structures_generated.h

/* This file is part of the LibMSWrite Library
   Copyright (C) 2001-2003 Clarence Dang <clarencedang@users.sourceforge.net>
 
   This library is free software; you can redistribute it and/or
   modify it under the terms of the GNU Library General Public
   License Version 2 as published by the Free Software Foundation.
 
   This library is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
   Library General Public License Version 2 for more details.
 
   You should have received a copy of the GNU Library General Public License
   Version 2 along with this library; see the file COPYING.LIB.  If not,
   write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
 * Boston, MA 02110-1301, USA.
 
   LibMSWrite Project Website:
   http://sourceforge.net/projects/libmswrite/
*/
 
/*
 * structures_generated - Internal MS Write file structures
 * This file was generated by make_structures_generated 0.51pre 2003/07/09.
 * ALL CHANGES MADE TO THIS FILE "WILL BE LOST IN TIME LIKE TEARS IN RAIN"!
 */
 
#ifndef __STRUCTURES_GENERATED_H__
#define __STRUCTURES_GENERATED_H__
 
#include "libmswrite_defs.h"
 
namespace MSWrite
{
    // $Id: structures_generated.h 490579 2005-12-22 12:32:17Z scripty $
    // 
    //    This file is part of the LibMSWrite Library
    //    Copyright (C) 2001-2003 Clarence Dang <clarencedang@users.sourceforge.net>
    // 
    //    This library is free software; you can redistribute it and/or
    //    modify it under the terms of the GNU Library General Public
    //    License Version 2 as published by the Free Software Foundation.
    // 
    //    This library is distributed in the hope that it will be useful,
    //    but WITHOUT ANY WARRANTY; without even the implied warranty of
    //    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
    //    Library General Public License Version 2 for more details.
    // 
    //    You should have received a copy of the GNU Library General Public License
    //    Version 2 along with this library; see the file COPYING.LIB.  If not,
    //    write to  the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor,
    //    Boston, MA 02110-1301, USA.
    // 
    //    LibMSWrite Project Website:
    //    http://sourceforge.net/projects/libmswrite/
    // 
    // DESCRIPTION
    // 
    // format.xml describes the basic structures that can be found in Microsoft(r)
    // Windows(r) Write files.  The majority of the information in format.xml
    // (excluding the Windows(r) BMP and WMF structures) is the result of
    // investigative file format work but a few portions of format.xml are derived
    // from a specification freely available from http://www.wotsit.org/.  The BMP
    // & WMF structures are from somewhere on the Internet (they are freely and
    // readily available) and can also be found in many programming books.
    // 
    // The data types and numbers in this document are intended to be interpreted
    // in the way they would be in Win3.x (Little Endian, 16-bit).
    // 
    // 
    //  Structure Fields:
    // 
    //      name #REQUIRED
    //      type #IMPLIED "Word"
    //      default #IMPLIED ""
    //      description #IMPLIED "" (also valid for Structures)
    //      verify #IMPLIED ""
    //      failVerify #IMPLIED "InvalidFormat"
    //      rep #IMPLIED "1"
    //      useThisMuch #IMPLIED "0"
    //      provideMethod #IMPLIED "0"
    //      protected #IMPLIED "0"  (also valid for Structures)
    // 
    //  All structure names will be automatically postfixed with "Generated".
    //  Derive structures from "Generated" structures (in structures*.cpp) e.g.
    // 
    //      class Header : public HeaderGenerated
    //      {
    //      }
    // 
    //  All fields will be automatically prefixed with "m_" to signify that
    //  they are member variables.
    // 
    //  Note that there are some limitations with make_structures_generated,
    //  most importantly:
    // 
    //      * any field of type Bit, must have
    //          - rep <=8
    //          - default = 0
    //          - may not cross a byte boundary!
    
    // Write file header (mostly from wotsit)
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class HeaderGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 98;
    
