libmswrite.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/
*/
 
#ifndef __LIBMSWRITE_H__
#define __LIBMSWRITE_H__
 
#include "structures.h"
#include "structures_private.h"
 
namespace MSWrite
{
#if 0
    class DocumentInfo
    {
    private:
        Word m_numObjects;
        bool m_hasHeader;
        bool m_hasFooter;
        bool m_hasHeaderOnFirstPage;
        bool m_hasFooterOnFirstPage;
 
    public:
        DocumentInfo ()
        {
            m_numObjects = 0;
            m_hasHeader = m_hasFooter = false;
            m_hasHeaderOnFirstPage = m_hasFooterOnFirstPage = false;
        }
 
        Word getNumObjects (void) const {   return m_numObjects;    }
        void setNumObjects (const Word numObjects)  {   m_numObjects = numObjects;  }
 
        bool getHasHeader (void) const  {   return m_hasHeader; }
        void setHasHeader (const bool hasHeader)    {   m_hasHeader = hasHeader;    }
 
        bool getHasFooter (void) const  {   return m_hasFooter; }
        void setHasFooter (const bool hasFooter)    {   m_hasFooter = hasFooter;    }
 
        bool getHasHeaderOnFirstPage (void) const   {   return m_hasHeaderOnFirstPage;  }
        void setHasHeaderOnFirstPage (const bool hasHeaderOnFirstPage)  {   m_hasHeader = hasHeaderOnFirstPage; }
 
        bool getHasFooterOnFirstPage (void) const   {   return m_hasFooterOnFirstPage;  }
        void setHasFooterOnFirstPage (const bool hasFooterOnFirstPage)  {   m_hasFooterOnFirstPage = hasFooterOnFirstPage;  }
    };
#endif
 
 
    // [PRIVATE] don't use
    class FormatInfo : public NeedsDevice, public NeedsHeader
    {
    private:
        List <FormatInfoPage> m_formatInfoPageList;
        List <FormatInfoPage>::Iterator m_formatInfoPageIterator;
        DWord m_nextChar;
 
        enum FormatInfoPageTypes m_type;
 
        friend class InternalParser;
        friend class InternalGenerator;
            Word m_leftMargin, m_rightMargin;   // for ParaType only
            FontTable *m_fontTable; // for CharType only
            void setMargins (const Word leftMargin, const Word rightMargin)
            {
                m_leftMargin = leftMargin, m_rightMargin = rightMargin;
            }
            void setFontTable (FontTable *fontTable)    {   m_fontTable = fontTable;    }
 
        FormatInfo &operator= (const FormatInfo &rhs);  // TODO
    public:
        FormatInfo ();
        virtual ~FormatInfo ();
 
        void setType (const enum FormatInfoPageTypes t) {   m_type = t; }
 
        bool readFromDevice (void);
        bool writeToDevice (const void *defaultProperty);
 
        void *begin (void);
        void *next (void);
        bool end (void) /*const*/;
 
        bool add (const void *property, const bool force = false);
    };
 
 
    class Generator;
    class Parser
    {
    protected:
        Generator *m_generator;
 
    public:
        Parser (Generator *generator = NULL)
        {
            setGenerator (generator);
        }
        
        virtual ~Parser ()
        {
        }
 
        void setGenerator (Generator *generator)
        {
            m_generator = generator;
        }
 
        virtual bool parse (void) = 0;
    };
 
 
    class Generator
    {
    public:
        Generator ();
        virtual ~Generator ();
 
        virtual bool writeDocumentBegin (const Word format, const PageLayout *pageLayout) = 0;
        virtual bool writeDocumentEnd (const Word format, const PageLayout *pageLayout) = 0;
 
        virtual bool writeFooterBegin (void)    {   return true;    }
        virtual bool writeFooterEnd(void)   {   return true;    }
 
        virtual bool writeHeaderBegin (void)    {   return true;    }
        virtual bool writeHeaderEnd (void)  {   return true;    }
 
        virtual bool writeBodyBegin (void) = 0;
        virtual bool writeBodyEnd (void)    = 0;
 
        virtual bool writeParaInfoBegin (const FormatParaProperty * /*paraProperty*/,
                                                    const OLE * /*ole*/ = NULL,
                                                    const Image * /*image*/ = NULL) {   return true;    }
        virtual bool writeParaInfoEnd (const FormatParaProperty * /*paraProperty*/,
                                                    const OLE * /*ole*/ = NULL,
                                                    const Image * /*image*/ = NULL) {   return true;    }
 
