/* 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 __STRUCTURES_PRIVATE_H__
#define __STRUCTURES_PRIVATE_H__

#include "structures_generated.h"
#include "list.h"

namespace MSWrite
{
	class Header : public HeaderGenerated
	{
	private:
		DWord m_numCharBytes;
		Word m_pageCharInfo;

		bool readFromDevice (void);	friend class InternalParser;
		bool writeToDevice (void);	friend class InternalGenerator;

	public:
		Header ();
		virtual ~Header ();

		Header &operator= (const Header &rhs);

		Word getFormat (void) const	{	return getMagic ();	}
		void setFormat (const Word f)	{	setMagic (f);	}

		DWord getNumCharBytes (void) const	{	return m_numCharBytes;	}
		void setNumCharBytes (const DWord w)	{	m_numCharBytes = w;	}

		Word getNumPageCharInfo (void) const	{	return m_pageParaInfo - m_pageCharInfo;	}
		Word getNumPageParaInfo (void) const	{	return m_pageFootnoteTable - m_pageParaInfo;	}
		Word getNumPageFootnoteTable (void) const	{	return m_pageSectionProperty - m_pageFootnoteTable;	}
		Word getNumPageSectionProperty (void) const	{	return m_pageSectionTable - m_pageSectionProperty;	}
		Word getNumPageSectionTable (void) const	{	return m_pagePageTable - m_pageSectionTable;	}
		Word getNumPagePageTable (void) const	{	return m_pageFontTable - m_pagePageTable;	}
		Word getNumPageFontTable (void) const	{	return m_numPages - m_pageFontTable;	}

		Word getPageCharInfo (void) const	{	return m_pageCharInfo;	}
	};

	class NeedsHeader
	{
	protected:
		Header *m_header;

	public:
		NeedsHeader (Header *header = NULL)
		{
			setHeader (header);
		}

		virtual ~NeedsHeader ()
		{
		}

		NeedsHeader &operator= (const NeedsHeader &rhs)
		{
			if (this == &rhs)
				return *this;

			m_header = rhs.m_header;

			return *this;
		}

		void setHeader (Header *header)	{	m_header = header;	}
	};


	class SectionDescriptor : public SectionDescriptorGenerated
	{
	public:
		SectionDescriptor ();
		virtual ~SectionDescriptor ();

		SectionDescriptor &operator= (const SectionDescriptor &rhs);
	};


	class SectionTable : public SectionTableGenerated, public NeedsHeader
	{
	public:
		SectionTable ();
		virtual ~SectionTable ();

		SectionTable &operator= (const SectionTable &rhs);

	private:
		bool readFromDevice (void);	friend class InternalParser;
		bool writeToDevice (const bool needed);	friend class InternalGenerator;
	};


	class Font;	// from structures.h
	class FontTable : public FontTableGenerated, public NeedsHeader
	{
	private:
		List <Font> m_fontList;

		bool readFromDevice (void);	friend class InternalParser;
		bool writeToDevice (void);	friend class InternalGenerator;

	public:
		FontTable ();
		virtual ~FontTable ();

		FontTable &operator= (const FontTable &rhs);

		Font *getFont (const DWord fontCode) const;
		DWord findFont (const Font *want) const;
		DWord addFont (const Font *input);
	};


	class PagePointer : public PagePointerGenerated
	{
	private:
		friend class PageTable;
			bool readFromDevice (void);
			bool writeToDevice (void);

	public:
		PagePointer ();
		virtual ~PagePointer ();

		PagePointer &operator= (const PagePointer &rhs);
	};


	class PageTable : public PageTableGenerated, public NeedsHeader
	{
	private:
		List <PagePointer> m_pagePointerList;
		Word m_pageNumberStart;	// for consistency checking

		friend class InternalParser;
		friend class InternalGenerator;
			bool readFromDevice (void);
			bool writeToDevice (void);

			// call before readFromDevice ()
			void setPageNumberStart (const Word s)	{	m_pageNumberStart = s;	}

		List <PagePointer>::Iterator m_pageTableIterator;

	public:
		PageTable ();
		virtual ~PageTable ();

		PageTable &operator= (const PageTable &rhs);

		PagePointer *begin (void)
		{
			m_pageTableIterator = m_pagePointerList.begin ();
			return &(*m_pageTableIterator);
		}

		PagePointer *next (void)
		{
			m_pageTableIterator = m_pageTableIterator.next ();
			return &(*m_pageTableIterator);
		}

		bool end (void) /*const*/
		{
			return m_pageTableIterator == m_pagePointerList.end ();
		}

		bool add (const PagePointer *newone)
		{
			return m_pagePointerList.addToBack (*newone);
		}
	};


	class FormatPointer : public FormatPointerGenerated
	{
	private:
		DWord m_afterEndCharByte;

		friend class FormatInfoPage;
			bool readFromDevice (void);
			bool writeToDevice (void);

			//
			// for exporting
			//
			const void *m_formatProperty;

			const void *getFormatProperty (void) const	{	return m_formatProperty;	}
			void setFormatProperty (const void *val)	{	m_formatProperty = val;	}

	public:
		FormatPointer ();
		virtual ~FormatPointer ();

		FormatPointer &operator= (const FormatPointer &rhs);

		DWord getAfterEndCharByte (void) const	{	return m_afterEndCharByte;	}
		void setAfterEndCharByte (const DWord val)	{	m_afterEndCharByte = val;	}
	};


	enum FormatInfoPageTypes
	{
		CharType,
		ParaType
	};

	class FormatCharProperty;	// from structures.h
	class FormatParaProperty;	// from structures.h
	class FormatInfoPage : public FormatInfoPageGenerated, public NeedsHeader
	{
	private:
		DWord m_firstCharByte;	// FormatInfoPageGenerated::m_firstCharBytePlus128 - 128
		enum FormatInfoPageTypes m_type;	// CharInfo or ParaInfo?


		//
		// uncompressed data
		//

		// list of FormatPointers (what byte it covers upto and which FormatProperty)
		FormatPointer *m_formatPointer;

		// FormatProperty (which one?  It depends on m_type)
		FormatCharProperty *m_formatCharProperty;
			FontTable *m_fontTable;	// for CharProperty
		FormatParaProperty *m_formatParaProperty;
			Word m_leftMargin, m_rightMargin;	// for ParaProperty


		//
		// Iterator helpers
		//
		int m_formatPointerUpto;	// [import] which formatPointer we are up to
		DWord m_nextCharByte;	// [import] for consistency checking
		int m_lastPropertyOffset;	// [import] lazy optimisation (don't reload Property if FormatPointer points to last Property)
		int m_formatPointerPos, m_formatPropertyPos;	// [export]
		int m_numProperty;	// [export]


		friend class FormatInfo;	// libmswrite.h
			bool readFromDevice (void);
			bool writeToDevice (void);
			bool writeToArray (void);

		// TODO operator=
		FormatInfoPage &operator= (const FormatInfoPage &rhs);

	public:
		FormatInfoPage ();
		virtual ~FormatInfoPage ();

		void setMargins (const Word leftMargin, const Word rightMargin)
		{
			m_leftMargin = leftMargin, m_rightMargin = rightMargin;
		}
		void setFontTable (FontTable *fontTable)
		{
			m_fontTable = fontTable;
		}

		void setType (const enum FormatInfoPageTypes t)	{	m_type = t;	}

		DWord getFirstCharByte (void) const	{	return m_firstCharByte;	}
		void setFirstCharByte (const DWord val)	{	m_firstCharByte = val;	}

		DWord getNextCharByte (void) const	{	return m_nextCharByte;	}

		// my version of iterators is a lot simpler now, isn't it? :)
		void *begin (void);
		void *next (void);
		bool end (void) const;

		bool add (const void *property);
	};


	class BMP_BitmapFileHeader : public BMP_BitmapFileHeaderGenerated
	{
	public:
		BMP_BitmapFileHeader ();
		virtual ~BMP_BitmapFileHeader ();

		BMP_BitmapFileHeader &operator= (const BMP_BitmapFileHeader &rhs);

		bool readFromDevice (void);
		bool writeToDevice (void);
	};


	class BMP_BitmapInfoHeader : public BMP_BitmapInfoHeaderGenerated
	{
	public:
		BMP_BitmapInfoHeader ();
		virtual ~BMP_BitmapInfoHeader ();

		BMP_BitmapInfoHeader &operator= (const BMP_BitmapInfoHeader &rhs);

		bool readFromDevice (void);
		bool writeToDevice (void);
	};


	class BMP_BitmapColourIndex : public BMP_BitmapColourIndexGenerated
	{
	public:
		BMP_BitmapColourIndex ();
		virtual ~BMP_BitmapColourIndex ();

		BMP_BitmapColourIndex &operator= (const BMP_BitmapColourIndex &rhs);
	};


	class BitmapHeader : public BitmapHeaderGenerated
	{
	//private:
	//	friend class ImageGenerated;
	public:
		BitmapHeader ();
		virtual ~BitmapHeader ();

		BitmapHeader &operator= (const BitmapHeader &rhs);

		bool readFromDevice (void);
		bool writeToDevice (void);
	};


	class WMFHeader : public WMFHeaderGenerated
	{
	//private:
	//	friend class Image;
	public:
		WMFHeader ();
		virtual ~WMFHeader ();

		WMFHeader &operator= (const WMFHeader &rhs);

		bool readFromDevice (void);
		bool writeToDevice (void);
	};

}	// namespace MSWrite	{

#endif	//	__STRUCTURES_PRIVATE_H__

// end of structures_private.h