    private:
        HeaderGenerated (const HeaderGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [98];   // raw data from .wri file
        
        Word m_magic;                           // must be 0xBE31 (v3.0) or 0xBE32 (v3.1 because the file contains OLE)
        Word m_zero;
        Word m_magic2;                          // Magic number2 (must be 0xAB00)
        Word m_zero2 [4];
        DWord m_numCharBytesPlus128;        // #bytes of text,images & OLE (starting from Byte 128/Page 1)
        Word m_pageParaInfo;
        Word m_pageFootnoteTable;
        Word m_pageSectionProperty;     // I call it "Page Layout"
        Word m_pageSectionTable;
        Word m_pagePageTable;
        Word m_pageFontTable;
        Word m_zero3 [33];
        Word m_numPages;                        // (where a page is 128 bytes)
        
        HeaderGenerated &operator= (const HeaderGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word magicDefault = Word (0xBE31/*Write 3.0*/);
        static const Word zeroDefault = Word (0);
        static const Word magic2Default = Word (0xAB00);
        // cannot provide default for zero2 (is an array or of a non-internal type)
        // no default for numCharBytesPlus128
        // no default for pageParaInfo
        // no default for pageFootnoteTable
        // no default for pageSectionProperty
        // no default for pageSectionTable
        // no default for pagePageTable
        // no default for pageFontTable
        // cannot provide default for zero3 (is an array or of a non-internal type)
        // no default for numPages
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        HeaderGenerated ();
        virtual ~HeaderGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getMagic (void) const  {   return m_magic; }
        void setMagic (const Word val)  {   m_magic = val;  }
        
        Word getPageParaInfo (void) const   {   return m_pageParaInfo;  }
        void setPageParaInfo (const Word val)   {   m_pageParaInfo = val;   }
        
        Word getPageFootnoteTable (void) const  {   return m_pageFootnoteTable; }
        void setPageFootnoteTable (const Word val)  {   m_pageFootnoteTable = val;  }
        
        Word getPageSectionProperty (void) const    {   return m_pageSectionProperty;   }
        void setPageSectionProperty (const Word val)    {   m_pageSectionProperty = val;    }
        
        Word getPageSectionTable (void) const   {   return m_pageSectionTable;  }
        void setPageSectionTable (const Word val)   {   m_pageSectionTable = val;   }
        
        Word getPagePageTable (void) const  {   return m_pagePageTable; }
        void setPagePageTable (const Word val)  {   m_pagePageTable = val;  }
        
        Word getPageFontTable (void) const  {   return m_pageFontTable; }
        void setPageFontTable (const Word val)  {   m_pageFontTable = val;  }
        
        Word getNumPages (void) const   {   return m_numPages;  }
        void setNumPages (const Word val)   {   m_numPages = val;   }
    };
    
    // Page layout information (margins, dimensions, ...)
    class PageLayoutGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 33;
    
    private:
        PageLayoutGenerated (const PageLayoutGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [33];   // raw data from .wri file
        
        Byte m_magic102;                        // =102?
        Word m_magic512;                        // =512?
        Word m_pageHeight;
        Word m_pageWidth;
        Word m_pageNumberStart;             // start counting page numbers from this value (0xFFFF means ignore, set to 1 I guess)
        Word m_topMargin;
        Word m_textHeight;
        Word m_leftMargin;
        Word m_textWidth;
        
        Word m_magic256;                        // =256?
        
        Word m_headerFromTop;               // distance header is from top of page
        Word m_footerFromTop;               // distance footer is from top of page
        
        Word m_magic720;                        // 720
        Word m_zero;                            // 0
        Word m_magic1080;                       // 1080
        Word m_unknown;                     // ? (let's not be random and default to 0)
        Word m_zero2;                           // 0
        
        PageLayoutGenerated &operator= (const PageLayoutGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Byte magic102Default = Byte (102);
        static const Word magic512Default = Word (512);
        static const Word pageHeightDefault = Word (Inch2Twip (11));
        static const Word pageWidthDefault = Word (Inch2Twip (8.5));
        static const Word pageNumberStartDefault = Word (1);
        static const Word topMarginDefault = Word (Inch2Twip (1));
        static const Word textHeightDefault = Word (Inch2Twip (9));
        static const Word leftMarginDefault = Word (Inch2Twip (1.25));
        static const Word textWidthDefault = Word (Inch2Twip (6));
        static const Word magic256Default = Word (256);
        static const Word headerFromTopDefault = Word (Inch2Twip (0.75));
        static const Word footerFromTopDefault = Word (Inch2Twip (10.25 /*11.0 (m_pageHeight) - 0.75*/));
        static const Word magic720Default = Word (720);
        static const Word zeroDefault = Word (0);
        static const Word magic1080Default = Word (1080);
        static const Word unknownDefault = Word (0);
        static const Word zero2Default = Word (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        PageLayoutGenerated ();
        virtual ~PageLayoutGenerated ();
        
    };
    
    // No idea what this is supposed to do (from wotsit)
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class SectionDescriptorGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 10;
    
    private:
        SectionDescriptorGenerated (const SectionDescriptorGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [10];   // raw data from .wri file
        
        DWord m_afterEndCharByte;           // byte of character just after end of section
        Word m_undefined;
        DWord m_sectionPropertyLocation;    // byte address of corresponding sectionProperty (I call it a "Page Layout" which is more obvious IMHO)
        
        SectionDescriptorGenerated &operator= (const SectionDescriptorGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for afterEndCharByte
        static const Word undefinedDefault = Word (0);
        // no default for sectionPropertyLocation
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        SectionDescriptorGenerated ();
        virtual ~SectionDescriptorGenerated ();
        
        
        //
        // get and set functions
        //
        
        DWord getAfterEndCharByte (void) const  {   return m_afterEndCharByte;  }
        void setAfterEndCharByte (const DWord val)  {   m_afterEndCharByte = val;   }
        
        DWord getSectionPropertyLocation (void) const   {   return m_sectionPropertyLocation;   }
        void setSectionPropertyLocation (const DWord val)   {   m_sectionPropertyLocation = val;    }
    };
    
    // (from wotsit)
    class SectionDescriptor;
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class SectionTableGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 24;
    
    private:
        SectionTableGenerated (const SectionTableGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [24];   // raw data from .wri file
        
        Word m_numSectionDescriptors;
        Word m_undefined;
        SectionDescriptor *m_sed [2];
        
        SectionTableGenerated &operator= (const SectionTableGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word numSectionDescriptorsDefault = Word (2);
        static const Word undefinedDefault = Word (0);
        // no default for sed
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        SectionTableGenerated ();
        virtual ~SectionTableGenerated ();
        
    };
    
    class FontGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 3;
    
    private:
        FontGenerated (const FontGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [3];    // raw data from .wri file
        
        Word m_numDataBytes;                    // number of bytes that follow
        Byte m_family;
        
        // - - - followed by Byte *fontName - - - 
        
        FontGenerated &operator= (const FontGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word numDataBytesDefault = Word (0);
        static const Byte familyDefault = Byte (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FontGenerated ();
        virtual ~FontGenerated ();
        
        
        //
        // get and set functions
        //
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        Word getNumDataBytes (void) const   {   return m_numDataBytes;  }
        void setNumDataBytes (const Word val)   {   m_numDataBytes = val;   }
        
        Byte getFamily (void) const {   return m_family;    }
        void setFamily (const Byte val) {   m_family = val; }
    };
    
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class FontTableGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 2;
    
    private:
        FontTableGenerated (const FontTableGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [2];    // raw data from .wri file
        
        Word m_numFonts;
        
        // - - - followed by a list of Font(s) - - - 
        
        FontTableGenerated &operator= (const FontTableGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word numFontsDefault = Word (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FontTableGenerated ();
        virtual ~FontTableGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getNumFonts (void) const   {   return m_numFonts;  }
        void setNumFonts (const Word val)   {   m_numFonts = val;   }
    };
    
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class PagePointerGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 6;
    
    private:
        PagePointerGenerated (const PagePointerGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [6];    // raw data from .wri file
        
        Word m_pageNumber;
        DWord m_firstCharByte;              // first character on page
        
        PagePointerGenerated &operator= (const PagePointerGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for pageNumber
        // no default for firstCharByte
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        PagePointerGenerated ();
        virtual ~PagePointerGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getPageNumber (void) const {   return m_pageNumber;    }
        void setPageNumber (const Word val) {   m_pageNumber = val; }
        
        DWord getFirstCharByte (void) const {   return m_firstCharByte; }
        void setFirstCharByte (const DWord val) {   m_firstCharByte = val;  }
    };
    
    // File/Repaginate function
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class PageTableGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 4;
    
    private:
        PageTableGenerated (const PageTableGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [4];    // raw data from .wri file
        
        Word m_numPagePointers;
        Word m_zero;
        
        // - - - followed by a list of PagePointer(s) - - - 
        
        PageTableGenerated &operator= (const PageTableGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word numPagePointersDefault = Word (0);
        static const Word zeroDefault = Word (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        PageTableGenerated ();
        virtual ~PageTableGenerated ();
        
    };
    
    // A pointer to the actual formatting properties (formatting properties are shared to save space)
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class FormatPointerGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 6;
    
    private:
        FormatPointerGenerated (const FormatPointerGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [6];    // raw data from .wri file
        
        DWord m_afterEndCharBytePlus128;    // last character it points to + 1
        Word m_formatPropertyOffset;        // location of relevant FormatProperty (or 0xFFFF for defaults)
        
        FormatPointerGenerated &operator= (const FormatPointerGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for afterEndCharBytePlus128
        // no default for formatPropertyOffset
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FormatPointerGenerated ();
        virtual ~FormatPointerGenerated ();
        
        
        //
        // get and set functions
        //
        
        DWord getAfterEndCharBytePlus128 (void) const   {   return m_afterEndCharBytePlus128;   }
        void setAfterEndCharBytePlus128 (const DWord val)   {   m_afterEndCharBytePlus128 = val;    }
        
        Word getFormatPropertyOffset (void) const   {   return m_formatPropertyOffset;  }
        void setFormatPropertyOffset (const Word val)   {   m_formatPropertyOffset = val;   }
    };
    
    // Character Properties
    class FormatCharPropertyGenerated : public NeedsDevice, public UseThisMuch
    {
    public:
        static const int s_size = 7;
    
    private:
        FormatCharPropertyGenerated (const FormatCharPropertyGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [7];    // raw data from .wri file
        
        // Byte 0 
        Byte m_numDataBytes;                    // number of bytes that follow
        
        // Byte 1 
        Byte m_unknown;                     // =0? or =1?
        
        // Byte 2 
        unsigned m_isBold   :   1;
        unsigned m_isItalic :   1;
        unsigned m_fontCodeLow  :   6;
        
        // Byte 3 
        Byte m_fontSize;                        // half the fontSize?
        
        // Byte 4 
        unsigned m_isUnderlined :   1;
        unsigned m_zero :   5;
        unsigned m_isPageNumber :   1;      // seems to be set for '(page)' number variables - only in headers/footers?
        unsigned m_zero2    :   1;
        
        // Byte 5 
        unsigned m_fontCodeHigh :   3;      // not sure if this is true
        unsigned m_zero3    :   5;
        
        // Byte 6 
        Byte m_position;                        // 0=normal, 1-127=superscript, 128-255=subscript (I tested mainly boundary values so I don't know if it's this is totally true)
        
        FormatCharPropertyGenerated &operator= (const FormatCharPropertyGenerated &rhs);
        
        Word getNumDataBytes (void) const   {   return UseThisMuch::getNeedNumDataBytes (); }
        // note: you cannot set numDataBytes
        void updateNumDataBytes (void)  {   m_numDataBytes = UseThisMuch::getNeedNumDataBytes ();   }
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Byte numDataBytesDefault = Byte (0);
        static const Byte unknownDefault = Byte (1);
        static const unsigned isBoldDefault = unsigned (0);
        static const unsigned isItalicDefault = unsigned (0);
        // cannot provide default for fontCodeLow (is an array or of a non-internal type)
        static const Byte fontSizeDefault = Byte (24);
        static const unsigned isUnderlinedDefault = unsigned (0);
        // cannot provide default for zero (is an array or of a non-internal type)
        static const unsigned isPageNumberDefault = unsigned (0);
        static const unsigned zero2Default = unsigned (0);
        // cannot provide default for fontCodeHigh (is an array or of a non-internal type)
        // cannot provide default for zero3 (is an array or of a non-internal type)
        static const Byte positionDefault = Byte (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FormatCharPropertyGenerated ();
        virtual ~FormatCharPropertyGenerated ();
        
        
        //
        // get and set functions
        //
        
        bool getIsBold (void) const {   return m_isBold;    }
        void setIsBold (const bool val) {   m_isBold = val; signalHaveSetData (m_isBold == bool (0), 8/*offset*/ + 1/*size*/);  }
        
        bool getIsItalic (void) const   {   return m_isItalic;  }
        void setIsItalic (const bool val)   {   m_isItalic = val;   signalHaveSetData (m_isItalic == bool (0), 9/*offset*/ + 1/*size*/);    }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        unsigned getFontCodeLow (void) const    {   return m_fontCodeLow;   }
        void setFontCodeLow (const unsigned val)    {   m_fontCodeLow = val;    signalHaveSetData (m_fontCodeLow == unsigned (0), 10/*offset*/ + 6/*size*/);    }
        
        bool getIsUnderlined (void) const   {   return m_isUnderlined;  }
        void setIsUnderlined (const bool val)   {   m_isUnderlined = val;   signalHaveSetData (m_isUnderlined == bool (0), 24/*offset*/ + 1/*size*/);   }
        
        bool getIsPageNumber (void) const   {   return m_isPageNumber;  }
        void setIsPageNumber (const bool val)   {   m_isPageNumber = val;   signalHaveSetData (m_isPageNumber == bool (0), 30/*offset*/ + 1/*size*/);   }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        unsigned getFontCodeHigh (void) const   {   return m_fontCodeHigh;  }
        void setFontCodeHigh (const unsigned val)   {   m_fontCodeHigh = val;   signalHaveSetData (m_fontCodeHigh == unsigned (0), 32/*offset*/ + 3/*size*/);   }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        Byte getPosition (void) const   {   return m_position;  }
        void setPosition (const Byte val)   {   m_position = val;   signalHaveSetData (m_position == Byte (0), 40/*offset*/ + 8/*size*/);   }
    };
    
    // Paragraph Tabulator(s) Properties
    class FormatParaPropertyTabulatorGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 4;
    
    private:
        FormatParaPropertyTabulatorGenerated (const FormatParaPropertyTabulatorGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [4];    // raw data from .wri file
        
        Word m_indent;
        Byte m_type;                            // 0=normal,3=decimal...all that the GUI allows
        Byte m_zero;
        
        FormatParaPropertyTabulatorGenerated &operator= (const FormatParaPropertyTabulatorGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word indentDefault = Word (0);
        static const Byte typeDefault = Byte (0);
        static const Byte zeroDefault = Byte (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FormatParaPropertyTabulatorGenerated ();
        virtual ~FormatParaPropertyTabulatorGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getIndent (void) const {   return m_indent;    }
        void setIndent (const Word val) {   m_indent = val; }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        Byte getType (void) const   {   return m_type;  }
        void setType (const Byte val)   {   m_type = val;   }
    };
    
    // Paragraph Properties
    class FormatParaPropertyTabulator;
    class FormatParaPropertyGenerated : public NeedsDevice, public UseThisMuch
    {
    public:
        static const int s_size = 79;
    
    private:
        FormatParaPropertyGenerated (const FormatParaPropertyGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [79];   // raw data from .wri file
        
        Byte m_numDataBytes;                    // number of bytes that follow
        Byte m_magic0_60_or_61;             // =0? =60? =61? 60 is the most common
        Byte m_alignment;
        Word m_magic30;                     // =30?
        Word m_rightIndent;                 // indent from right margin + right margin (if in header/footer)
        Word m_leftIndent;                  // indent from left margin + left margin (if in header/footer)
        Short m_leftIndentFirstLine;        // indent of first line relative to leftIndent (may be negative for a "hanging indent")
        Word m_lineSpacing;                 // measurement in twips?
        Word m_zero [2];
        
        // Type Byte 
        unsigned m_headerOrFooter   :   1;  // 0=header,1=footer (if not normal paragraph)
        unsigned m_isNotNormalParagraph :   2;// 0=normal paragraph;1,2?,3?=header/footer
        unsigned m_isOnFirstPage    :   1;  // again, valid only if not normal paragraph
        unsigned m_isObject :   1;          // 0=image/OLE,1=text
        unsigned m_zero2    :   3;
        
        Byte m_zero3 [5];
        FormatParaPropertyTabulator *m_tab [14];
        
        FormatParaPropertyGenerated &operator= (const FormatParaPropertyGenerated &rhs);
        
        Word getNumDataBytes (void) const   {   return UseThisMuch::getNeedNumDataBytes (); }
        // note: you cannot set numDataBytes
        void updateNumDataBytes (void)  {   m_numDataBytes = UseThisMuch::getNeedNumDataBytes ();   }
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Byte numDataBytesDefault = Byte (0);
        static const Byte magic0_60_or_61Default = Byte (60);
        static const Byte alignmentDefault = Byte (0);
        static const Word magic30Default = Word (30);
        static const Word rightIndentDefault = Word (0);
        static const Word leftIndentDefault = Word (0);
        static const Short leftIndentFirstLineDefault = Short (0);
        static const Word lineSpacingDefault = Word (240);
        // cannot provide default for zero (is an array or of a non-internal type)
        static const unsigned headerOrFooterDefault = unsigned (0);
        // cannot provide default for isNotNormalParagraph (is an array or of a non-internal type)
        static const unsigned isOnFirstPageDefault = unsigned (0);
        static const unsigned isObjectDefault = unsigned (0);
        // cannot provide default for zero2 (is an array or of a non-internal type)
        // cannot provide default for zero3 (is an array or of a non-internal type)
        // no default for tab
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FormatParaPropertyGenerated ();
        virtual ~FormatParaPropertyGenerated ();
        
        
        //
        // get and set functions
        //
        
        Byte getAlignment (void) const  {   return m_alignment; }
        void setAlignment (const Byte val)  {   m_alignment = val;  signalHaveSetData (m_alignment == Byte (0), 8/*offset*/ + 8/*size*/);   }
        
        Word getRightIndent (void) const    {   return m_rightIndent;   }
        void setRightIndent (const Word val)    {   m_rightIndent = val;    signalHaveSetData (m_rightIndent == Word (0), 32/*offset*/ + 16/*size*/);   }
        
        Word getLeftIndent (void) const {   return m_leftIndent;    }
        void setLeftIndent (const Word val) {   m_leftIndent = val; signalHaveSetData (m_leftIndent == Word (0), 48/*offset*/ + 16/*size*/);    }
        
        Word getLineSpacing (void) const    {   return m_lineSpacing;   }
        void setLineSpacing (const Word val)    {   m_lineSpacing = val;    signalHaveSetData (m_lineSpacing == Word (240), 80/*offset*/ + 16/*size*/); }
        
        bool getHeaderOrFooter (void) const {   return m_headerOrFooter;    }
        void setHeaderOrFooter (const bool val) {   m_headerOrFooter = val; signalHaveSetData (m_headerOrFooter == bool (0), 128/*offset*/ + 1/*size*/);    }
        
        unsigned getIsNotNormalParagraph (void) const   {   return m_isNotNormalParagraph;  }
        void setIsNotNormalParagraph (const unsigned val)   {   m_isNotNormalParagraph = val;   signalHaveSetData (m_isNotNormalParagraph == unsigned (0), 129/*offset*/ + 2/*size*/);  }
        
        bool getIsOnFirstPage (void) const  {   return m_isOnFirstPage; }
        void setIsOnFirstPage (const bool val)  {   m_isOnFirstPage = val;  signalHaveSetData (m_isOnFirstPage == bool (0), 131/*offset*/ + 1/*size*/); }
        
        bool getIsObject (void) const   {   return m_isObject;  }
        void setIsObject (const bool val)   {   m_isObject = val;   signalHaveSetData (m_isObject == bool (0), 132/*offset*/ + 1/*size*/);  }
    };
    
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class FormatInfoPageGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 128;
    
    private:
        FormatInfoPageGenerated (const FormatInfoPageGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [128];  // raw data from .wri file
        
        DWord m_firstCharBytePlus128;
        Byte m_packedStructs [123];     // array of FormatPointers and FormatCharProperties/FormatParaProperties
        Byte m_numFormatPointers;
        
        FormatInfoPageGenerated &operator= (const FormatInfoPageGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for firstCharBytePlus128
        // cannot provide default for packedStructs (is an array or of a non-internal type)
        static const Byte numFormatPointersDefault = Byte (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        FormatInfoPageGenerated ();
        virtual ~FormatInfoPageGenerated ();
        
    };
    
    // first header of a .BMP file (_not_ stored in .WRI)
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class BMP_BitmapFileHeaderGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 14;
    
    private:
        BMP_BitmapFileHeaderGenerated (const BMP_BitmapFileHeaderGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [14];   // raw data from .wri file
        
        Word m_magic;
        DWord m_totalBytes;
        Word m_zero [2];
        DWord m_actualImageOffset;
        
        BMP_BitmapFileHeaderGenerated &operator= (const BMP_BitmapFileHeaderGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word magicDefault = Word (Word ('B') + (Word ('M') << 8));
        // no default for totalBytes
        // cannot provide default for zero (is an array or of a non-internal type)
        // no default for actualImageOffset
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        BMP_BitmapFileHeaderGenerated ();
        virtual ~BMP_BitmapFileHeaderGenerated ();
        
        
        //
        // get and set functions
        //
        
        DWord getTotalBytes (void) const    {   return m_totalBytes;    }
        void setTotalBytes (const DWord val)    {   m_totalBytes = val; }
        
        DWord getActualImageOffset (void) const {   return m_actualImageOffset; }
        void setActualImageOffset (const DWord val) {   m_actualImageOffset = val;  }
    };
    
    // second header of a .BMP file (_not_ stored in .WRI)
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class BMP_BitmapInfoHeaderGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 40;
    
    private:
        BMP_BitmapInfoHeaderGenerated (const BMP_BitmapInfoHeaderGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [40];   // raw data from .wri file
        
        DWord m_numHeaderBytes;
        Long m_width;
        Long m_height;
        Word m_numPlanes;                       // always==1
        Word m_bitsPerPixel;
        DWord m_compression;
        DWord m_sizeImage;
        Long m_xPixelsPerMeter;
        Long m_yPixelsPerMeter;
        DWord m_coloursUsed;
        DWord m_coloursImportant;
        
        BMP_BitmapInfoHeaderGenerated &operator= (const BMP_BitmapInfoHeaderGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const DWord numHeaderBytesDefault = DWord (s_size);
        // no default for width
        // no default for height
        static const Word numPlanesDefault = Word (1);
        // no default for bitsPerPixel
        static const DWord compressionDefault = DWord (0);
        static const DWord sizeImageDefault = DWord (0);
        static const Long xPixelsPerMeterDefault = Long (0);
        static const Long yPixelsPerMeterDefault = Long (0);
        static const DWord coloursUsedDefault = DWord (0);
        // no default for coloursImportant
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        BMP_BitmapInfoHeaderGenerated ();
        virtual ~BMP_BitmapInfoHeaderGenerated ();
        
        
        //
        // get and set functions
        //
        
        Long getWidth (void) const  {   return m_width; }
        void setWidth (const Long val)  {   m_width = val;  }
        
        Long getHeight (void) const {   return m_height;    }
        void setHeight (const Long val) {   m_height = val; }
        
        Word getNumPlanes (void) const  {   return m_numPlanes; }
        void setNumPlanes (const Word val)  {   m_numPlanes = val;  }
        
        Word getBitsPerPixel (void) const   {   return m_bitsPerPixel;  }
        void setBitsPerPixel (const Word val)   {   m_bitsPerPixel = val;   }
        
        DWord getCompression (void) const   {   return m_compression;   }
        void setCompression (const DWord val)   {   m_compression = val;    }
        
        DWord getSizeImage (void) const {   return m_sizeImage; }
        void setSizeImage (const DWord val) {   m_sizeImage = val;  }
        
        Long getXPixelsPerMeter (void) const    {   return m_xPixelsPerMeter;   }
        void setXPixelsPerMeter (const Long val)    {   m_xPixelsPerMeter = val;    }
        
        Long getYPixelsPerMeter (void) const    {   return m_yPixelsPerMeter;   }
        void setYPixelsPerMeter (const Long val)    {   m_yPixelsPerMeter = val;    }
        
        DWord getColoursUsed (void) const   {   return m_coloursUsed;   }
        void setColoursUsed (const DWord val)   {   m_coloursUsed = val;    }
        
        DWord getColoursImportant (void) const  {   return m_coloursImportant;  }
        void setColoursImportant (const DWord val)  {   m_coloursImportant = val;   }
    };
    
    // element of colourTable, triad of RGB
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class BMP_BitmapColourIndexGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 4;
    
    private:
        BMP_BitmapColourIndexGenerated (const BMP_BitmapColourIndexGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [4];    // raw data from .wri file
        
        Byte m_blue;
        Byte m_green;
        Byte m_red;
        Byte m_reserved;
        
        BMP_BitmapColourIndexGenerated &operator= (const BMP_BitmapColourIndexGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for blue
        // no default for green
        // no default for red
        static const Byte reservedDefault = Byte (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        BMP_BitmapColourIndexGenerated ();
        virtual ~BMP_BitmapColourIndexGenerated ();
        
        
        //
        // get and set functions
        //
        
        Byte getBlue (void) const   {   return m_blue;  }
        void setBlue (const Byte val)   {   m_blue = val;   }
        
        Byte getGreen (void) const  {   return m_green; }
        void setGreen (const Byte val)  {   m_green = val;  }
        
        Byte getRed (void) const    {   return m_red;   }
        void setRed (const Byte val)    {   m_red = val;    }
    };
    
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class BitmapHeaderGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 14;
    
    private:
        BitmapHeaderGenerated (const BitmapHeaderGenerated &rhs);   //TODO: copy constructor
    
    protected:
        Byte m_data [14];   // raw data from .wri file
        
        Word m_zero;
        Word m_width;
        Word m_height;
        Word m_widthBytes;
        Byte m_numPlanes;                       // always 1 for mono BMP or the entire struct is 0 for WMF
        Byte m_bitsPerPixel;
        DWord m_zero2;
        
        BitmapHeaderGenerated &operator= (const BitmapHeaderGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word zeroDefault = Word (0);
        static const Word widthDefault = Word (0);
        static const Word heightDefault = Word (0);
        static const Word widthBytesDefault = Word (0);
        static const Byte numPlanesDefault = Byte (0);
        static const Byte bitsPerPixelDefault = Byte (0);
        static const DWord zero2Default = DWord (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        BitmapHeaderGenerated ();
        virtual ~BitmapHeaderGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getWidth (void) const  {   return m_width; }
        void setWidth (const Word val)  {   m_width = val;  }
        
        Word getHeight (void) const {   return m_height;    }
        void setHeight (const Word val) {   m_height = val; }
        
        Word getWidthBytes (void) const {   return m_widthBytes;    }
        void setWidthBytes (const Word val) {   m_widthBytes = val; }
        
        Byte getNumPlanes (void) const  {   return m_numPlanes; }
        void setNumPlanes (const Byte val)  {   m_numPlanes = val;  }
        
        Byte getBitsPerPixel (void) const   {   return m_bitsPerPixel;  }
        void setBitsPerPixel (const Byte val)   {   m_bitsPerPixel = val;   }
    };
    
    // 'Standard WMF' Header
    // [PRIVATE] this is a private libmswrite class, do not use it!
    class WMFHeaderGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 18;
    
    private:
        WMFHeaderGenerated (const WMFHeaderGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [18];   // raw data from .wri file
        
        Word m_fieldType;                       // 0=memory WMF,1=file WMF; so will never be 0
        Word m_headerSize;                  // (in Words)
        Word m_winVersion;                  // correct for Win>=3.0
        DWord m_fileSize;                       // (in Words)
        Word m_numObjects;                  // ?
        DWord m_maxRecordSize;              // (in Words)
        Word m_zero;
        
        WMFHeaderGenerated &operator= (const WMFHeaderGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        static const Word fieldTypeDefault = Word (1);
        static const Word headerSizeDefault = Word (9);
        static const Word winVersionDefault = Word (0x0300);
        // no default for fileSize
        static const Word numObjectsDefault = Word (0);
        // no default for maxRecordSize
        static const Word zeroDefault = Word (0);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        WMFHeaderGenerated ();
        virtual ~WMFHeaderGenerated ();
        
        
        //
        // get and set functions
        //
        
        DWord getFileSize (void) const  {   return m_fileSize;  }
        void setFileSize (const DWord val)  {   m_fileSize = val;   }
        
        DWord getMaxRecordSize (void) const {   return m_maxRecordSize; }
        void setMaxRecordSize (const DWord val) {   m_maxRecordSize = val;  }
    };
    
    class BitmapHeader;
    class ImageGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 40;
    
    private:
        ImageGenerated (const ImageGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [40];   // raw data from .wri file
        
        // - - - METAFILEPICT begin - - - 
        
        Word m_mappingMode;                 // type of image: 0xE3 for mono bitmap, != 0xE3 for WMF (usually 0x88)
        Word m_MFP_width;
        Word m_MFP_height;
        Word m_MFP_unknown;
        
        // - - - METAFILEPICT end - - - 
        
        Word m_indent;                          // horizontal position from left margin
        Word m_width;                           // WMF width only, use m_bmh for bitmaps
        Word m_height;                          // WMF height only, use m_bmh for bitmaps
        Word m_zero;                            // ??? varies too much, default to 0
        
        BitmapHeader *m_bmh;                    // only valid for mono BMPs i.e. when mappingMode == 0xe3
        
        Word m_numHeaderBytes;              // size of this header? (why isn't it the first element?)
        DWord m_numDataBytes;               // number of image bytes
        Word m_horizontalScalingRel1000;    // horizontal scaling (/1000)*100% (BMPs only)
        Word m_verticalScalingRel1000;  // vertical scaling (/1000)*100% (BMPs only)
        
        // - - - Followed by either a strangely packed monochrome bitmap or a Standard WMF (with WMFHeader, of course) - - - 
        
        ImageGenerated &operator= (const ImageGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for mappingMode
        // no default for MFP_width
        // no default for MFP_height
        static const Word MFP_unknownDefault = Word (0);
        static const Word indentDefault = Word (0);
        // no default for width
        // no default for height
        static const Word zeroDefault = Word (0);
        // no default for bmh
        static const Word numHeaderBytesDefault = Word (s_size);
        // no default for numDataBytes
        static const Word horizontalScalingRel1000Default = Word (1000);
        static const Word verticalScalingRel1000Default = Word (1000);
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        ImageGenerated ();
        virtual ~ImageGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getIndent (void) const {   return m_indent;    }
        void setIndent (const Word val) {   m_indent = val; }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        Word getNumHeaderBytes (void) const {   return m_numHeaderBytes;    }
        void setNumHeaderBytes (const Word val) {   m_numHeaderBytes = val; }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        DWord getNumDataBytes (void) const  {   return m_numDataBytes;  }
        void setNumDataBytes (const DWord val)  {   m_numDataBytes = val;   }
    };
    
    class OLEGenerated : public NeedsDevice
    {
    public:
        static const int s_size = 40;
    
    private:
        OLEGenerated (const OLEGenerated &rhs); //TODO: copy constructor
    
    protected:
        Byte m_data [40];   // raw data from .wri file
        
        Word m_mappingMode;
        DWord m_zero;
        Word m_objectType;                  // 1=static, 2=embedded, 3=link
        
        Word m_indent;                          // horizontal position from left margin
        Word m_width;
        Word m_height;
        Word m_zero2;
        DWord m_numDataBytes;               // number of OLE bytes
        DWord m_zero3;
        DWord m_objectName;                 // name of the object in hex
        Word m_zero4;
        Word m_numHeaderBytes;              // size of this header
        DWord m_zero5;
        Word m_widthScaledRel1000;          // horizontal scaling (/1000)*100% (same as Image?)
        Word m_heightScaledRel1000;     // vertical scaling (/1000)*100% (same as Image?)
        
        // - - - Followed by OLE data - - - 
        
        OLEGenerated &operator= (const OLEGenerated &rhs);
        
        virtual bool verifyVariables (void);
        virtual bool writeToArray (void);
        
        // no default for mappingMode
        static const DWord zeroDefault = DWord (0);
        // no default for objectType
        // no default for indent
        // no default for width
        // no default for height
        static const Word zero2Default = Word (0);
        // no default for numDataBytes
        static const DWord zero3Default = DWord (0);
        // no default for objectName
        static const Word zero4Default = Word (0);
        // no default for numHeaderBytes
        static const DWord zero5Default = DWord (0);
        // no default for widthScaledRel1000
        // no default for heightScaledRel1000
    
    public:
        // [PRIVATE] do not call!
        virtual bool readFromDevice (void);
        virtual bool writeToDevice (void);
        
        OLEGenerated ();
        virtual ~OLEGenerated ();
        
        
        //
        // get and set functions
        //
        
        Word getObjectType (void) const {   return m_objectType;    }
        void setObjectType (const Word val) {   m_objectType = val; }
        
        Word getIndent (void) const {   return m_indent;    }
        void setIndent (const Word val) {   m_indent = val; }
        
        Word getWidth (void) const  {   return m_width; }
        void setWidth (const Word val)  {   m_width = val;  }
        
        Word getHeight (void) const {   return m_height;    }
        void setHeight (const Word val) {   m_height = val; }
        
        // [PRIVATE] these are private libmswrite methods, do not call them!
        DWord getNumDataBytes (void) const  {   return m_numDataBytes;  }
        void setNumDataBytes (const DWord val)  {   m_numDataBytes = val;   }
        
        DWord getObjectName (void) const    {   return m_objectName;    }
        void setObjectName (const DWord val)    {   m_objectName = val; }
        
        Word getWidthScaledRel1000 (void) const {   return m_widthScaledRel1000;    }
        void setWidthScaledRel1000 (const Word val) {   m_widthScaledRel1000 = val; }
        
        Word getHeightScaledRel1000 (void) const    {   return m_heightScaledRel1000;   }
        void setHeightScaledRel1000 (const Word val)    {   m_heightScaledRel1000 = val;    }
    };
}   // namespace MSWrite    {
 
#endif  // __STRUCTURES_GENERATED_H__
 
// end of structures_generated.h