        virtual bool writeCharInfoBegin (const FormatCharProperty * /*charProperty*/)   {   return true;    }
        virtual bool writeCharInfoEnd (const FormatCharProperty * /*charProperty*/,
                                                    const bool /*endOfParagraph*/ = false)  {   return true;    }
 
 
        virtual bool writeBinary (const Byte * /*buffer*/, const DWord /*length*/)  {   return true;    }
 
 
        /*
         *
         * Text output
         *
         */
 
        bool processText (const Byte *string, bool willReachEndOfParagraph);
        virtual bool writeText (const Byte *string) = 0;
 
 
        virtual bool writePageNew (const int /*pageNumberClaimed*/ = 0)
        {
            return true;
        };
        virtual bool writePageBreak (void)
        {
            return writeText ((const Byte *) "\xc");    // i.e. (char)12
        }
        virtual bool writePageNumber (void)
        {
            return writeText ((const Byte *) "\x1");    // i.e. (char)1
        }
        virtual bool writeCarriageReturn (void)
        {
            return writeText ((const Byte *) "\xd");    // i.e. (char)13
        }
        virtual bool writeNewLine (const bool /*endOfParagraph*/ = true)
        {
            return writeText ((const Byte *) "\n"); // i.e. (char)10
        }
        virtual bool writeOptionalHyphen (void)
        {
            return writeText ((const Byte *) "-");
        }
 
        virtual void sigProgress (const int /*value*/)  {}
    };
 
 
    class InternalParser : public Parser, public NeedsDevice
    {
    private:
        Header *m_header;
        SectionTable *m_sectionTable;
        PageLayout *m_pageLayout;
        PageTable *m_pageTable;
        FontTable *m_fontTable;
        FormatInfo *m_paragraphInfo, *m_characterInfo;
 
        Image *m_image;
        OLE *m_ole;
 
    public:
        InternalParser ();
        virtual ~InternalParser ();
 
        bool parse (void);
    };
 
 
    class InternalGenerator : public Generator, public NeedsDevice
    {
    private:
        Header *m_header;
        SectionTable *m_sectionTable;
        PageLayout *m_pageLayout;
        PageTable *m_pageTable;
        FontTable *m_fontTable;
        FormatInfo *m_paragraphInfo, *m_characterInfo;
 
        Image *m_image;
        OLE *m_ole;
        
        bool seekNextPage (void);
        
    public:
        InternalGenerator ();
        virtual ~InternalGenerator ();
 
        bool writeDocumentBegin (const Word format, const PageLayout *pageLayout);
        bool writeDocumentEnd (const Word format, const PageLayout *pageLayout);
 
        bool writeFooterBegin (void)
        {
            // don't care
            return true;
        }
        bool writeFooterEnd(void)
        {
            // don't care
            return true;
        }
 
        bool writeHeaderBegin (void)
        {
            // don't care
            return true;
        }
        bool writeHeaderEnd (void)
        {
            // don't care
            return true;
        }
 
        bool writeBodyBegin (void)
        {
            // don't care
            return true;
        }
 
        bool writeBodyEnd (void)
        {
            // don't care
            return true;
        }
 
 
        bool writeParaInfoBegin (const FormatParaProperty *paraProperty,
                                            const OLE *oleHeader = NULL,
                                            const Image *imageHeader = NULL);
        bool writeParaInfoEnd (const FormatParaProperty *paraProperty,
                                        const OLE *oleHeader = NULL,
                                        const Image *imageHeader = NULL);
 
        bool writeCharInfoBegin (const FormatCharProperty *charProperty);
        bool writeCharInfoEnd (const FormatCharProperty *charProperty,
                                        const bool endOfParagraph = false);
 
 
        bool writeBinary (const Byte *buffer, const DWord length);
 
 
        bool writeText (const Byte *string);
 
 
        bool writePageNew (const int pageNumberClaimed = 0);
 
        bool writePageBreak (void)
        {
            return writeText ((const Byte *) "\xC");    // i.e. (char)12
        }
        bool writePageNumber (void)
        {
            return writeText ((const Byte *) "\x1");    // i.e. (char)1
        }
        bool writeCarriageReturn (void)
        {
            // it's DOS/Windows(r) which has \r\n newlines
            return writeText ((const Byte *) "\xD");    // i.e. (char)13
        }
        bool writeNewLine (const bool)
        {
            return writeText ((const Byte *) "\n"); // i.e. (char)10
        }
        bool writeOptionalHyphen (void)
        {
            return writeText ((const Byte *) "\x1F");   // i.e. (char)31
        }
 
        void sigProgress (const int)
        {
            // don't care
            return;
        }
 
    };
}   // namespace MSWrite    {
 
#endif  // __LIBMSWRITE_H__
 
// end of libmswrite.h