gecko-dev/lib/layout/editor.h

/* -*- Mode: C++; tab-width: 8; indent-tabs-mode: nil; c-basic-offset: 2 -*-
 *
 * The contents of this file are subject to the Netscape Public License
 * Version 1.0 (the "NPL"); you may not use this file except in
 * compliance with the NPL.  You may obtain a copy of the NPL at
 * http://www.mozilla.org/NPL/
 *
 * Software distributed under the NPL is distributed on an "AS IS" basis,
 * WITHOUT WARRANTY OF ANY KIND, either express or implied. See the NPL
 * for the specific language governing rights and limitations under the
 * NPL.
 *
 * The Initial Developer of this code under the NPL is Netscape
 * Communications Corporation.  Portions created by Netscape are
 * Copyright (C) 1998 Netscape Communications Corporation.  All Rights
 * Reserved.
 */


//
// Editor save stuff. LWT 06/01/95
//

#ifdef EDITOR

#ifndef _EDITOR_H
#define _EDITOR_H
#include "edttypep.h"       // include first so types are mapped.

// 
// Turn on new DT mapping code
//
#define EDT_DDT 1

#if defined(JAVA)
#define EDITOR_JAVA
#endif

//
//    Many of the system header files have C++ specific stuff in
//    them. If we just widely extern "C" {} the lot, we will lose.
//    So.. pre-include some that must be seen by C++.
//
#if defined(HPUX) || defined(SCO_SV)
#include "math.h"
#endif /*HPUX losing headers */

extern "C" {
#include "net.h"
//#include "glhist.h"
//#include "shist.h"
#include "merrors.h"
#include "xp.h"
#include "pa_parse.h"
#include "layout.h"
#include "edt.h"
#include "pa_tags.h"
#include "xpassert.h"
#include "xp_file.h"
#include "libmocha.h"
#include "libi18n.h"
}

#include "bits.h"
#include "garray.h"
#include "streams.h"


#include "gui.h"

// For textFE test, hardts
#include "xlate.h"

#include "fsfile.h"
#include "shist.h"

#ifdef XP_WIN32
#include	<crtdbg.h>
#endif

// XP Strings
extern "C" {
#include "xpgetstr.h"
#define WANT_ENUM_STRING_IDS
#include "allxpstr.h"
#undef WANT_ENUM_STRING_IDS
}

// Defining DEBUG_AUTO_SAVE will make the document AutoSave every six seconds.
//#define DEBUG_AUTO_SAVE

// Test if ele
#ifdef USE_SCRIPT
#define  ED_IS_NOT_SCRIPT(pEle) (0 == (pEle->Text()->m_tf & (TF_SERVER | TF_SCRIPT | TF_STYLE)))
#else
#define ED_IS_NOT_SCRIPT(pEle) (TRUE)
#endif

#define EDT_SELECTION_START_COMMENT "selection start"
#define EDT_SELECTION_END_COMMENT "selection end"

// TRY / CATCH / RETHROW macros for minimal error recovery on macs
#if defined(XP_MAC)
#define EDT_TRY try
#define EDT_CATCH_ALL catch(...)
#define EDT_RETHROW throw
#else
#define EDT_TRY if(1)
#define EDT_CATCH_ALL else
#define EDT_RETHROW

#endif

#ifdef XP_MAC
// taken from pa_amp.h
#define NON_BREAKING_SPACE  ((char)007)
#define NON_BREAKING_SPACE_STRING   "\07"
#else
#define NON_BREAKING_SPACE  ((char)160)
#define NON_BREAKING_SPACE_STRING   "\xa0"
#endif

#define DEF_FONTSIZE    3
#define DEFAULT_HR_THICKNESS    2

#define EDT_IS_LIVEWIRE_MACRO(s) ( (s) && (s)[0] == '`' )


// Macros for the public entry points.
// usage:
// GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) ; // For no return value
// GET_EDIT_BUF_OR_RETURN(pContext, pEditBuffer) return-value; // to return a return value

#define GET_WRITABLE_EDIT_BUF_OR_RETURN(CONTEXT, BUFFER) CEditBuffer* BUFFER = LO_GetEDBuffer( CONTEXT );\
    if (!CEditBuffer::IsAlive(BUFFER) || !BUFFER->IsReady() || !BUFFER->IsWritable() ) return

#define GET_EDIT_BUF_OR_RETURN(CONTEXT, BUFFER) CEditBuffer* BUFFER = LO_GetEDBuffer( CONTEXT );\
    if (!CEditBuffer::IsAlive(BUFFER) || !BUFFER->IsReady() ) return

#define GET_EDIT_BUF_OR_RETURN_READY_OR_NOT(CONTEXT, BUFFER) CEditBuffer* BUFFER = LO_GetEDBuffer( CONTEXT );\
    if (!CEditBuffer::IsAlive(BUFFER) ) return

#define GET_WRITABLE_EDIT_BUF_OR_RETURN_READY_OR_NOT(CONTEXT, BUFFER) CEditBuffer* BUFFER = LO_GetEDBuffer( CONTEXT );\
    if (!CEditBuffer::IsAlive(BUFFER) || !BUFFER->IsWritable() ) return


//-----------------------------------------------------------------------------
// Edit Classes
//-----------------------------------------------------------------------------
class CEditElement;
class CEditLeafElement;
class CEditSubDocElement;
class CEditTableElement;
class CEditTableRowElement;
class CEditCaptionElement;
class CEditTableCellElement;
class CEditRootDocElement;
class CEditContainerElement;
class CEditListElement;
class CEditTextElement;
class CEditImageElement;
class CEditHorizRuleElement;
class CEditIconElement;
class CEditEndElement;
class CEditBreakElement;
class CEditTargetElement;
class CEditLayerElement;
class CEditDivisionElement;
class CParseState;
class CPrintState;
class CEditImageLoader;
class CEditSaveObject;
class CFileSaveObject;
struct ED_Link;
class CEditCommand;
class CEditCommandGroup;

class CEditSaveData;
class CEditSaveToTempData;

#ifdef DEBUG
class CEditTestManager;
#endif
#ifdef EDITOR_JAVA
// Opaque interface to Editor Plugin support classes.
// (It's too expensive to pull jri in in this header file.
// If we do, bsdi runs out of VM while compiling.

typedef void* EditorPluginManager;
EditorPluginManager EditorPluginManager_new(MWContext* pContext);
void EditorPluginManager_delete(EditorPluginManager a);
XP_Bool EditorPluginManager_IsPluginActive(EditorPluginManager a);
XP_Bool EditorPluginManager_PluginsExist();
class CEditorPluginInterface;
#endif

// Originally this was a sugared int32, but we ran into
// trouble working with big-endian architectures, like the
// Macintosh. So rather than being even cleverer with
// macros, I decided to make it a regular class.
// If this turns out to be a performance bottleneck
// we can always inline it.... jhp
class ED_Color {
public:
    ED_Color();
    ED_Color(LO_Color& pLoColor);
    ED_Color(int32 rgb);
    ED_Color(int r, int g, int b);
    ED_Color(LO_Color* pLoColor);
    XP_Bool IsDefined();
    XP_Bool operator==(const ED_Color& other) const;
    XP_Bool operator!=(const ED_Color& other) const;
    int Red();
    int Green();
    int Blue();
    LO_Color GetLOColor();
    long GetAsLong(); // 0xRRGGBB
	void SetUndefined();
	static ED_Color GetUndefined();
private:
    LO_Color m_color;
    XP_Bool m_bDefined;
};

// Copies the argument into a static buffer, and then upper-cases the
// buffer, and returns a pointer to the buffer. You don't own the
// result pointer, and you can't call twice in same line of code.

char* EDT_UpperCase(char*);

// Returns a string for the given alignment. Uses a static buffer, so
// don't call twice in the same line of code.

char* EDT_AlignString(ED_Alignment align);

// Backwards-compatable macros. Should clean this up some day.

#define EDT_COLOR_DEFAULT    (ED_Color())
#define EDT_RED(x)      ((x).Red())
#define EDT_GREEN(x)    ((x).Green())
#define EDT_BLUE(x)     ((x).Blue())
#define EDT_RGB(r,g,b)  (ED_Color(r,g,b))
#define EDT_LO_COLOR(pLoColor)  ED_Color(pLoColor)

/* Gives us quick access to first cell in each column or row 
 *  with location and index data
*/
struct _EDT_CellLayoutData {
    int32                 X;                 /* X value of cell */
    int32                 Y;                 /* Y value of cell */
    int32                 iColumn;           /* Geometric column index */
    int32                 iRow;              /* Geometric row index */
    int32                 iCellsInColumn;    /* Total number of cells in each column */
    int32                 iCellsInRow;       /*  and row */
    LO_Element            *pLoCell;          /* Layout element pointer */
    CEditTableCellElement *pEdCell;          /* Corresponding edit element object */
};

typedef struct _EDT_CellLayoutData EDT_CellLayoutData;


// Editor selections

// template declarations
Declare_GrowableArray(XP_Bool,XP_Bool)                  // TXP_GrowableArray_XP_Bool
Declare_GrowableArray(int32,int32)                      // TXP_GrowableArray_int32
Declare_GrowableArray(intn,intn)                        // TXP_GrowableArray_intn
Declare_GrowableArray(ED_Link,ED_Link*)                 // TXP_GrowableArray_ED_Link
Declare_GrowableArray(EDT_MetaData,EDT_MetaData*)       // TXP_GrowableArray_EDT_MetaData
Declare_GrowableArray(pChar,char*)                      // TXP_GrowableArray_pChar
Declare_GrowableArray(CEditCommand,CEditCommand*)       // TXP_GrowableArray_CEditCommand
#ifdef EDITOR_JAVA
Declare_GrowableArray(CEditorPluginInterface,CEditorPluginInterface*)       // TXP_GrowableArray_CEditorPluginInterface
#endif
//cmanske - store lists of selected cell elements
Declare_GrowableArray(CEditTableCellElement,CEditTableCellElement*)  // TXP_GrowableArray_CEditTableCellElement
Declare_GrowableArray(LO_CellStruct,LO_CellStruct*)                  // TXP_GrowableArray_LO_CellStruct
//List of tables encountered during Relayout()
Declare_GrowableArray(LO_TableStruct,LO_TableStruct*)                // TXP_GrowableArray_LO_TableStruct

Declare_GrowableArray(EDT_CellLayoutData, EDT_CellLayoutData*)       // TXP_GrowableArray_EDT_CellLayoutData

Declare_PtrStack(ED_Alignment,ED_Alignment)             // TXP_PtrStack_ED_Alignment
Declare_PtrStack(TagType,TagType)                       // TXP_PtrStack_TagType
Declare_PtrStack(CEditTextElement,CEditTextElement*)    // TXP_PtrStack_CEditTextElement
Declare_PtrStack(ED_TextFormat,int32)                   // TXP_PtrStack_ED_TextFormat
Declare_PtrStack(CEditCommandGroup,CEditCommandGroup*)  // TXP_PtrStack_CEditCommandGroup
Declare_PtrStack(CParseState,CParseState*)              // TXP_PtrStack_CParseState


/* iTableMode param for CEditTableElement::SetSizeMode() */
#define ED_MODE_TABLE_PERCENT     0x0001   /* Convert table to use % of parent width */
#define ED_MODE_TABLE_PIXELS      0x0002   /* Convert table to use absolute pixels */
#define ED_MODE_CELL_PERCENT      0x0004   /* Convert all cells to use % of parent width */
#define ED_MODE_CELL_PIXELS       0x0008   /* Convert all cells to use absolute pixels */
#define ED_MODE_USE_TABLE_WIDTH   0x0010   /* Set WIDTH param for table */
#define ED_MODE_NO_TABLE_WIDTH    0x0020   /* Remove WIDTH param for table */
#define ED_MODE_USE_TABLE_HEIGHT  0x0040   /* Set HEIGHT param for table*/
#define ED_MODE_NO_TABLE_HEIGHT   0x0080   /* Remove HEIGHT param table */
#define ED_MODE_USE_CELL_WIDTH    0x0100   /* Set WIDTH param for all cells */
#define ED_MODE_NO_CELL_WIDTH     0x0200   /* Remove WIDTH param for all cells */
#define ED_MODE_USE_CELL_HEIGHT   0x0400   /* Set HEIGHT param for all cells*/
#define ED_MODE_NO_CELL_HEIGHT    0x0800   /* Remove HEIGHT param for all cells*/
#define ED_MODE_USE_COLS          0x1000   /* Use COLS param for table (only 1st row used) */
#define ED_MODE_NO_COLS           0x2000   /* Remove COLS param for table (all cell widths used) */

#ifdef DEBUG
    #define DEBUG_EDIT_LAYOUT
#endif

typedef int32 DocumentVersion;

typedef int32 ElementIndex; // For persistent insert points, a position from the start of the document.
typedef int32 ElementOffset; // Within one element, an offset into an element. Is 0 or 1, except for text.

class CEditInsertPoint
{
public:
    CEditInsertPoint();
    CEditInsertPoint(CEditElement* pElement, ElementOffset iPos);
    CEditInsertPoint(CEditLeafElement* pElement, ElementOffset iPos);
    CEditInsertPoint(CEditElement* pElement, ElementOffset iPos, XP_Bool bStickyAfter);

    XP_Bool IsStartOfElement();
    XP_Bool IsEndOfElement();
    XP_Bool IsStartOfContainer();
    XP_Bool IsEndOfContainer();
    XP_Bool IsStartOfDocument();
    XP_Bool IsEndOfDocument();

    XP_Bool GapWithBothSidesAllowed();
    XP_Bool IsLineBreak();
    XP_Bool IsSoftLineBreak();
    XP_Bool IsHardLineBreak();
    XP_Bool IsSpace(); // After insert point
    XP_Bool IsSpaceBeforeOrAfter(); // Before or after insert point

    // Move forward and backward. Returns FALSE if can't move
    CEditInsertPoint NextPosition();
    CEditInsertPoint PreviousPosition();

    XP_Bool operator==(const CEditInsertPoint& other );
    XP_Bool operator!=(const CEditInsertPoint& other );
    XP_Bool operator<(const CEditInsertPoint& other );
    XP_Bool operator<=(const CEditInsertPoint& other );
    XP_Bool operator>=(const CEditInsertPoint& other );
    XP_Bool operator>(const CEditInsertPoint& other );
    XP_Bool IsDenormalizedVersionOf(const CEditInsertPoint& other);
    intn Compare(const CEditInsertPoint& other );

#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif

    CEditLeafElement* m_pElement;
    ElementOffset m_iPos;
    XP_Bool m_bStickyAfter;

private:
    CEditElement* FindNonEmptyElement( CEditElement *pStartElement );
};


class CEditSelection
{
public:
    CEditSelection();
    CEditSelection(CEditElement* pStart, intn iStartPos, CEditElement* pEnd, intn iEndPos, XP_Bool fromStart = FALSE);
    CEditSelection(const CEditInsertPoint& start, const CEditInsertPoint& end, XP_Bool fromStart = FALSE);

    XP_Bool operator==(const CEditSelection& other );
    XP_Bool operator!=(const CEditSelection& other );
    XP_Bool IsInsertPoint();
    CEditInsertPoint* GetActiveEdge();
    CEditInsertPoint* GetAnchorEdge();
    CEditInsertPoint* GetEdge(XP_Bool bEnd);

    // Like ==, except ignores bFromStart.
    XP_Bool EqualRange(CEditSelection& other);
    XP_Bool Intersects(CEditSelection& other); // Just a test; doesn't change this.
    XP_Bool Contains(CEditInsertPoint& point);
    XP_Bool Contains(CEditSelection& other);
    XP_Bool ContainsStart(CEditSelection& other);
    XP_Bool ContainsEnd(CEditSelection& other);
    XP_Bool ContainsEdge(CEditSelection& other, XP_Bool bEnd);
    XP_Bool CrossesOver(CEditSelection& other);

    XP_Bool ClipTo(CEditSelection& other); // True if the result is defined. No change to this if it isn't

    CEditElement* GetCommonAncestor();
    XP_Bool CrossesSubDocBoundary();
    CEditSubDocElement* GetEffectiveSubDoc(XP_Bool bEnd);

    XP_Bool ExpandToNotCrossStructures(); // TRUE if this was changed
    void ExpandToBeCutable();
    void ExpandToIncludeFragileSpaces();
    void ExpandToEncloseWholeContainers();
    XP_Bool EndsAtStartOfContainer();
    XP_Bool StartsAtEndOfContainer();
    XP_Bool AnyLeavesSelected(); // FALSE if insert point or container end.
    XP_Bool IsContainerEnd(); // TRUE if just contains the end of a container.
    // Useful for cut & delete, where you don't replace the final container mark
    XP_Bool ContainsLastDocumentContainerEnd();
    void ExcludeLastDocumentContainerEnd();

    CEditContainerElement* GetStartContainer();
    CEditContainerElement* GetClosedEndContainer(); // Not 1/2 open!

#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif

    CEditInsertPoint m_start;
    CEditInsertPoint m_end;
    XP_Bool m_bFromStart;
    
    //cmanske: Needed to differentiate between an empty selection 
    //  (indicating we should get the current selection)
    //  and a selection obtained from a table cell
    XP_Bool IsEmpty() { return (m_start.m_pElement == 0); }
};


class CPersistentEditInsertPoint
{
public:
    // m_bStickyAfter defaults to TRUE
    CPersistentEditInsertPoint();
    CPersistentEditInsertPoint(ElementIndex index);
    CPersistentEditInsertPoint(ElementIndex index, XP_Bool bStickyAfter);
#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif
    XP_Bool operator==(const CPersistentEditInsertPoint& other );
    XP_Bool operator!=(const CPersistentEditInsertPoint& other );
    XP_Bool operator<(const CPersistentEditInsertPoint& other );
    XP_Bool operator<=(const CPersistentEditInsertPoint& other );
    XP_Bool operator>=(const CPersistentEditInsertPoint& other );
    XP_Bool operator>(const CPersistentEditInsertPoint& other );

    XP_Bool IsEqualUI(const CPersistentEditInsertPoint& other );

    // Used for undo
    // delta = this - other;
    void ComputeDifference(CPersistentEditInsertPoint& other, CPersistentEditInsertPoint& delta);
    // result = this + delta;
    void AddRelative(CPersistentEditInsertPoint& delta, CPersistentEditInsertPoint& result);

    ElementIndex m_index;
    // If this insert point falls between two elements, and
    // m_bStickyAfter is TRUE, then this insert point is attached
    // to the start of the second element. If m_bStickyAfter
    // is false, then this insert point is attached to the end of
    // the first element. It is FALSE by default. It is ignored
    // by all of the comparison operators except IsEqualUI. It
    // is ignored by ComputeDifference and AddRelative

     XP_Bool m_bStickyAfter;
};

#ifdef DEBUG
    #define DUMP_PERSISTENT_EDIT_INSERT_POINT(s, pt) { XP_TRACE(("%s %d", s, pt.m_index));}
#else
    #define DUMP_PERSISTENT_EDIT_INSERT_POINT(s, pt) {}
#endif

class CPersistentEditSelection
{
public:
    CPersistentEditSelection();
    CPersistentEditSelection(const CPersistentEditInsertPoint& start, const CPersistentEditInsertPoint& end);
#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif
    XP_Bool operator==(const CPersistentEditSelection& other );
    XP_Bool operator!=(const CPersistentEditSelection& other );
    XP_Bool SelectedRangeEqual(const CPersistentEditSelection& other ); // Ignores m_bFromStart

    ElementIndex GetCount();
    XP_Bool IsInsertPoint();
    CPersistentEditInsertPoint* GetEdge(XP_Bool bEnd);

    // Used for undo
    // change this by the same way that original was changed into modified.
    void Map(CPersistentEditSelection& original, CPersistentEditSelection& modified);

    CPersistentEditInsertPoint m_start;
    CPersistentEditInsertPoint m_end;
    XP_Bool m_bFromStart;
};

#ifdef DEBUG
    #define DUMP_PERSISTENT_EDIT_SELECTION(s, sel) { XP_TRACE(("%s %d-%d %d", s,\
        sel.m_start.m_index,\
        sel.m_end.m_index,\
        sel.m_bFromStart));}
#else
    #define DUMP_PERSISTENT_EDIT_SELECTION(s, sel) {}
#endif

#ifdef DEBUG
void TraceLargeString(char* b);
#endif

//
// Element type used during stream constructor
//
enum EEditElementType {
    eElementNone,
    eElement,
    eTextElement,
    eImageElement,
    eHorizRuleElement,
    eBreakElement,
    eContainerElement,
    eIconElement,
    eTargetElement,
    eListElement,
    eEndElement,
    eTableElement,
    eTableRowElement,
    eTableCellElement,
    eCaptionElement,
    eLayerElement,
    eDivisionElement,
    eInternalAnchorElement
};

//
// CEditElement
//
class CEditElement {
private:
    CEditElement* m_pParent;
    CEditElement* m_pNext;
    CEditElement* m_pChild;
    char *m_pTagData;               // hack! remainder of tag data for regen.

protected:
    TagType m_tagType;
    char* GetTagData(){ return m_pTagData; };
    void SetTagData(char* tagData);

public:

    // ctor, dtor
    CEditElement(CEditElement *pParent, TagType tagType, char* pData = NULL);
    CEditElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditElement();

    static CEditElement* StreamCtor( IStreamIn *pIn, CEditBuffer *pBuffer );
    static CEditElement* StreamCtorNoChildren( IStreamIn *pIn, CEditBuffer *pBuffer );
    virtual void StreamInChildren(IStreamIn* pIn, CEditBuffer* pBuffer);

    //
    // Accessor functions
    //
    CEditElement* GetParent(){ return m_pParent; }
    CEditElement* GetNextSibling(){ return m_pNext; }
    CEditElement* GetPreviousSibling();
    CEditElement* GetChild(){ return m_pChild; }
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild);
    void SetParent(CEditElement* pParent){m_pParent = pParent;}
    void SetChild(CEditElement *pChild);
    void SetNextSibling(CEditElement* pNext);

    CEditElement* GetLastChild();
    CEditElement* GetLastMostChild();
    CEditElement* GetFirstMostChild();

    CEditCaptionElement* GetCaption(); // Returns containing cell, or NULL if none.
    CEditCaptionElement* GetCaptionIgnoreSubdoc(); // Returns containing cell, or NULL if none.
    CEditTableCellElement* GetTableCell(); // Returns containing cell, or NULL if none.
    CEditTableCellElement* GetTableCellIgnoreSubdoc(); // Returns containing cell, or NULL if none.
    CEditTableRowElement* GetTableRow(); // Returns containing row, or NULL if none.
    CEditTableRowElement* GetTableRowIgnoreSubdoc(); // Returns containing row, or NULL if none.
    CEditTableElement* GetTable(); // Returns containing table, or NULL if none.
    CEditTableElement* GetTableIgnoreSubdoc(); // Returns containing table, or NULL if none.
    CEditLayerElement* GetLayer(); // Returns containing Layer, or NULL if none.
    CEditLayerElement* GetLayerIgnoreSubdoc(); // Returns containing Layer, or NULL if none.
    CEditSubDocElement* GetSubDoc(); // Returns containing sub-doc, or NULL if none.
    CEditSubDocElement* GetSubDocSkipRoot(); // Returns containing sub-doc, or NULL if none.
    CEditRootDocElement* GetRootDoc(); // Returns containing root, or NULL if none.
    XP_Bool InMungableMailQuote(); // Returns true if this element is within a mungable mail quote.
    XP_Bool InMailQuote(); // Returns true if this element is within a mail quote.
    CEditListElement* GetMailQuote(); // Returns containing mail quote or NULL.

    //cmanske A bit more readable
    XP_Bool IsInTableCell() { return NULL != GetTableCellIgnoreSubdoc(); }
    XP_Bool IsInTable() { return NULL != GetTableIgnoreSubdoc(); }

    CEditElement* GetTopmostTableOrLayer(); // Returns topmost containing table or Layer, or NULL if none.
    CEditElement* GetTableOrLayerIgnoreSubdoc(); // Returns containing table or Layer, or NULL if none.
    CEditElement* GetSubDocOrLayerSkipRoot();

    CEditBuffer* GetEditBuffer(); // returns the edit buffer if the element is in one.

    virtual ED_Alignment GetDefaultAlignment();
    virtual ED_Alignment GetDefaultVAlignment();

    TagType GetType(){ return m_tagType; }
    void SetType( TagType t ){ m_tagType = t; }

    // Returns TRUE only if tag has WIDTH or HEIGHT already defined
    // Use NULL for params if you don't need those values
    XP_Bool GetWidth(XP_Bool * pPercent = NULL, int32 * pWidth = NULL);
    XP_Bool GetHeight(XP_Bool * pPercent = NULL, int32 * pHeight = NULL);
    
    virtual void SetSize(XP_Bool bWidthPercent, int32 iWidth,
                         XP_Bool bHeightPercent, int32 iHeight);
	
	virtual XP_Bool CanReflow();
	
    //
    // Cast routines.
    //
    CEditTextElement* Text();

    virtual XP_Bool IsLeaf();
    CEditLeafElement* Leaf();

    virtual XP_Bool IsRoot();
    CEditRootDocElement* Root();

    virtual XP_Bool IsContainer();
    CEditContainerElement* Container();

    //get previous non empty container to querry for preopen conditions ect
    CEditContainerElement*  GetPreviousNonEmptyContainer();
    //get next non empty container to querry for preclose conditions ect
    CEditContainerElement*  GetNextNonEmptyContainer();

    virtual XP_Bool IsList();
    CEditListElement* List();

    virtual XP_Bool IsBreak();
    CEditBreakElement* Break();

    virtual XP_Bool CausesBreakBefore();
    virtual XP_Bool CausesBreakAfter();
    virtual XP_Bool AllowBothSidesOfGap();

    virtual XP_Bool IsImage();
    CEditImageElement* Image();
    virtual XP_Bool IsIcon();
    CEditIconElement* Icon();

    virtual XP_Bool IsTarget();
    CEditTargetElement* Target();

    CEditHorizRuleElement* HorizRule();
    virtual XP_Bool IsRootDoc();
    CEditRootDocElement* RootDoc();
    virtual XP_Bool IsSubDoc();
    CEditSubDocElement* SubDoc();
    virtual XP_Bool IsTable();
    CEditTableElement* Table();
    virtual XP_Bool IsTableRow();
    CEditTableRowElement* TableRow();
    virtual XP_Bool IsTableCell();
    CEditTableCellElement* TableCell();
    virtual XP_Bool IsCaption();
    CEditCaptionElement* Caption();
    virtual XP_Bool IsText();
    virtual XP_Bool IsLayer();
    CEditLayerElement* Layer();
    virtual XP_Bool IsDivision();
    CEditDivisionElement* Division();

    XP_Bool IsEndOfDocument();
    virtual XP_Bool IsEndContainer();

    // Can this element contain a paragraph?
    virtual XP_Bool IsContainerContainer();

    XP_Bool IsA( int tagType ){ return m_tagType == tagType; }
    XP_Bool Within( int tagType );
    XP_Bool InFormattedText();
    CEditContainerElement* FindContainer(); // Returns this if this is a container.
    CEditContainerElement* FindEnclosingContainer(); // Starts search with parent of this.
    CEditElement* FindList();
    void FindList( CEditContainerElement*& pContainer, CEditListElement*& pList );
    CEditElement* FindContainerContainer();

    //
    // Tag Generation functions
    //
    virtual PA_Tag* TagOpen( int iEditOffset );
    virtual PA_Tag* TagEnd( );
    void SetTagData( PA_Tag* pTag, char* pTagData);

    //
    // Output routines.
    //
    virtual void PrintOpen( CPrintState *pPrintState );
    void InternalPrintOpen( CPrintState *pPrintState, char* pTagData );
    virtual void PrintEnd( CPrintState *pPrintState );
    virtual void StreamOut( IStreamOut *pOut );
    virtual void PartialStreamOut( IStreamOut *pOut, CEditSelection& selection );
    virtual XP_Bool ShouldStreamSelf( CEditSelection& local, CEditSelection& selection);
    virtual void StreamToPositionalText( IStreamOut * /*pOut*/, XP_Bool /*bEnd*/ ){}


    virtual EEditElementType GetElementType();

    // Get parent table or cell of any element
    CEditTableElement* GetParentTable();
    CEditTableCellElement* GetParentTableCell();

    virtual XP_Bool Reduce( CEditBuffer *pBuffer );

    // Selection utilities
    XP_Bool ClipToMe(CEditSelection& selection, CEditSelection& local); // Returns TRUE if selection intersects with "this".
    virtual void GetAll(CEditSelection& selection); // Get selection that selects all of this.
    
    //cmanske: Used only by CEditTableElement and CEditTableCellElement
    virtual XP_Bool IsSelected() {return FALSE; }

    // iterators
    typedef XP_Bool (CEditElement::*PMF_EditElementTest)(void*);

    CEditElement* FindNextElement( PMF_EditElementTest pmf, void *pData );
    CEditElement* UpRight( PMF_EditElementTest pmf, void *pTestData );
    CEditElement* DownRight( PMF_EditElementTest pmf,void *pTestData,
            XP_Bool bIgnoreThis = FALSE );

    CEditElement* FindPreviousElement( PMF_EditElementTest pmf, void *pTestData );
    CEditElement* UpLeft( PMF_EditElementTest pmf, void *pTestData );
    CEditElement* DownLeft( PMF_EditElementTest pmf, void *pTestData,
            XP_Bool bIgnoreThis = FALSE );

    XP_Bool TestIsTrue( PMF_EditElementTest pmf, void *pTestData ){
                return (this->*pmf)(pTestData); }

    //
    // Search routines to be applied FindNextElement and FindPreviousElement
    //
    XP_Bool FindText( void* /*pVoid*/ );
    XP_Bool FindTextAll( void* /*pVoid*/ );
    XP_Bool FindLeaf( void* /*pVoid*/ );
    XP_Bool FindLeafAll( void* /*pVoid*/ );
    XP_Bool FindImage( void* /*pvoid*/ );
    XP_Bool FindTarget( void* /*pvoid*/ );
    XP_Bool FindUnknownHTML( void* /*pvoid*/ );
    XP_Bool SplitContainerTest( void* /*pVoid*/ );
    XP_Bool SplitFormattingTest( void* pVoid );
    XP_Bool FindTable( void* /*pvoid*/ );
    XP_Bool FindTableRow( void* /*pvoid*/ );
    XP_Bool FindTableCell( void* /*pvoid*/ );
    

    XP_Bool FindContainer( void* /*pVoid*/ );

    //
    // Split the tree.  You can stop when pmf returns true.
    //
    virtual CEditElement* Split(CEditElement *pLastChild,
                                CEditElement* pCloneTree,
                                PMF_EditElementTest pmf,
                                void *pData);

    virtual CEditElement* Clone( CEditElement *pParent = 0 );
    CEditElement* CloneFormatting( TagType endType );
    virtual void Unlink();
    virtual void Merge( CEditElement *pAppendBlock, XP_Bool bCopyAppendAttributes = TRUE );


#ifdef DEBUG
    virtual void ValidateTree();
#endif
    CEditElement* InsertAfter( CEditElement *pPrev );
    CEditElement* InsertBefore( CEditElement *pNext );
    void InsertAsFirstChild( CEditElement *pParent );
    void InsertAsLastChild( CEditElement *pParent );

    virtual XP_Bool IsFirstInContainer();
    CEditTextElement* TextInContainerAfter();
    CEditTextElement* PreviousTextInContainer();
    virtual CEditElement* Divide(int iOffset);

    CEditLeafElement* PreviousLeafInContainer();
    CEditLeafElement* LeafInContainerAfter();

    CEditLeafElement* PreviousLeaf() { return (CEditLeafElement*) FindPreviousElement( &CEditElement::FindLeaf, 0 ); }
    CEditLeafElement* NextLeaf() { return (CEditLeafElement*) FindNextElement( &CEditElement::FindLeaf, 0 ); }
    CEditLeafElement* NextLeafAll() { return (CEditLeafElement*) FindNextElement( &CEditElement::FindLeafAll, 0 ); }
    CEditLeafElement* NextLeafAll(XP_Bool bForward);
    CEditContainerElement* NextContainer() { return (CEditContainerElement*) FindNextElement( &CEditElement::FindContainer, 0 ); }
    CEditContainerElement* PreviousContainer() { return (CEditContainerElement*) FindPreviousElement( &CEditElement::FindContainer, 0 ); }

    CEditElement* GetRoot();
    CEditElement* GetCommonAncestor(CEditElement* pOther); // NULL if not in same tree
    CEditElement* GetChildContaining(CEditElement* pDescendant); // NULL if not a descendant

    XP_Bool DeleteElement( CEditElement *pTellIfKilled );
    void DeleteChildren();

    // should be in Container class
    int GetDefaultFontSize();

    // To and from persistent insert points
    virtual CEditInsertPoint IndexToInsertPoint(ElementIndex index, XP_Bool bStickyAfter);
    virtual CPersistentEditInsertPoint GetPersistentInsertPoint(ElementOffset offset);
    virtual ElementIndex GetElementIndexOf(CEditElement* child); // asserts if argument is not a child.
    virtual ElementIndex GetPersistentCount();
    ElementIndex GetElementIndex();

    virtual void FinishedLoad( CEditBuffer* pBuffer );
    virtual void AdjustContainers( CEditBuffer* pBuffer );

	int16 GetWinCSID(); // International Character set ID

protected:
    virtual void Finalize();
    void EnsureSelectableSiblings(CEditBuffer* pBuffer);

private:
    void CommonConstructor();
    // For CEditElement constructor, where the vtable isn't
    // set up enough to check if the item is acceptable.
    void RawSetNextSibling(CEditElement* pNext) {m_pNext = pNext; }
    void RawSetChild(CEditElement* pChild) {m_pChild = pChild; }
};


//
// CEditSubDocElement - base class for the root, captions, and table data cells
//
class CEditSubDocElement: public CEditElement {
public:
    CEditSubDocElement(CEditElement *pParent, int tagType, char* pData = NULL);
    CEditSubDocElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditSubDocElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);

    virtual XP_Bool IsSubDoc() { return TRUE; }
    static CEditSubDocElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsSubDoc() ? (CEditSubDocElement*) pElement : 0; }

    virtual XP_Bool Reduce( CEditBuffer *pBuffer );
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild){
            return ! pChild.IsLeaf();
        }
    virtual void FinishedLoad( CEditBuffer* pBuffer );
};

class CEditTableElement: public CEditElement {
public:
    CEditTableElement(intn columns, intn rows);
    CEditTableElement(CEditElement *pParent, PA_Tag *pTag, int16 csid, ED_Alignment align);
    CEditTableElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditTableElement();

    virtual XP_Bool IsTable() { return TRUE; }
    static CEditTableElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsTable() ? (CEditTableElement*) pElement : 0; }
    virtual EEditElementType GetElementType() { return eTableElement; }
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild){
            return pChild.IsTableRow() || pChild.IsCaption();
        }
    virtual void FinishedLoad( CEditBuffer* pBuffer );
    // Move current caption contents to just after or before the table.
    // Used primarily when all table contents are about to be deleted
    XP_Bool MoveCaptionOutsideTable(XP_Bool bAfter);
    void AdjustCaption();
    virtual PA_Tag* TagOpen(int iEditOffset);
    PA_Tag* InternalTagOpen(int iEditOffset, XP_Bool bPrinting);
    virtual PA_Tag* TagEnd();

    // These now return the cell where we should place the insert point after Relayout
    void InsertRows(int32 Y, int32 newY, intn number, CEditTableElement* pSource = NULL, intn iStartColumn = 0, 
                    CEditTableCellElement **ppCellForInsertPoint = NULL);
    void InsertColumns(int32 X, int32 newX, intn number, CEditTableElement* pSource = NULL, intn iStartRow = 0, 
                       CEditTableCellElement **ppCellForInsertPoint = NULL);
    // Returns TRUE if all cells in source are pasted
    XP_Bool ReplaceSpecialCells(CEditTableElement *pSourceTable,  XP_Bool bIgnoreSourceLayout = FALSE, CEditTableCellElement **ppCellForInsertPoint = NULL);

    // Delete a table and relayout
    // Use bMoveInsertPoint = TRUE when you have already moved insert point
    //   outside of the table, else it is moved to just before the table
    void Delete(XP_Bool bMoveInsertPoint = TRUE);
//cmanske: I doubt we will ever revive the old undo system, so skip it here
//    void DeleteRows(int32 Y, intn number, CEditTableElement* pUndoContainer = NULL);
    void DeleteRows(int32 Y, intn number, CEditTableCellElement **ppCellForInsertPoint = NULL);
    void DeleteColumns(int32 X, intn number, CEditTableCellElement **ppCellForInsertPoint = NULL);
    // Returns TRUE if the entire table was deleted
    // Also returns last leaf in the row just above
    //  the first row deleted (use to locate cursor for backspacing through cells)
    XP_Bool DeleteEmptyRows(CEditLeafElement **ppPreviousLeaf = 0);

    // Not used much - index based
    CEditTableRowElement* FindRow(intn number);

    // Find first row containing a cell that has Y as its top
    // Optionally return the "logical" row index
    CEditTableRowElement* GetRow(int32 Y, intn *pRow = NULL);

    // Find first geometric cell that is at or spans given Y value
    // The logical row is written to m_iGetRow
    CEditTableCellElement* GetFirstCellInRow(int32 Y, XP_Bool bSpan = FALSE);
    CEditTableCellElement* GetFirstCellInRow(CEditTableCellElement *pCell, XP_Bool bSpan = FALSE);
    // Find next cell using the supplied cell's Y value 
    //  (bSpan is FALSE, so Y must match exactly)
    // If pCell is NULL, use the same Y and bSpan as used for GetFirstCellInRow()
    // The logical row is written to the element's m_iGetRow
    // Note: If cell has ROWSPAN > 1, this will skip the next actual row
    CEditTableCellElement* GetNextCellInRow(CEditTableCellElement *pCell = NULL);
    
    // Find previous and cell using supplied cell's Y value 
    //  (does not depend on data from GetFirstCellInRow)
    CEditTableCellElement* GetPreviousCellInRow(CEditTableCellElement *pCell);
    CEditTableCellElement* GetLastCellInRow(CEditTableCellElement *pCell);

    // Same as above, but finds columns
    CEditTableCellElement* GetFirstCellInColumn(int32 X, XP_Bool bSpan = FALSE);
    CEditTableCellElement* GetFirstCellInColumn(CEditTableCellElement *pCell, XP_Bool bSpan = FALSE);
    // Note: If cell has COPSPAN > 1, this will skip the next actual column
    CEditTableCellElement* GetNextCellInColumn(CEditTableCellElement *pCell = NULL);
    
    // Find previous and last cell using supplied cell's X value 
    //  (does not depend on data from GetFirstCellInRow)
    CEditTableCellElement* GetPreviousCellInColumn(CEditTableCellElement *pCell);
    CEditTableCellElement* GetLastCellInColumn(CEditTableCellElement *pCell);

    // Find first cell in column or row exactly at the specified col or row index grid
    CEditTableCellElement *GetFirstCellAtColumnIndex(intn iIndex);
    CEditTableCellElement *GetFirstCellAtRowIndex(intn iIndex);

    // This gets the next geometric column or row 
    //  using supplied X or Y value as current location
    // (these use the tables m_pRowLayoutData and m_pColumnLayoutData)
    CEditTableCellElement* GetFirstCellInNextColumn(int32 iCurrentColumnX);
    CEditTableCellElement* GetFirstCellInNextRow(int32 iCurrentRowY);

    // Get the defining left (for columns) and top (for rows) value from
    //  the index into m_pColumnLayoutData and m_pRowLayoutData 
    int32 GetColumnX(intn iIndex);
    int32 GetRowY(intn iIndex);

    // Use m_pColumnLayoutData and m_pRowLayoutData
    // to get grid coordinates of a cell
    intn GetColumnIndex(int32 X);
    intn GetRowIndex(int32 Y);

    CEditCaptionElement* GetCaption();
    void SetCaption(CEditCaptionElement*);
    void DeleteCaption();
    void DeleteCaptionAbove();
    void DeleteCaptionBelow();

    void SetData( EDT_TableData *pData );
    EDT_TableData* GetData();
    EDT_TableData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_TableData* NewData();
    static void FreeData( EDT_TableData *pData );

    void SetBackgroundColor( ED_Color iColor );
    ED_Color GetBackgroundColor();
    void SetBackgroundImage( char* pImage );
    char* GetBackgroundImage();

    // Override printing and taging, since we don't allow ALIGN tag when editing.
    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );
    char* CreateTagData(EDT_TableData *pData, XP_Bool bPrinting);

    virtual void StreamOut( IStreamOut *pOut);

    //cmanske:
    // Get corresponding Layout table element
    LO_TableStruct* GetLoTable();

    // Get width of window view or parent cell of a table
    // Supply pLoTable if known, else find it
    void GetParentSize(MWContext *pContext, int32 *pWidth, int32 *pHeight = NULL, LO_TableStruct *pLoTable = NULL);

    // See edttypes.h for dConvert table and all rows and cells to Percent mode or not
    // Current bWidthPercent, bHeightPercent, bWidthDefined, and bHeightDefined are saved...
    void SetSizeMode(MWContext *pContext, int iTableMode);
    // ... to be restored by this after relayout after table, col, or row resizing
    void RestoreSizeMode(MWContext *pContext);

    // Next two use m_pRowLayoutData and m_pColumnLayoutData
    // Clear all row and column layout data
    void DeleteLayoutData();
    
    // Add new cell to column and/or row layout data
    void AddLayoutData(CEditTableCellElement *pEdCell, LO_Element *pLoCell);

    int32 GetCellSpacing() {return m_iCellSpacing; }
    int32 GetCellPadding() {return m_iCellPadding; }
    int32 GetCellBorder() {return m_iCellBorder; }

    int32 GetWidth() {return m_iWidthPixels; }
    int32 GetHeight() {return m_iHeightPixels; }
    int32 GetWidthOrPercent() { return m_iWidth; }
    int32 GetHeightOrPercent() { return m_iHeight; }

    // Get first cell in table. 
    //  Use GetNextCellInTable() or resulting pCell->GetNextCellInTable() 
    //     to walk through the table, wrapping around rows,
    //  or resultCell->pGetNextCellInLogicalRow() to walk through cells in the row
    CEditTableCellElement* GetFirstCell();

    // Result from above is stored in m_pCurrentCell    
    CEditTableCellElement* GetNextCellInTable(intn *pRowCounter = NULL);

    // Analogous routine for rows
    CEditTableRowElement* GetFirstRow();

    // Use following BEFORE we layout and build our m_pRowLayoutData and m_pColumnLayoutData    
    // This counts row elements in table and also saves result in m_iRows
    intn CountRows();
    // Max of number of columns 
    // (may be more than number of cells in any particular
    //  row because of ROWSPAN effect)
    intn CountColumns();

    intn GetRows()     {return m_iRows;}
    intn GetColumns()  {return m_iColumns;}

    // Get number of columns between given values    
    intn GetColumnsSpanned(int32 iStartX, int32 iEndX);

    // Test if any cell in the first row has COLSPAN > 1
    XP_Bool FirstRowHasColSpan();

    
    // 1. Fixup COLSPAN and ROWSPAN errors, 
    //    If all cells in a column have COLSPAN > 1,
    //    that is bad, so fix it. Same for ROWSPAN
    // 2. Save accurate number of cells in each column,
    //    compensating for COLSPAN and ROWSPAN
    //    Uses m_pColumnLayoutData and m_pRowLayoutData
    void FixupColumnsAndRows();
    
    // Add empty cells to each row so table looks rectangular
    // (each row has same number of "virtual" cells,
    //  compensating for effects of COLSPAN and ROWSPAN
    void NormalizeCellsPerRow();

private:
    ED_Color m_backgroundColor;
    char* m_pBackgroundImage;
    ED_Alignment m_align;
    ED_Alignment m_malign;
    
    //Actual width, as determined from layout
    // See comments for similar params in CEditTableCellElement
    int32   m_iWidthPixels;       
    // This is % of parent (when bWidthPercent = TRUE) or absolute (in pixels)
    int32   m_iWidth;
    XP_Bool m_bWidthPercent;       

    int32   m_iHeightPixels;       
    int32   m_iHeight;
    XP_Bool m_bHeightPercent;       

    // Pixels between cells
    int32   m_iCellSpacing;
    // Space between border and cell contents
    int32   m_iCellPadding;
    // Cell border is 1 if table border is > 0
    int32   m_iCellBorder;

    // Save last value of m_bWidthPercent, m_bWidthDefined,
    //  bHeightPercent, and bHeightDefined here
    //   during table, col, and row resizing.
    // Call RestoreTableSizeMode to reset back to these values
    XP_Bool m_bSaveWidthPercent;       
    XP_Bool m_bSaveHeightPercent;
    XP_Bool m_bSaveWidthDefined;       
    XP_Bool m_bSaveHeightDefined;

    // Maximum number of "geometric" columns
    // (May be > number in individual rows because of ROWSPAN)
    int32   m_iColumns;
    int32   m_iRows;

    // Used by GetFirstCell() and GetNextCellInTable()
    CEditTableCellElement *m_pCurrentCell;

    // For use with GetFirstCellInRow/Column and GetNextCellInRow/Column
    CEditTableCellElement *m_pFirstCellInColumnOrRow;
    CEditTableCellElement *m_pNextCellInColumnOrRow;
    int32                  m_iColX;
    int32                  m_iRowY;
    XP_Bool                m_bSpan;
    intn                   m_iGetRow;

public:
    intn m_iBackgroundSaveIndex;

    // Let CEditBuffer access this directly
    // Very weird, but these are very slow when dereferencing pointer
    //TXP_GrowableArray_EDT_CellLayoutData m_pColumnLayoutData;
    //TXP_GrowableArray_EDT_CellLayoutData m_pRowLayoutData;

    // Lets use simple arrays instead
    EDT_CellLayoutData *m_pColumnLayoutData;
    EDT_CellLayoutData *m_pRowLayoutData;
    // Sizes of these arrays - initially 1000 each,
    //  and expanded as needed
    int32   m_iColumnLayoutSize;
    int32   m_iRowLayoutSize;
};

class CEditTableRowElement: public CEditElement {
public:
    CEditTableRowElement();
    CEditTableRowElement(intn cells);
    CEditTableRowElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditTableRowElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditTableRowElement();

    virtual XP_Bool IsTableRow() { return TRUE; }
    static CEditTableRowElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsTableRow() ? (CEditTableRowElement*) pElement : 0; }
    virtual EEditElementType GetElementType() { return eTableRowElement; }
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild){
            return pChild.IsTableCell();
        }
    virtual void FinishedLoad( CEditBuffer* pBuffer );

    intn GetCells();
    XP_Bool AllCellsInRowAreEmpty();

    // Use actual cell X and Y for Insert and Delete logic
    // Return the cell where we should place the insert point after Relayout
    void InsertCells(int32 X, int32 newX, intn number, CEditTableRowElement* pSource = NULL, 
                     CEditTableCellElement **ppCellForInsertPoint = NULL);
    // Append (move) cells in supplied row to this row and delete supplied row if requested
    // (Note: Unlike most other "insert" methods, "this" is the existing row, not row to be inserted)
    // Returns the number of cells "positions" appended (sum of COLSPAN of appended cells)
    intn AppendRow( CEditTableRowElement *pAppendRow, XP_Bool bDeleteRow = TRUE );
    // Add extra empty cells to fill out a row to specified amount
    //   or use current table's max columns if iColumns is 0
    void PadRowWithEmptyCells(intn iColumns = 0);

    // Return the cell where we should place the insert point after Relayout
    void DeleteCells(int32 X, intn number, CEditTableCellElement **ppCellForInsertPoint = NULL);

    // Find cell at specific location in column
    CEditTableCellElement* FindCell(int32 X, XP_Bool bIncludeRightEdge = FALSE);

    void SetData( EDT_TableRowData *pData );
    EDT_TableRowData* GetData( );
    static EDT_TableRowData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_TableRowData* NewData();
    static void FreeData( EDT_TableRowData *pData );
    void SetBackgroundColor( ED_Color iColor );
    ED_Color GetBackgroundColor();
    void SetBackgroundImage( char* pImage );
    char* GetBackgroundImage();
    // Not sure if we need this, but it will be useful
    //   for padding tables with ragged right edges
    intn GetColumns() {return m_iColumns; }
    void SetColumns(intn iColumns) {m_iColumns = iColumns; }

    CEditTableRowElement *GetNextRow();
    // Use resultCell->pGetNextCellInLogicalRow() to walk through cells in row
    CEditTableCellElement *GetFirstCell();

private:
    ED_Color m_backgroundColor;
    char* m_pBackgroundImage;
    // Total number of "physical" columns in row
    //  (i.e., includes effect of COLSPAN and ROWSPAN)
    intn m_iColumns;
public:
    intn m_iBackgroundSaveIndex;

};

class CEditCaptionElement: public CEditSubDocElement {
public:
    CEditCaptionElement();
    CEditCaptionElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditCaptionElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);

    virtual XP_Bool IsCaption() { return TRUE; }
    static CEditCaptionElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsCaption() ? (CEditCaptionElement*) pElement : 0; }
    virtual EEditElementType GetElementType() { return eCaptionElement; }

    void SetData( EDT_TableCaptionData *pData );
    EDT_TableCaptionData* GetData( );
    EDT_TableCaptionData* GetData( int16 csid );
    static EDT_TableCaptionData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_TableCaptionData* NewData();
    static void FreeData( EDT_TableCaptionData *pData );
};

// Table data and Table header

class CEditTableCellElement: public CEditSubDocElement {
public:
    CEditTableCellElement();
    CEditTableCellElement(XP_Bool bIsHeader);
    CEditTableCellElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditTableCellElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditTableCellElement();
    virtual XP_Bool IsTableCell();
    static CEditTableCellElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsTableCell() ? (CEditTableCellElement*) pElement : 0; }
    virtual EEditElementType GetElementType();
    virtual ED_Alignment GetDefaultAlignment();
    void Unlink();

    XP_Bool IsTableData();

    virtual void StreamOut(IStreamOut *pOut);

    void SetData( EDT_TableCellData *pData );
    // This gets current params using GetData(),
    //   then overrides the size-related values from suppled data
    void SetSizeData( EDT_TableCellData *pData );
    // Supply the csid if getting data for table not
    //  yet part of doc, as when pasting from stream
    EDT_TableCellData* GetData(int16 csid = 0);
    // No tag param parsing - get just member variables
    // Supply a struct to avoid allocating another struct
    EDT_TableCellData* GetSizeData(EDT_TableCellData *pData = NULL);

    // Clear mask bits for attributes different from supplied data
    void MaskData( EDT_TableCellData *pData );
    
    EDT_TableCellData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_TableCellData* NewData();
    static void FreeData( EDT_TableCellData *pData );
    void SetBackgroundColor( ED_Color iColor );
    ED_Color GetBackgroundColor();
    void SetBackgroundImage( char* pImage );
    char* GetBackgroundImage();

    //cmanske:
    // Get corresponding Layout struct
    LO_CellStruct* GetLoCell();

    // Next cell in table - wraps around end of each
    //  row until end of table is found (returns null)
    // If pRowCount is supplied, value it is incremented
    //   when cell returned is 1st one in a next row
    CEditTableCellElement* GetNextCellInTable(intn *pRowCounter = NULL);
    // Similar to above, but finds previous cell until beginning is found (returns null)
    // If pRowCount is supplied, value it is decremented
    //   when cell returned is 1st one in a previous row
    CEditTableCellElement* GetPreviousCellInTable(intn *pRowCounter = NULL);
    
    // This gets next cell in the same logical row
    CEditTableCellElement* GetNextCellInLogicalRow();

    // Find first geometric cell that is at 
    //  given X (for column) or Y (for row)value
    // GetNext... continue using same X or Y
    // (These just call same functions in CEditTableElement)
    // If X or Y is not supplied, it is taken from "this" cell's X or Y
    CEditTableCellElement* GetFirstCellInRow(int32 Y = -1, XP_Bool bSpan = FALSE);
    CEditTableCellElement* GetFirstCellInColumn(int32 X = -1, XP_Bool bSpan = FALSE);
    CEditTableCellElement* GetNextCellInRow(CEditTableCellElement *pCell = NULL);
    CEditTableCellElement* GetNextCellInColumn(CEditTableCellElement *pCell = NULL);

    XP_Bool AllCellsInColumnAreSelected();
    XP_Bool AllCellsInRowAreSelected();

    // Test if cell contains only 1 container with 
    //  just the empty text field every new cell has
    XP_Bool IsEmpty();
    
    // Keep these in synch when selecting so
    //  we don't always have to rely on LO_Elements
    XP_Bool IsSelected() { return m_bSelected; }
    XP_Bool IsSpecialSelected() { return m_bSpecialSelected; }
    void    SetSelected(XP_Bool bSelected) { m_bSelected = bSelected; }
    void    SetSpecialSelected(XP_Bool bSelected) { m_bSpecialSelected = bSelected; }

    // Move contents of supplied cell into this cell
    // If merging results in a row deletion, iNewRowSpan is adjusted
    void MergeCells(CEditTableCellElement* pCell, int32& iNewRowSpan);
    void SplitCell();

    // Delete all contents, leaving just the minimum empty text element
    // Set param to TRUE only when deleting all selected cells
    // using CEditBuffer::DeleteSelectedCells()
    void DeleteContents(XP_Bool bMarkAsDeleted = FALSE);

    inline XP_Bool IsDeleted() { return m_bDeleted; }
    inline void SetDeleted(XP_Bool bDeleted) {m_bDeleted = bDeleted;}

    // Get all text from a cell. If bJoinParagrphs is FALSE,
    //  appropriate CR/LF is added between containers,
    //  else they are appended without CR/LF so cell contents
    //  can be pasted into Excell spreadsheet
    char * GetText(XP_Bool bJoinParagraphs = FALSE);

    // Returns sum of widths of all cells in first row in table
    int32 GetParentWidth();
    // Sum of heights of all cells in first column of table
    int32 GetParentHeight();

    int32 GetX() { return m_X; }
    int32 GetY() { return m_Y; }
    void  SetX(int32 x) { m_X = x; }
    void  SetY(int32 y) { m_Y = y; }
    intn  GetRow() { return m_iRow; }
    int32 GetWidth() { return m_iWidthPixels; }
    int32 GetHeight() { return m_iHeightPixels; }
    int32 GetWidthOrPercent() { return m_iWidth; }
    int32 GetHeightOrPercent() { return m_iHeight; }
    int32 GetColSpan() { return m_iColSpan; }
    int32 GetRowSpan() { return m_iRowSpan; }
    XP_Bool GetWidthPercent() { return m_bWidthPercent; }
    XP_Bool GetHeightPercent() { return m_bHeightPercent; }

    // This gets the width including the cell border,
    //   padding inside cell, and inter-cell space to the next cell
    // Supply pTable if available for efficiency
    int32 GetFullWidth(CEditTableElement *pTable = NULL);
    int32 GetFullHeight(CEditTableElement *pTable = NULL);

    // These will do appropriate action using SetData
    void IncreaseColSpan(int32 iIncrease);
    void IncreaseRowSpan(int32 iIncrease);
    void DecreaseColSpan(int32 iDecrease);
    void DecreaseRowSpan(int32 iDecrease);

    // Insert as last child of supplied parent 
    //   but first save current parent and next pointers
    void SwitchLinkage(CEditTableRowElement *pParentRow);
    // This switches parent and next pointers
    //   to those saved during SwitchLinkage
    void RestoreLinkage();

    // Save current percent and "defined" values -- do this before resizing, which may need
    //  to change the mode for better control of resizing
    // Since this is always called when we know the cell's data,
    //  supply the bWidthDefined and bHeightDefined values
    //  (percent mode params are held in class member variables)
    void SaveSizeMode(XP_Bool bWidthDefined, XP_Bool bHeightDefined);
    
    // Restore saved width and height percent modes,
    //   readjust m_bWidth an m_bHeight, and call SetData to set tag data
    void RestoreSizeMode(int32 iParentWidth, int32 iParentHeight);

    // Calculate the Percent iWidth or iHeight from the 
    //  iWidthPixels and iHeightPixels in pData...
    void CalcPercentWidth(EDT_TableCellData *pData);
    void CalcPercentHeight(EDT_TableCellData *pData);

    // ...vice versa
    void CalcPixelWidth(EDT_TableCellData *pData);
    void CalcPixelHeight(EDT_TableCellData *pData);

    void SetWidth(XP_Bool bWidthDefined, XP_Bool bWidthPercent, int32 iWidthPixels);
    void SetHeight(XP_Bool bHeightDefined, XP_Bool bHeightPercent, int32 iHeightPixels);
    void SetRow(intn iRow) {m_iRow = iRow;}

    // Next two are used when dragging the right border
    // Set all cells in a column to the width supplied
    void SetColumnWidthRight(CEditTableElement *pTable, LO_Element *pLoCell, EDT_TableCellData *pData);
    // Set all cells in a row to the width params supplied in pData
    void SetRowHeightBottom(CEditTableElement *pTable, LO_Element *pLoCell, EDT_TableCellData *pData);

    // Next two are use when resizing inside table cell property dialog
    // Supplying bWidthDefined or bHeightDefined allows clearing this for entire col or row
    // Set all cells in a column to the width supplied
    void SetColumnWidthLeft(CEditTableElement *pTable, CEditTableCellElement *pEdCell, EDT_TableCellData *pData);
    // Set all cells in a row to the width supplied
    void SetRowHeightTop(CEditTableElement *pTable, CEditTableCellElement *pEdCell, EDT_TableCellData *pData);

private:
    ED_Color m_backgroundColor;
    char* m_pBackgroundImage;

    // Cache this for efficiency
    XP_Bool m_bWidthDefined;
    XP_Bool m_bHeightDefined;
    XP_Bool m_bWidthPercent;       
    XP_Bool m_bHeightPercent;
    int32   m_iColSpan;
    int32   m_iRowSpan;

    // These are set only by FixupTableData() during Relayou
    int32 m_X;
    int32 m_Y;
    intn m_iRow;    // Current logical and actual row index

    //Actual width, as determined from layout
    //Set by CEditBuffer::FixupTableData() after a table is layed out
    // We need this because tag data is not recorded
    // if m_bWidthDefined is FALSE, but we want to be able
    // to have the actual width available as default when
    // user edits the table or cell data
    int32   m_iWidthPixels;       
    int32   m_iHeightPixels;       

    // This is actual width or height in pixels, or Percent if b[Width|Height]Percent = TRUE;
    int32   m_iWidth;       
    int32   m_iHeight;       

    // Save last value of m_bWidthPercent, m_bWidthDefined,
    //  bHeightPercent, and bHeightDefined here
    //   during table, col, and row resizing.
    // Call RestoreTableSizeMode to reset back to these values
    XP_Bool m_bSaveWidthPercent;       
    XP_Bool m_bSaveHeightPercent;
    XP_Bool m_bSaveWidthDefined;       
    XP_Bool m_bSaveHeightDefined;

    // This is used to temporarily switch cell to 
    //  a table created for copying contents
    // These are used by SwitchLinkage() and RestoreLinkage()
    CEditElement *m_pSaveParent;
    CEditElement *m_pSaveNext;

    // This should be TRUE only if cell is also in CEditBuffer::m_SelectedEdCells list
    XP_Bool       m_bSelected;
    XP_Bool       m_bSpecialSelected;
    
    // Deleting an arbitrary set of cells is tricky 
    // since some cells only have contents deleted,
    // and we want to leave those selected, so we can't rely on 
    // m_SeletectedEdCells list to be empty after "deleting" all cells
    // This marks cells to be skipped over on successive recursions.
    // Must call CEditTable::ResetDeletedCells() to clear these flags when done
    XP_Bool      m_bDeleted;

public:
    intn    m_iBackgroundSaveIndex;
};

class CEditLayerElement: public CEditElement {
public:
    CEditLayerElement();
    CEditLayerElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditLayerElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);

    virtual XP_Bool IsLayer() { return TRUE; }
    static CEditLayerElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsLayer() ? (CEditLayerElement*) pElement : 0; }
    virtual EEditElementType GetElementType() { return eLayerElement; }
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild){
            return pChild.IsContainer();
        }
    virtual void FinishedLoad( CEditBuffer* pBuffer );

    void SetData( EDT_LayerData *pData );
    EDT_LayerData* GetData( );
    static EDT_LayerData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_LayerData* NewData();
    static void FreeData( EDT_LayerData *pData );

    // Temporary methods. Remove when we can display layers.
    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );


private:
};

class CEditDivisionElement: public CEditElement {
public:
    CEditDivisionElement();
    CEditDivisionElement(CEditElement *pParent, PA_Tag *pTag, int16 csid);
    CEditDivisionElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);

    virtual XP_Bool IsDivision();
    static CEditDivisionElement* Cast(CEditElement* pElement);
    virtual EEditElementType GetElementType();
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild);

    ED_Alignment GetAlignment();
    void ClearAlignment();
    XP_Bool HasData();

    void SetData( EDT_DivisionData *pData );
    EDT_DivisionData* GetData( );
    static EDT_DivisionData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_DivisionData* NewData();
    static void FreeData( EDT_DivisionData *pData );

    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );

private:
};

//
// CEditRootDocElement - Top most element in the tree, tag HTML
//
class CEditRootDocElement: public CEditSubDocElement {
private:
    CEditBuffer* m_pBuffer;
public:
    CEditRootDocElement( CEditBuffer* pBuffer ):
            CEditSubDocElement(0, P_MAX), m_pBuffer( pBuffer ){}
    virtual XP_Bool Reduce( CEditBuffer * /*pBuffer */ ){ return FALSE; }
    virtual XP_Bool ShouldStreamSelf( CEditSelection& /*local*/, CEditSelection& /*selection*/ ) { return FALSE; }

    virtual void FinishedLoad( CEditBuffer *pBuffer );

    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );

    virtual XP_Bool IsRoot() { return TRUE; }
    static CEditRootDocElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsRoot() ? (CEditRootDocElement*) pElement : 0; }
    CEditBuffer* GetBuffer(){ return m_pBuffer; }
#ifdef DEBUG
    virtual void ValidateTree();
#endif
};

class CEditLeafElement: public CEditElement {
private:
    ElementOffset m_iSize;        // fake size.
public:
    // pass through constructors.
    CEditLeafElement(CEditElement *pParent, int tagType):
            CEditElement(pParent,tagType),m_iSize(1){}

    CEditLeafElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer):
            CEditElement(pStreamIn,pBuffer),m_iSize(1){}

    //
    // CEditElement Stuff
    //
    virtual XP_Bool IsLeaf() { return TRUE; }
    static CEditLeafElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsLeaf() ? (CEditLeafElement*) pElement : 0; }
    virtual PA_Tag* TagOpen( int iEditOffset );

    virtual void GetAll(CEditSelection& selection);
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild );
    virtual ElementIndex GetPersistentCount();
    virtual void StreamToPositionalText( IStreamOut *pOut, XP_Bool bEnd );

    virtual XP_Bool IsContainerContainer();
    virtual XP_Bool IsFirstInContainer();

    //
    // Stuff created at this level (Leaf)
    //
    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement )=0;
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement )=0;
    virtual LO_Element* GetLayoutElement()=0;

    virtual XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool bEditStickyAfter,
                LO_Element*& pRetElement,
                int& pLayoutOffset )=0;       // if appropriate
    virtual ElementOffset GetLen(){ return m_iSize; }
    virtual void DeleteChar( MWContext * /*pContext*/, int /*iOffset*/ ){ m_iSize = 0; }
    virtual CEditElement* Divide(int iOffset);
    virtual CEditTextElement* CopyEmptyText(CEditElement *pParent = 0);

    // HREF management...
    virtual void SetHREF( ED_LinkId ){}
    virtual ED_LinkId GetHREF(){ return ED_LINK_ID_NONE; }

    //
    // Leaf manipulation functions..
    //
    XP_Bool NextPosition(ElementOffset iOffset, CEditLeafElement*& pNew, ElementOffset& iNewOffset );
    XP_Bool PrevPosition(ElementOffset iOffset, CEditLeafElement*& pNew, ElementOffset& iNewOffset );

    virtual CPersistentEditInsertPoint GetPersistentInsertPoint(ElementOffset offset);

    // True if this is a bucket for totally unknown html
    virtual XP_Bool IsUnknownHTML();
    // True if this element is an HTML comment
    virtual XP_Bool IsComment();
    // True if this element is an HTML comment that matches a given prefix.
    // IsComment("FOO") will match "<!-- FOOBAR -->"
    virtual XP_Bool IsComment(char* pPrefix);

    XP_Bool IsMisspelled();

#ifdef DEBUG
    virtual void ValidateTree();
#endif
protected:
    void DisconnectLayoutElements(LO_Element* pElement);
    void SetLayoutElementHelper( intn desiredType, LO_Element** pElementHolder,
          intn iEditOffset, intn lo_type,
          LO_Element* pLoElement);
    void ResetLayoutElementHelper( LO_Element** pElementHolder, intn iEditOffset,
            LO_Element* pLoElement );
};

class CEditContainerElement: public CEditElement {
private:
    ED_Alignment m_align;
    ED_Alignment m_defaultAlign;
    XP_Bool m_hackPreformat;
public:
    XP_Bool m_bHasEndTag; // Only important for parsing.

    static CEditContainerElement* NewDefaultContainer( CEditElement *pParent,
            ED_Alignment align );
    CEditContainerElement(CEditElement *pParent, PA_Tag *pTag, int16 csid,
            ED_Alignment eAlign);
    CEditContainerElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual void StreamInChildren(IStreamIn* pIn, CEditBuffer* pBuffer);

    virtual void StreamOut( IStreamOut *pOut);
    virtual XP_Bool ShouldStreamSelf( CEditSelection& /*local*/, CEditSelection& /*selection*/ ) { return TRUE; }
    virtual XP_Bool IsContainer() { return TRUE; }
    static CEditContainerElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsContainer() ? (CEditContainerElement*) pElement : 0; }
    virtual XP_Bool IsContainerContainer() { return FALSE; }

    virtual ElementIndex GetPersistentCount();
    virtual void FinishedLoad( CEditBuffer *pBuffer );
    virtual void AdjustContainers( CEditBuffer *pBuffer );

    virtual PA_Tag* TagOpen( int iEditOffset );
    virtual PA_Tag* TagEnd( );
    virtual EEditElementType GetElementType();
    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );

    virtual CEditElement* Clone( CEditElement *pParent = 0);
    virtual void StreamToPositionalText( IStreamOut *pOut, XP_Bool bEnd );

    static EDT_ContainerData* NewData();
    static void FreeData( EDT_ContainerData *pData );

    virtual XP_Bool IsAcceptableChild(CEditElement& pChild) {return pChild.IsLeaf();}

    //
    // Implementation
    //
    void SetData( EDT_ContainerData *pData );
    EDT_ContainerData* GetData( );
    EDT_ContainerData* ParseParams( PA_Tag *pTag, int16 csid );

    void SetAlignment( ED_Alignment eAlign );
    ED_Alignment GetAlignment( ){ return m_align; }
    void CopyAttributes( CEditContainerElement *pContainer );
    XP_Bool IsEmpty();

    XP_Bool ShouldSkipTags();
    XP_Bool IsImplicitBreak();
    // 0..2, where 0 = not in pseudo paragraph.
    // 1 = first container of pseudo paragraph.
    // 2 = second container of pseudo paragraph.
    int16 GetPseudoParagraphState(); 
    XP_Bool ForcesDoubleSpacedNextLine();

    //cmanske: Get single string with all of container's text (no embeded CR/LF)
    // Caller must XP_FREE the result
    char *GetText();

#ifdef DEBUG
    virtual void ValidateTree();
#endif

    XP_Bool IsPlainFirstContainer();
    XP_Bool IsFirstContainer();
    XP_Bool SupportsAlign();
    void AlignIfEmpty( ED_Alignment eAlign );
    XP_Bool HasExtraData();
};

class CEditListElement: public CEditElement {
private:
    char *m_pBaseURL; /* If an ED_LIST_TYPE_CITE, this is the URL from the enclosing <BASE> tag. */

public:
    CEditListElement( CEditElement *pParent, PA_Tag *pTag, int16 csid );
    CEditListElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditListElement();

    /* Test if supplied element is a list of compatable type */
    XP_Bool IsCompatableList(CEditElement *pElement);
    XP_Bool IsList(){ return TRUE; }
    static CEditListElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsList() ? (CEditListElement*) pElement : 0; }

    virtual PA_Tag* TagOpen( int iEditOffset );
    virtual CEditElement* Clone( CEditElement *pParent = 0);

    static EDT_ListData* NewData();
    static void FreeData( EDT_ListData *pData );

    // Streaming
    virtual EEditElementType GetElementType();

    //
    // Implementation
    //
    void SetData( EDT_ListData *pData );
    EDT_ListData* GetData( );
    static EDT_ListData* ParseParams( PA_Tag *pTag, int16 csid );

    void CopyData(CEditListElement* pOther);

    XP_Bool IsMailQuote();
#ifdef DEBUG
    virtual void ValidateTree();
#endif

};

//
// CEditTextElement
//

class CEditTextElement: public CEditLeafElement {
public:
    char* m_pText;                          // pointer to actual string.
    int m_textSize;                         // number of bytes allocated
    LO_Element* m_pFirstLayoutElement;
    LO_TextBlock* m_pTextBlock;
    ED_TextFormat m_tf;
    intn m_iFontSize;
    ED_Color m_color;
    ED_LinkId m_href;
    char* m_pFace;
    int16  m_iWeight;                 /* font weight range = 100-900, 400=Normal, 700=Bold*/
    int16  m_iPointSize;              /* not sure what default is! Use 0 to mean "default" */
    char* m_pScriptExtra;   // <SCRIPT> tag parameters

public:
    CEditTextElement(CEditElement *pParent, char *pText);
    CEditTextElement(IStreamIn *pStreamIn, CEditBuffer* pBuffer);
    virtual ~CEditTextElement();

    virtual XP_Bool IsText() { return TRUE; }
    static CEditTextElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsText() ? (CEditTextElement*) pElement : 0; }

    // accessor functions
    char* GetText(){ return m_pText; }
    char* GetTextWithConvertedSpaces();
    // If bConvertSpaces is FALSE, then csid is not used.
    void SetText(char* pText, XP_Bool bConvertSpaces=FALSE, int16 csid=0 );
    int GetSize(){ return m_textSize; }
    ElementOffset GetLen(){ return m_pText ? XP_STRLEN( m_pText ) : 0 ; }
    LO_Element* GetLayoutElement();
    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );

    void SetColor( ED_Color iColor );
    ED_Color GetColor(){ return m_color; }

    // If bRelative is TRUE, the iSize changes relative to existing size (usually -1 or +1)
    void SetFontSize(int iSize, XP_Bool bRelative = FALSE);
    int GetFontSize();
    void SetFontFace(char* face);
    char* GetFontFace();
    void SetFontWeight(int16 weight);
    int16 GetFontWeight();
    void SetFontPointSize(int16 pointSize);
    int16 GetFontPointSize();
    void SetScriptExtra(char* );
    char* GetScriptExtra();
    void SetHREF( ED_LinkId );
    ED_LinkId GetHREF(){ return m_href; }
    void ClearFormatting();

    void SetData( EDT_CharacterData *pData );
    EDT_CharacterData *GetData();
    void MaskData( EDT_CharacterData*& ppData );

    //
    // utility functions
    //
    XP_Bool InsertChar( int iOffset, int newChar );
    // returns number of bytes inserted.
    int32 InsertChars( int iOffset, char* pNewChars );
    XP_Bool GetLOTextAndOffset( ElementOffset iEditOffset, XP_Bool bEditStickyAfter, LO_TextStruct*& pRetText,
        int& pLayoutOffset );

    // for leaf implementation.
    void DeleteChar( MWContext *pContext, int iOffset );
    XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool bEditStickyAfter,
                LO_Element*& pRetText,
                int& pLayoutOffset );

    LO_TextStruct* GetLOText( int iEditOffset );
	LO_TextBlock* GetTextBlock();
	
	virtual XP_Bool CanReflow();

    virtual PA_Tag* TagOpen( int iEditOffset );

    // output funcitons
    virtual void PrintOpen( CPrintState *ps );
    virtual void PrintWithEscapes( CPrintState *ps, XP_Bool bTrimTrailingSpaces );
    virtual void PrintLiteral( CPrintState *ps );
    virtual void StreamOut( IStreamOut *pOut );
    // Why is "selection" param commented out?
    virtual void PartialStreamOut( IStreamOut *pOut, CEditSelection& /*selection*/ );
    virtual EEditElementType GetElementType();
    virtual XP_Bool Reduce( CEditBuffer *pBuffer );
    virtual void StreamToPositionalText( IStreamOut *pOut, XP_Bool bEnd );

    CEditElement* SplitText( int iOffset );
    void DeleteText();
    XP_Bool IsOffsetEnd( int iOffset ){
        ElementOffset iLen = GetLen();
        return ( iOffset == iLen
                  || ( iOffset == iLen-1
                        && m_pText[iLen-1] == ' ')
                );
    }
    // Copy current element's attributes to the supplied element
    void CopyTextFormat(CEditTextElement *pTextElement);
    CEditTextElement* CopyEmptyText( CEditElement *pParent = 0);
    void FormatOpenTags(PA_Tag*& pStartList, PA_Tag*& pEndList);
    void FormatTransitionTags(CEditTextElement *pNext,
            PA_Tag*& pStart, PA_Tag*& pEndList);
    void FormatCloseTags(PA_Tag*& pStartList, PA_Tag*& pEndList);
    char* DebugFormat();

    void PrintTagOpen( CPrintState *pPrintState, TagType t, ED_TextFormat tf, char* pExtra=0 );
    void PrintFormatDifference( CPrintState *ps, ED_TextFormat bitsDifferent );
    void PrintFormat( CPrintState *ps, CEditTextElement *pFirst, ED_TextFormat mask );
    void PrintTagClose( CPrintState *ps, TagType t );
    void PrintPopFormat( CPrintState *ps, int iStackTop );
    ED_TextFormat PrintFormatClose( CPrintState *ps );

    XP_Bool SameAttributes(CEditTextElement *pCompare);
    // Stronger than SameAtributes - must match all text styles
    XP_Bool SameFormat(CEditTextElement *pCompare);
    void ComputeDifference(CEditTextElement *pFirst,
        ED_TextFormat mask, ED_TextFormat& bitsCommon, ED_TextFormat& bitsDifferent);

#ifdef DEBUG
    virtual void ValidateTree();
#endif

private:
    void PrintRange(CPrintState *ps, int32 start, int32 end);
    void PrintOpen2(CPrintState* ps, XP_Bool bTrimTrailingSpaces);
};

//-----------------------------------------------------------------------------
//  CEditImageElement
//-----------------------------------------------------------------------------

class CEditImageElement: public CEditLeafElement {
    LO_ImageStruct *m_pLoImage;
    ED_Alignment m_align;
    char *m_pParams;            // partial parameter string

    //EDT_ImageData *pData;
    int32 m_iHeight;
    int32 m_iWidth;
    ED_LinkId m_href;
    XP_Bool m_bSizeWasGiven;
    XP_Bool m_bSizeIsBogus;
    XP_Bool m_bWidthPercent;
    XP_Bool m_bHeightPercent;
public:
    intn m_iSaveIndex;
    intn m_iSaveLowIndex;

public:
    // pass through constructors.
    CEditImageElement(CEditElement *pParent, PA_Tag* pTag = 0, int16 csid = 0,
            ED_LinkId href = ED_LINK_ID_NONE );
    CEditImageElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditImageElement();

    LO_Element* GetLayoutElement();
    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );

    void StreamOut( IStreamOut *pOut );
    virtual EEditElementType GetElementType();


    //
    // CEditElement implementation
    //
    PA_Tag* TagOpen( int iEditOffset );
    void PrintOpen( CPrintState *pPrintState );

    //
    // CEditLeafElement Implementation
    //
    XP_Bool IsImage() { return TRUE; }
    static CEditImageElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsImage() ? (CEditImageElement*) pElement : 0; }
    void FinishedLoad( CEditBuffer *pBuffer );
    LO_ImageStruct* GetLayoutImage(){ return m_pLoImage; }

    XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool /*bEditStickyAfter*/ ,
                LO_Element*& pRetElement,
                int& pLayoutOffset );

    int32 GetDefaultBorder();
    void SetHREF( ED_LinkId );
    ED_LinkId GetHREF(){ return m_href; }

    //
    // Implementation
    //
    void SetImageData( EDT_ImageData *pData );
    EDT_ImageData* GetImageData( );
    EDT_ImageData* ParseParams( PA_Tag *pTag, int16 csid );
    char* FormatParams(EDT_ImageData* pData, XP_Bool bForPrinting);

    XP_Bool SizeIsKnown();

    //CLM: Since HREF is a "character" attribute,
    //  we look at images for this as well
    void MaskData( EDT_CharacterData*& pData );
    EDT_CharacterData* GetCharacterData();
};


//-----------------------------------------------------------------------------
//  CEditHRuleElement
//-----------------------------------------------------------------------------

class CEditHorizRuleElement: public CEditLeafElement {
    LO_HorizRuleStruct *m_pLoHorizRule;
public:
    // pass through constructors.
    CEditHorizRuleElement(CEditElement *pParent, PA_Tag* pTag = 0, int16 csid = 0 );
    CEditHorizRuleElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditHorizRuleElement();

    void StreamOut( IStreamOut *pOut);
    virtual EEditElementType GetElementType();

    //
    // CEditLeafElement Implementation
    //
    virtual XP_Bool CausesBreakBefore() { return TRUE;}
    virtual XP_Bool CausesBreakAfter() { return TRUE;}
    virtual XP_Bool AllowBothSidesOfGap() { return TRUE; }

    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );

    LO_Element* GetLayoutElement();
    LO_HorizRuleStruct* GetLayoutHorizRule(){ return m_pLoHorizRule; }

    XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool /* bEditStickyAfter */,
                LO_Element*& pRetElement,
                int& pLayoutOffset );

    static EDT_HorizRuleData* NewData();
    static void FreeData( EDT_HorizRuleData *pData );

    //
    // Implementation
    //
    void SetData( EDT_HorizRuleData *pData );
    EDT_HorizRuleData* GetData( );
    static EDT_HorizRuleData* ParseParams( PA_Tag *pTag, int16 csid );
};

//-----------------------------------------------------------------------------
//  CEditIconElement
//-----------------------------------------------------------------------------

#define EDT_ICON_NAMED_ANCHOR           0
#define EDT_ICON_FORM_ELEMENT           1
#define EDT_ICON_UNSUPPORTED_TAG        2
#define EDT_ICON_UNSUPPORTED_END_TAG    3
#define EDT_ICON_JAVA                   4
#define EDT_ICON_PLUGIN                 5
#define EDT_ICON_OBJECT                 6
#define EDT_ICON_LAYER                  7

class CEditIconElement: public CEditLeafElement {
private:
    // States for parsing LOCALDATA tag, see ParseLocalData().
    enum {BeforeMIME,InMIME,BeforeURL,InURL,AfterURL};

    // States for ReplaceParamValue().
    enum {OutsideValue,BeforeValue,InsideValue,InsideValueQuote};

protected:
    LO_ImageStruct *m_pLoIcon;
    TagType m_originalTagType;
    int32 m_iconTag;
    XP_Bool m_bEndTag;
    char *m_pSpoofData;

public:
    // pass through constructors.
    CEditIconElement(CEditElement *pParent, int32 iconTag, PA_Tag* pTag = 0, int16 csid = 0 );
    CEditIconElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    ~CEditIconElement();

    void StreamOut( IStreamOut *pOut);
    virtual EEditElementType GetElementType(){ return eIconElement; }

    static ED_TagValidateResult ValidateTag(  char *Data, XP_Bool bNoBrackets );

    //
    // CEditLeafElement Implementation
    //
    XP_Bool IsIcon() { return TRUE; }
    static CEditIconElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsIcon() ? (CEditIconElement*) pElement : 0; }

    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );

    LO_Element* GetLayoutElement(){ return (LO_Element*)m_pLoIcon; }
    LO_ImageStruct* GetLayoutIcon(){ return m_pLoIcon; }

    XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool /* bEditStickyAfter */,
                LO_Element*& pRetElement,
                int& pLayoutOffset );

    PA_Tag* TagOpen( int iEditOffset );
    void PrintOpen( CPrintState *pPrintState );
    void PrintEnd( CPrintState *pPrintState );

    char* GetData();

    // Creates list of the mimeType/URL pairs from the LOCALDATA parameter.
    // List of Strings.
    // mimeTypes and URLs must be freed with FreeLocalDataLists() when done.
    // Returns the length of the lists.
    int ParseLocalData(char ***mimeTypes,char ***urls);
    static void FreeLocalDataLists(char **mimeTypes,char **urls,int count);

    // Replace all occurances of pOld in parameter values with pNew.
    // Used by LOCALDATA to update tags when saved/published/mailed.
    void ReplaceParamValues(char *pOld,char *pNew);

    // Call this to set both Width and Height at same time,
    //  to avoid relayout twice if Width and Height are set separetely
    // Set either value to 0 to ignore 
    //  Do we ever need to set to 0? (change to -1 to "ignore" if we need 0)
    void SetSize(XP_Bool bWidthPercent, int32 iWidth,
                 XP_Bool bHeightPercent, int32 iHeight);

    // Not currently implemented.
    void SetData( char* );

    void MorphTag( PA_Tag *pTag );
    void SetSpoofData( PA_Tag* pTag );
    void SetSpoofData( char* pData );

    virtual XP_Bool IsUnknownHTML();
    virtual XP_Bool IsComment();
    virtual XP_Bool IsComment(char* pPrefix);

public:
    // Used by CEditSaveObject.
    intn *m_piSaveIndices;
};

//-----------------------------------------------------------------------------
//  CEditTargetElement
//-----------------------------------------------------------------------------
class CEditTargetElement: public CEditIconElement {
private:
public:
    CEditTargetElement(CEditElement *pParent, PA_Tag* pTag = 0, int16 csid = 0 );
    CEditTargetElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    void StreamOut( IStreamOut *pOut);
    EEditElementType GetElementType(){ return eTargetElement; }

    XP_Bool IsTarget() { return TRUE; }
    PA_Tag* TagOpen( int iEditOffset );

    char *GetName();
    void SetName( char* pName, int16 csid );

    void SetData( EDT_TargetData *pData );
    EDT_TargetData* GetData();
    EDT_TargetData* GetData(int16 csid);
    static EDT_TargetData* ParseParams( PA_Tag *pTag, int16 csid );
    static EDT_TargetData* NewTargetData();
    static void FreeTargetData(EDT_TargetData* pData);
};


//-----------------------------------------------------------------------------
//  CEditBreakElement
//-----------------------------------------------------------------------------

class CEditBreakElement: public CEditLeafElement {
    LO_LinefeedStruct *m_pLoLinefeed;
public:
    // pass through constructors.
    CEditBreakElement(CEditElement *pParent, PA_Tag* pTag = 0, int16 csid = 0 );
    CEditBreakElement(IStreamIn *pStreamIn, CEditBuffer *pBuffer);
    virtual ~CEditBreakElement();

    void StreamOut( IStreamOut *pOut );
    virtual EEditElementType GetElementType();

    void PrintOpen( CPrintState *ps );

    virtual XP_Bool IsBreak() { return TRUE; }
    virtual XP_Bool CausesBreakAfter() { return TRUE;}
    static CEditBreakElement* Cast(CEditElement* pElement) {
        return pElement && pElement->IsBreak() ? (CEditBreakElement*) pElement : 0; }
    //
    // CEditLeafElement Implementation
    //
    void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );

    LO_Element* GetLayoutElement();

    XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool bEditStickyAfter,
                LO_Element*& pRetElement,
                int& pLayoutOffset );
};

class CEditEndElement: public CEditHorizRuleElement {
public:
    CEditEndElement(CEditElement *pParent):
            CEditHorizRuleElement(pParent){
            EDT_HorizRuleData ourParams;
            ourParams.align = ED_ALIGN_LEFT;
            ourParams.size = DEFAULT_HR_THICKNESS;
            ourParams.bNoShade = FALSE;
            ourParams.iWidth = 64;
            ourParams.bWidthPercent = FALSE;
            ourParams.pExtra = 0;
            SetData(&ourParams);
            }

    virtual XP_Bool ShouldStreamSelf( CEditSelection& /* local */, CEditSelection& /* selection */ ) { return FALSE; }
    virtual void StreamOut( IStreamOut * /* pOut */) { XP_ASSERT(FALSE); }

    void SetLayoutElement( intn /* iEditOffset */ , intn lo_type,
                LO_Element* pLoElement ){
        CEditHorizRuleElement::SetLayoutElement(-1, lo_type, pLoElement);
    }

    virtual EEditElementType GetElementType() { return eEndElement; }
    virtual void PrintOpen( CPrintState * /*pPrintState*/ ) {}
    virtual void PrintEnd( CPrintState * /*pPrintState*/ ) {}
};

class CEditEndContainerElement: public CEditContainerElement {
public:
    CEditEndContainerElement(CEditElement *pParent);
    virtual void StreamOut( IStreamOut * pOut);
    virtual XP_Bool ShouldStreamSelf( CEditSelection& local, CEditSelection& selection );
    virtual XP_Bool IsAcceptableChild(CEditElement& pChild);
    virtual void PrintOpen( CPrintState * pPrintState );
    virtual void PrintEnd( CPrintState * pPrintState );
    virtual XP_Bool IsEndContainer();
    virtual void AdjustContainers( CEditBuffer* pBuffer );
};

class CEditInternalAnchorElement: public CEditLeafElement {
public:
    CEditInternalAnchorElement(CEditElement *pParent);
    virtual ~CEditInternalAnchorElement();
    virtual XP_Bool Reduce( CEditBuffer* );

    virtual XP_Bool ShouldStreamSelf( CEditSelection& local, CEditSelection& selection);
    virtual void StreamOut( IStreamOut *pOut);

    virtual void SetLayoutElement( intn iEditOffset, intn lo_type,
                LO_Element* pLoElement );
    virtual void ResetLayoutElement( intn iEditOffset,
                LO_Element* pLoElement );
    virtual LO_Element* GetLayoutElement();

    virtual XP_Bool GetLOElementAndOffset( ElementOffset iEditOffset, XP_Bool bEditStickyAfter,
                LO_Element*& pRetElement,
                int& pLayoutOffset );

    virtual EEditElementType GetElementType();
    virtual void PrintOpen( CPrintState *pPrintState );
    virtual void PrintEnd( CPrintState *pPrintState );
};


//
// Macro to compute the next size of an TextBuffer.
//
#define GROW_TEXT(x)    ((x+0x20) & ~0x1f)   // grow buffer by 32 bytes

//-----------------------------------------------------------------------------
// CEditPosition
//-----------------------------------------------------------------------------

class CEditPosition {
private:
    CEditElement* m_pElement;
    int m_iOffset;
public:
    CEditPosition( CEditElement* pElement, int iOffset = 0 ):
            m_pElement(pElement), m_iOffset( iOffset ){}

    int Offset() { return m_iOffset; }
    CEditElement* Element() { return m_pElement; }
    int IsPositioned(){ return m_pElement != 0; }
};


class CEditPositionComparable: public CEditPosition {
private:
    TXP_GrowableArray_int32 m_Array;
    void CalcPosition( TXP_GrowableArray_int32* pA, CEditPosition *pPos );
public:
    CEditPositionComparable( CEditElement* pElement, int iOffset = 0 ):
            CEditPosition( pElement, iOffset )
    {
        CalcPosition( &m_Array, this );
    }

    // return -1 if passed pos is before
    // return 0 if pos is the same
    // return 1 if pos is greater
    int Compare( CEditPosition *pPos );
};

//-----------------------------------------------------------------------------
// CEditBuffer (and others)..
//-----------------------------------------------------------------------------

class CParseState {
public:
    XP_Bool bLastWasSpace;
    XP_Bool m_bInTitle;
private:
    int m_iDocPart;
public:
    XP_Bool InBody();
    void StartBody();
    void EndBody();

    TagType m_inJavaScript; // 0 when not in any script, otherwise the tag of the kind of script
    int m_baseFontSize;
    TXP_PtrStack_ED_Alignment m_formatAlignStack;
    TXP_PtrStack_TagType m_formatTypeStack;
    TXP_PtrStack_CEditTextElement m_formatTextStack;
    CEditTextElement *m_pNextText;
    CStreamOutMemory *m_pJavaScript;
    CStreamOutMemory* m_pPostBody;
    CStreamOutMemory* GetStream(); // Gets either m_pJavaScript or m_postBody, depending upon m_iDocPart

public:
    void Reset();
    CParseState();
    ~CParseState();
private:
    void Free(CStreamOutMemory*& pStream);
};

class CPrintState {
public:
    int m_iLevel;
    int m_iCharPos;
    XP_Bool m_bTextLast;
    IStreamOut* m_pOut;
    TXP_PtrStack_ED_TextFormat m_formatStack;
    TXP_PtrStack_CEditTextElement m_elementStack;
    CEditBuffer *m_pBuffer;
    XP_Bool m_bEncodeSelectionAsComment;
    CEditSelection m_selection;
public:
    void Reset( IStreamOut *pStream, CEditBuffer *pBuffer );
    XP_Bool ShouldPrintSelectionComments(CEditLeafElement* pElement);
    XP_Bool ShouldPrintSelectionComment(CEditLeafElement* pElement, XP_Bool bEnd);
    void PrintSelectionComment(XP_Bool bEnd, XP_Bool bStickyAfter);
};


//
// This is a structure, not a class.  It cannot be instanciated with NEW and
//  should never be derived from.
//
class CEditLinkManager;

struct ED_Link {
private:
    // Should never create on of these with a constructor!  Must
    //  create it only through CEditLinkManager::Add
    ED_Link(){}
public:
    void AddRef(){ iRefCount++; }

    void Release() {} 
    // A bug, probably should call pLinkManager::Free(), not worth the work to fix 
    // it and make sure ref counting works all the time.  hardts

    EDT_HREFData* GetData();
    intn iRefCount;
    CEditLinkManager* pLinkManager;
    int linkOffset;
    char *hrefStr;
    char *pExtra;
    XP_Bool bAdjusted;
};


typedef TXP_GrowableArray_pChar ED_HREFList;
class CEditLinkManager {
private:
    TXP_GrowableArray_ED_Link m_links;

public:
    CEditLinkManager();
    ED_Link* MakeLink( char* pStr, char* pExtra, intn iRefCount = 1 );
    ED_LinkId Add( char *pHREF, char *pExtra );
    char* GetHREF( ED_LinkId id ){ return id->hrefStr; }
    int GetHREFLen( ED_LinkId id ){ return XP_STRLEN( id->hrefStr ); }
    EDT_HREFData* GetHREFData( ED_LinkId id){ return id->GetData(); }
    void Free( ED_LinkId id );
    void AdjustAllLinks( char *pOldURL, char* pNewURL, ED_HREFList *badLinks );

    // When a target name changes, call this change links to that target
    // Returns TRUE if any links were changed
    XP_Bool FixupLinksToTarget(char *pOldName, char *pNewName);

    // Wrapper for other AdjustLink function.
    void AdjustLink( ED_LinkId id, char *pOldURL, char* pNewURL, ED_HREFList *badLinks ) {
      if (id && id->hrefStr) AdjustLink(&id->hrefStr,pOldURL,pNewURL,badLinks);
    }

    // Used for adjusting links, images, etc.
    static void AdjustLink(char **pURL,char *pOldBase, char *pNewBase, ED_HREFList *badLinks);

    static void AddHREFUnique(ED_HREFList *badLinks,char *pURL);

    // Since we don't trust the reference counting, CEditSaveObject::FixupLinks() marks each link
    // as it adjusts it, so it doesn't adjust links twice.  HARDTS
    static void SetAdjusted(ED_LinkId id,XP_Bool bVal) { if (id) id->bAdjusted = bVal;}
    static XP_Bool GetAdjusted(ED_LinkId id) { if (id) return id->bAdjusted; else return TRUE;}
};

// Relayout Flags
#define RELAYOUT_NOCARET        1       // after relaying out, don't show the caret


// Commands

class CEditBuffer;

class CEditCommand {
public:
    CEditCommand(CEditBuffer*, intn id);
    virtual ~CEditCommand();
    virtual void Do();
    virtual void Undo();
    virtual void Redo();
    intn GetID();
#ifdef DEBUG
    virtual void Print(IStreamOut& stream);
#endif
protected:
    CEditBuffer* GetEditBuffer() { return m_editBuffer; };
private:
    CEditBuffer* m_editBuffer;
    intn m_id;
};

// CEditCommandGroup

class CEditCommandGroup : public CEditCommand {
public:
    CEditCommandGroup(CEditBuffer*, int id);
    virtual ~CEditCommandGroup();
    void AdoptAndDo(CEditCommand* pCommand);
    virtual void Undo();
    virtual void Redo();
#ifdef DEBUG
    virtual void Print(IStreamOut& stream);
#endif
    intn GetNumberOfCommands();
private:
    TXP_GrowableArray_CEditCommand m_commands;
};

/* Default */
#define EDT_CMD_LOG_MAXHISTORY 1

class CEditCommandLog;

class CGlobalHistoryGroup {
public:
    static CGlobalHistoryGroup* GetGlobalHistoryGroup();
    CGlobalHistoryGroup();
    ~CGlobalHistoryGroup();
    XP_Bool IsReload(CEditBuffer* pContext);
    void ReloadFinished(CEditBuffer* pContext);
    CEditCommandLog* CreateLog(CEditBuffer* pContext);
    CEditCommandLog* GetLog(CEditBuffer* pContext);
    void DeleteLog(CEditBuffer* pContext);
    void IgnoreNextDeleteOf(CEditBuffer* pContext);

private:
    CEditCommandLog* m_pHead; // First log
    static CGlobalHistoryGroup* g_pGlobalHistoryGroup;
};

//
// CEditDocState
//
class CEditDocState {
public:
  // Only created by CEditBuffer::RecordState().
  friend class CEditBuffer;
  virtual ~CEditDocState();

#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif

private:
  CEditDocState();

  XP_HUGE_CHAR_PTR m_pBuffer;
  DocumentVersion m_version;
};


class CCommandState {
public:
    CCommandState();
    ~CCommandState();
    void SetID(intn commandID);
    intn GetID();
    void Record(CEditBuffer* pBufferToRecord);
    void Restore(CEditBuffer* pBufferToRestore);
#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif

private:
    void Flush();

    intn m_commandID;
    CEditDocState *m_pState;
};

class CEditCommandLog {
public:
    void StartTyping(intn typing);
    void EndTyping();
    void AdoptAndDo(CEditCommand*);
    void Undo();
    void Redo();
    void Trim();    // Trims undo and redo command lists.
    XP_Bool InReload();
    void SetInReload(XP_Bool bInReload);
    DocumentVersion GetVersion();
    void SetVersion(DocumentVersion); // For CEditBuffer::RestoreState().
    DocumentVersion GetStoredVersion();
    void DocumentStored();
    XP_Bool IsDirty();

    intn GetCommandHistoryLimit();
    void SetCommandHistoryLimit(intn newLimit);

    intn GetNumberOfCommandsToUndo();
    intn GetNumberOfCommandsToRedo();

    // Returns kNullCommandID if out of range
    intn GetUndoCommand(intn index);
    intn GetRedoCommand(intn index);

    void BeginBatchChanges(intn batchID);
    void EndBatchChanges();

#ifdef DEBUG
    void Print(IStreamOut& stream);
#endif

#ifdef EDITOR_JAVA
    EditorPluginManager GetPlugins();
#endif

    // Temporary directory specific to the edit buffer.  In xpURL format.
    char *GetDocTempDir();
    char *CreateDocTempFilename(char *pPrefix,char *pExtension);

protected:
    // Use the global history to get the command log for a given context.
    CEditCommandLog();
    ~CEditCommandLog();

private:
    void FinishBatchCommands();
    void InternalAdoptAndDo(CEditCommand*);
    void InternalDo(intn id);
    void Trim(intn start, intn end);
    static char *GetAppTempDir();

    CEditBuffer* m_pBuffer;
    CCommandState* m_pUndo;
    CCommandState* m_pRedo;
    int32 m_iBatchLevel;
    int16 m_state;

#ifdef DEBUG
    friend class CEditCommandLogRecursionCheckEntry;
    XP_Bool m_bBusy;
#endif

    friend CGlobalHistoryGroup;
    CEditCommandLog* m_pNext;
    MWContext* m_pContext;
    XP_Bool m_bIgnoreDelete;

    DocumentVersion m_version;
    DocumentVersion m_storedVersion;
    DocumentVersion m_highestVersion;

#ifdef EDITOR_JAVA
    EditorPluginManager m_pPlugins;
#endif


    ///// All the temp directory variables are stored in CEditCommandLog
    ///// because they must persist when the CEditBuffer is deleted 
    ///// during undo/redo.    
    // The temp directory for this document.
    char *m_pDocTempDir; 
    // Used to create unique filenames in the temp directory.
    int m_iDocTempFilenameNonce;
    // used to create unique temp dir filenames.
    static int32 m_iDocTempDirNonce; 
};

// The commands

#define kNullCommandID 0
#define kTypingCommandID 1
#define kAddTextCommandID 2
#define kDeleteTextCommandID 3
#define kCutCommandID 4
#define kPasteTextCommandID 5
#define kPasteHTMLCommandID 6
#define kPasteHREFCommandID 7
#define kChangeAttributesCommandID 8
#define kIndentCommandID 9
#define kParagraphAlignCommandID 10
#define kMorphContainerCommandID 11
#define kInsertHorizRuleCommandID 12
#define kSetHorizRuleDataCommandID 13
#define kInsertImageCommandID 14
#define kSetImageDataCommandID 15
#define kInsertBreakCommandID 16
#define kChangePageDataCommandID 17
#define kSetMetaDataCommandID 18
#define kDeleteMetaDataCommandID 19
#define kInsertTargetCommandID 20
#define kSetTargetDataCommandID 21
#define kInsertUnknownTagCommandID 22
#define kSetUnknownTagDataCommandID 23
#define kGroupOfChangesCommandID 24
#define kSetListDataCommandID 25

#define kInsertTableCommandID 26
#define kDeleteTableCommandID 27
#define kSetTableDataCommandID 28

#define kInsertTableCaptionCommandID 29
#define kSetTableCaptionDataCommandID 30
#define kDeleteTableCaptionCommandID 31

#define kInsertTableRowCommandID 32
#define kSetTableRowDataCommandID 33
#define kDeleteTableRowCommandID 34

#define kInsertTableColumnCommandID 35
#define kSetTableCellDataCommandID 36
#define kDeleteTableColumnCommandID 37

#define kInsertTableCellCommandID 38
#define kDeleteTableCellCommandID 39

#define kInsertLayerCommandID 40
#define kDeleteLayerCommandID 41
#define kSetLayerDataCommandID 42

#define kSetSelectionCommandID 43

#define kPerformPluginCommandID 44

#define kCommandIDMax 44

// This class holds a chunk of html text.

class CEditText
{
public:
    CEditText();
    ~CEditText();

    void Clear();

    // The length is the number of chars
    char* GetChars();
    int32 Length();
    char** GetPChars();
    int32* GetPLength();
private:
    char* m_pChars;
    int32 m_iLength;
    ElementIndex m_iCount;
};

// Can save and restore a region of the document. Also saves and restores current
// selection

class CEditDataSaver {
public:
    CEditDataSaver(CEditBuffer* pBuffer);
    ~CEditDataSaver();
    void DoBegin(CPersistentEditSelection& original);
    void DoEnd(CPersistentEditSelection& modified);
    void Undo();
    void Redo();

    CPersistentEditSelection* GetOriginalDocumentSelection() { return &m_originalDocument; }
private:
    CEditBuffer* m_pEditBuffer;
    CPersistentEditSelection m_originalDocument;
    CPersistentEditSelection m_modifiedDocument;
    CPersistentEditSelection m_original;
    CPersistentEditSelection m_expandedOriginal;
    CPersistentEditSelection m_expandedModified;
    CEditText m_originalText;
    CEditText m_modifiedText;
    XP_Bool m_bModifiedTextHasBeenSaved;
#ifdef DEBUG
    int m_bDoState;
#endif
};

class CDeleteTableCommand
    : public CEditCommand
{
public:
    CDeleteTableCommand(CEditBuffer* buffer, intn id = kDeleteTableCommandID);
    virtual ~CDeleteTableCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
	CEditTableElement* m_pTable;
    CPersistentEditInsertPoint m_replacePoint;
    CPersistentEditSelection m_originalSelection;
};

class CInsertTableCaptionCommand
    : public CEditCommand
{
public:
    CInsertTableCaptionCommand(CEditBuffer* buffer, EDT_TableCaptionData *pData, intn id = kInsertTableCaptionCommandID);
    virtual ~CInsertTableCaptionCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
    CEditCaptionElement* m_pOldCaption;
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CDeleteTableCaptionCommand
    : public CEditCommand
{
public:
    CDeleteTableCaptionCommand(CEditBuffer* buffer, intn id = kDeleteTableCaptionCommandID);
    virtual ~CDeleteTableCaptionCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
    CEditCaptionElement* m_pOldCaption;
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};
class CInsertTableRowCommand
    : public CEditCommand
{
public:
    CInsertTableRowCommand(CEditBuffer* buffer, EDT_TableRowData *pData, XP_Bool bAfterCurrentRow, intn number, intn id = kInsertTableRowCommandID);
    virtual ~CInsertTableRowCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
    intn m_row;
    intn m_number;
    intn m_new_row;
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CDeleteTableRowCommand
    : public CEditCommand
{
public:
    CDeleteTableRowCommand(CEditBuffer* buffer, intn rows, XP_Bool *pTableDeleted = 0, intn id = kDeleteTableRowCommandID);
    virtual ~CDeleteTableRowCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
//    XP_Bool m_bDeletedWholeTable;
    intn m_row;
    intn m_rows;
	CEditTableElement m_table;    // Holds deleted rows
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CInsertTableColumnCommand
    : public CEditCommand
{
public:
    CInsertTableColumnCommand(CEditBuffer* buffer, EDT_TableCellData *pData, XP_Bool bAfterCurrentCell, intn number, intn id = kInsertTableColumnCommandID);
    virtual ~CInsertTableColumnCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
    intn m_number;
    //cmanske: Changed to retain actual column and new insert column
    // This is needed for proper insert given COLSPAN effects
    intn m_column;
    intn m_new_column;
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CDeleteTableColumnCommand
    : public CEditCommand
{
public:
    CDeleteTableColumnCommand(CEditBuffer* buffer, intn rows, XP_Bool *pTableDeleted = 0, intn id = kDeleteTableColumnCommandID);
    virtual ~CDeleteTableColumnCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
//    XP_Bool m_bDeletedWholeTable;
    intn m_column;
    intn m_columns;
	CEditTableElement m_table;    // Holds deleted columns
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CInsertTableCellCommand
    : public CEditCommand
{
public:
    CInsertTableCellCommand(CEditBuffer* buffer, XP_Bool bAfterCurrentCell, intn number, intn id = kInsertTableCellCommandID);
    virtual ~CInsertTableCellCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
    intn m_column;
    intn m_new_column;
    intn m_number;
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CDeleteTableCellCommand
    : public CEditCommand
{
public:
    CDeleteTableCellCommand(CEditBuffer* buffer, intn rows, XP_Bool *pTableDeleted = 0, intn id = kDeleteTableCellCommandID);
    virtual ~CDeleteTableCellCommand();
    virtual void Do();
//    virtual void Undo();
//    virtual void Redo();
private:
//    XP_Bool m_bDeletedWholeTable;
    intn m_column;
    intn m_columns;
	CEditTableRowElement m_tableRow;    // Holds deleted cells
    CPersistentEditSelection m_originalSelection;
    CPersistentEditSelection m_changedSelection;
};

class CSetListDataCommand
    : public CEditCommand
{
public:
    CSetListDataCommand(CEditBuffer*, EDT_ListData& listData, intn id = kSetListDataCommandID);
    virtual ~CSetListDataCommand();
    virtual void Do();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_ListData m_newData;
    EDT_ListData* m_pOldData;
};

// CChangePageDataCommand - for commands that change the document's page data

class CChangePageDataCommand
    : public CEditCommand
{
public:
    CChangePageDataCommand(CEditBuffer*, intn id = kChangePageDataCommandID);
    virtual ~CChangePageDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_PageData* m_oldData;
    EDT_PageData* m_newData;
};

// CSetMetaDataCommand - for changes to the document's meta data

class CSetMetaDataCommand
    : public CEditCommand
{
public:
    // Note: Simply creating this command does the action -- this is so we don't have to explicitly copy the
    // meta data that's passed in.
    CSetMetaDataCommand(CEditBuffer*, EDT_MetaData *pMetaData, XP_Bool bDelete, intn id = kSetMetaDataCommandID);
    virtual ~CSetMetaDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    XP_Bool m_bNewItem;    // This command creates an item.
    XP_Bool m_bDelete;     // This command deletes an item.
    EDT_MetaData* m_pOldData;
    EDT_MetaData* m_pNewData;
};

class CSetTableDataCommand
    : public CEditCommand
{
public:
    // Note: Simply creating this command does the action -- this is so we don't have to explicitly copy the
    // data that's passed in.
    CSetTableDataCommand(CEditBuffer*, EDT_TableData *pMetaData, intn id = kSetTableDataCommandID);
    virtual ~CSetTableDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_TableData* m_pOldData;
    EDT_TableData* m_pNewData;
};

class CSetTableCaptionDataCommand
    : public CEditCommand
{
public:
    // Note: Simply creating this command does the action -- this is so we don't have to explicitly copy the
    // data that's passed in.
    CSetTableCaptionDataCommand(CEditBuffer*, EDT_TableCaptionData *pMetaData, intn id = kSetTableCaptionDataCommandID);
    virtual ~CSetTableCaptionDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_TableCaptionData* m_pOldData;
    EDT_TableCaptionData* m_pNewData;
};

class CSetTableRowDataCommand
    : public CEditCommand
{
public:
    // Note: Simply creating this command does the action -- this is so we don't have to explicitly copy the
    // data that's passed in.
    CSetTableRowDataCommand(CEditBuffer*, EDT_TableRowData *pMetaData, intn id = kSetTableRowDataCommandID);
    virtual ~CSetTableRowDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_TableRowData* m_pOldData;
    EDT_TableRowData* m_pNewData;
};

class CSetTableCellDataCommand
    : public CEditCommand
{
public:
    // Note: Simply creating this command does the action -- this is so we don't have to explicitly copy the
    // data that's passed in.
    CSetTableCellDataCommand(CEditBuffer*, EDT_TableCellData *pMetaData, intn id = kSetTableCellDataCommandID);
    virtual ~CSetTableCellDataCommand();
    virtual void Undo();
    virtual void Redo();

private:
    EDT_TableCellData* m_pOldData;
    EDT_TableCellData* m_pNewData;
};

class CSetSelectionCommand
    : public CEditCommand
{
public:
    CSetSelectionCommand(CEditBuffer*, CEditSelection& selection, intn id = kSetSelectionCommandID);
    virtual ~CSetSelectionCommand();
    virtual void Do();
    virtual void Undo();
    virtual void Redo();

private:
    CPersistentEditSelection m_OldSelection;
    CPersistentEditSelection m_NewSelection;
};

// Generic timer callback

extern "C" {
void CEditTimerCallback (void * closure);
}

class CEditTimer {
public:
    CEditTimer();
    virtual ~CEditTimer();
protected:
    void SetTimeout(uint32 msecs);
    void Callback();
    void Cancel();
    XP_Bool IsTimeoutEnabled() { return m_timeoutEnabled; }
    virtual void OnCallback();
private:
    friend void CEditTimerCallback (void * closure);
    XP_Bool m_timeoutEnabled;
    void*   m_timerID;
};

class CFinishLoadTimer : public CEditTimer {
public:
    CFinishLoadTimer();
    void FinishedLoad(CEditBuffer* pBuffer);
protected:
    virtual void OnCallback();
private:
    CEditBuffer* m_pBuffer;
};

class CRelayoutTimer : public CEditTimer {
public:
    CRelayoutTimer();
    void SetEditBuffer(CEditBuffer* pBuffer);
    void Relayout(CEditElement *pStartElement, int iOffset);
    void Flush();
protected:
    virtual void OnCallback();
private:
    CEditBuffer* m_pBuffer;
    CEditElement* m_pStartElement;
    int m_iOffset;
};

class CAutoSaveTimer : public CEditTimer {
public:
    CAutoSaveTimer();
    void SetEditBuffer(CEditBuffer* pBuffer);
    void SetPeriod(int32 minutes);
    int32 GetPeriod();
    void Restart();

    //CLM: Call before and after operations
    //     that are upset by autosave relayout
    void Suspend();
    void Resume();

protected:
    virtual void OnCallback();
private:
    CEditBuffer* m_pBuffer;
    int32 m_iMinutes;
    XP_Bool m_bSuspended;
    XP_Bool m_bCalledWhileSuspended;
};


//
// CSizingObject
//

class CSizingObject {
public:
    CSizingObject();
    ~CSizingObject();
    XP_Bool Create(CEditBuffer *pBuffer,
                   LO_Element *pLoElement,
                   int iSizingStyle,
                   int32 xVal, int32 yVal,
                   XP_Bool bModifierKeyPressed, XP_Rect *pRect);


    XP_Bool GetSizingRect(int32 xVal, int32 yVal, XP_Bool bModifierKeyPressed, XP_Rect *pRect);
    void ResizeObject();
    void EraseAddRowsOrCols();

private:
    CEditBuffer   *m_pBuffer;
    LO_Element    *m_pLoElement;
    XP_Rect        m_Rect;
    int            m_iStyle;
    int32          m_iXOrigin;
    int32          m_iYOrigin;
    int32          m_iXMouseOffset;
    int32          m_iYMouseOffset;
    int32          m_iStartWidth;
    int32          m_iStartHeight;
    int32          m_iParentWidth;
    int32          m_iViewWidth;
    int32          m_iViewHeight;
    int32          m_iAddCols;
    int32          m_iAddRows;
    XP_Bool        m_bWidthPercent;
    XP_Bool        m_bHeightPercent;
    XP_Bool        m_bPercentOriginal;
    XP_Bool        m_bFirstTime;
    XP_Bool        m_bCenterSizing;
    int            m_iWidthMsgID;
};



//
// CEditBuffer
//

// Matches LO_NA constants, plus up/down

#define EDT_NA_CHARACTER 0
#define EDT_NA_WORD 1
#define EDT_NA_LINEEDGE 2
#define EDT_NA_DOCUMENT 3
#define EDT_NA_UPDOWN 4
#define EDT_NA_COUNT 5

class CEditBuffer {
public:
    long m_lifeFlag; /* Used to detect accesses to deleted buffer. */
    MWContext *m_pContext;
    CEditRootDocElement *m_pRoot;
    // To do: replace m_pCurrent et. al. with a CEditInsertPoint
    CEditLeafElement *m_pCurrent;
    ElementOffset m_iCurrentOffset;
    XP_Bool m_bCurrentStickyAfter;
    CEditElement* m_pCreationCursor;

    ED_Color m_colorText;
    ED_Color m_colorBackground;
    ED_Color m_colorLink;
    ED_Color m_colorFollowedLink;
    ED_Color m_colorActiveLink;
    char *m_pTitle;
    char *m_pBackgroundImage;
    XP_Bool m_bBackgroundNoSave;
    // Bug 117881: There may be > 1 FontDef LINK per page, so use an growable array
    //char *m_pFontDefURL;
    TXP_GrowableArray_pChar m_FontDefURL;
    TXP_GrowableArray_XP_Bool m_FontDefNoSave;
    char *m_pBaseTarget;
    char *m_pBodyExtra;

#ifdef ENDER
	XP_Bool m_bEmbedded;
	void *m_pEmbeddedData;
	char *m_pImportedHTMLStream; //dont forget to XP_FREE this memory //ENDER
#endif //ENDER

    CEditImageLoader *m_pLoadingImage;
    CFileSaveObject *m_pSaveObject;
    XP_Bool m_bMultiSpaceMode;
    
    // Save copied style here
    // By making it static, we can paste attributes
    //   into a different window
    static EDT_CharacterData *m_pCopyStyleCharacterData;

    int m_hackFontSize;             // not a real implementation, just for testing

    int32 m_iDesiredX;
    int32 m_lastTopY;
    XP_Bool m_inScroll;
    XP_Bool m_bBlocked;                // we are doing the initial layout so we
                                    //  are blocked.
    XP_Bool m_bSelecting;
    XP_Bool m_bNoRelayout;               // maybe should be a counter
    XP_Bool m_bDontClearTableSelection;

    // Any operation changing table (insert and delete operations)
    //  can set this so next Relayout call knows where to place caret
    CEditTableCellElement *m_pCellForInsertPoint;

    CEditElement *m_pSelectStart;
    int m_iSelectOffset;

    int m_preformatLinePos;
    XP_Bool m_bInPreformat;             // semaphore to keep us from reentering
                                    //  NormalizePreformat
    TagType m_iLastTagType; // The previous tag's type, comments are ignored.
    XP_Bool m_bLastTagIsEnd; // The previous tag's open vs. close state, comments are ignored.

    CPrintState printState;
    CEditLinkManager linkManager;
    TXP_GrowableArray_EDT_MetaData m_metaData;

    // Get time and save in m_FileSaveTime
    // Public so CEditFileSave can call it
    void  GetFileWriteTime();

    // Used only by CEditBuffer::Relayout()
    TXP_GrowableArray_LO_TableStruct m_RelayoutTables;

    PRBool m_bEncrypt;

private:
    CParseState*    GetParseState();
    void            PushParseState();
    void            PopParseState();
    void            ResetParseStateStack();
    TXP_PtrStack_CParseState    m_parseStateStack;

    // CFileFileSaveObject->m_status copied here
    //  to return a result even if save object is deleted
    ED_FileError m_status;

    XP_Bool IsSelectionComment(PA_Tag* pTag);
    XP_Bool HandleSelectionComment(PA_Tag* pTag, CEditElement*& pElement, intn& retVal);
    CEditCommandLog* GetCommandLog(){ XP_ASSERT(m_pCommandLog); return m_pCommandLog; };
    CEditCommandLog* m_pCommandLog;
    XP_Bool m_bTyping;

    // Trying to figure out new new insert point is too complicated
    //   when moving a table, so we set this and delete AFTER inserting
    XP_Bool m_bDeleteTableAfterPasting;
    // Record an element to be "watched" here
    //  After every element deleted, CleanupForDeletedElement()
    //  is called to set this to 0 if element was the one deleted
    CEditElement *m_pWatchForDeletionElement;

    CEditInternalAnchorElement* m_pStartSelectionAnchor;
    CEditInternalAnchorElement* m_pEndSelectionAnchor;
    XP_Bool m_bStartSelectionStickyAfter;
    XP_Bool m_bEndSelectionStickyAfter;

    // Set TRUE only when user uses left arrow key to move to beginning
    // of a text element, so we use that formating and not the previous element's
    // Thus a quick press of right, left arrows works to keep styles to right of caret
    XP_Bool m_bUseCurrentTextFormat;

    XP_Bool m_bLayoutBackpointersDirty;
    //CLM: Save the current file time to
    //     check if an outside editor changed our source
    int32 m_iFileWriteTime;

    // For maintaining the selected Table, row, columns, or individual cell
    // Only 1 table can be selected, but multiple cells are selected for rows, columns
    // Array of SelectedCell structs matches LO_Elements to CEditElements
    TXP_GrowableArray_CEditTableCellElement m_SelectedEdCells;
    TXP_GrowableArray_LO_CellStruct         m_SelectedLoCells;
    CEditTableElement                      *m_pSelectedEdTable;
    LO_TableStruct                         *m_pSelectedLoTable;
    
    // Index to the next selected cell from the m_SelectedEdCells list.
    // This and m_CurrentInsertPoint are used by GetFirstCellSelection() and SelectNextSelectedCell()
    intn m_iNextSelectedCell;

    // Save the current insert point before mucking with selected cells
    // Don't need this as long as we suppress relayout for individual
    //   cell selection format changes. Just relayout entire table when done
//    CEditInsertPoint m_CurrentInsertPoint;

    // This is either m_pSelectedLoTable or last selected cell 
    //   (which will be a member of m_SelectedLoCells list)
    LO_Element     *m_pSelectedTableElement;
    ED_HitType      m_TableHitType;

    // Used with ExtentTableCellSelection:
    //  save previous cell we used to extend selection so we change
    //  selection only when we move into a different cell
    LO_Element     *m_pPrevExtendSelectionCell;

#ifdef DEBUG
    friend CEditTestManager;
    CEditTestManager* m_pTestManager;
    int16 m_iSuppressPhantomInsertPointCheck;
    XP_Bool m_bSkipValidation;
#endif

public:
    CEditBuffer( MWContext* pContext, XP_Bool bImportText );
    ~CEditBuffer();
    CEditElement* CreateElement(PA_Tag* pTag, CEditElement *pParent);
    CEditElement* CreateFontElement(PA_Tag* pTag, CEditElement *pParent);
    intn ParseTag(pa_DocData *data_doc, PA_Tag* pTag, intn status);

private:
    XP_Bool ShouldAutoStartBody(PA_Tag* pTag, int16 csid);
    intn ParseOpenTag(pa_DocData *data_doc, PA_Tag* pTag, intn status);
    void ParseUnsupportedTag(PA_Tag* pTag, CEditElement*& pElement, intn& retVal);
    void ParseLink(PA_Tag* pTag, CEditElement*& pElement, intn& retVal);
    void ParseLinkFontDef(PA_Tag* pTag, CEditElement*& pElement, intn& retVal);
    intn ParseEndTag(PA_Tag* pTag);
    void WriteClosingScriptTag();
public:
    void FinishedLoad();
    void FinishedLoad2();
    void DummyCharacterAddedDuringLoad();
    void ConvertCurrentDocToNewDoc();

    XP_Bool IsComposeWindow(){ return m_pContext->bIsComposeWindow; }

#if defined(ENDER) && defined(MOZ_ENDER_MIME)
    void AddImagesToSafeList( CEditElement* pElement );
#endif /* ENDER && MOZ_ENDER_MIME */

    void PrintTree( CEditElement* m_pRoot );
    void DebugPrintTree( CEditElement* m_pRoot );
    XP_HUGE_CHAR_PTR GetPositionalText();
    void StreamToPositionalText( CEditElement* pElement, IStreamOut* pOut );

    void PrintDocumentHead( CPrintState *pPrintState );
    void PrintDocumentEnd( CPrintState *pPrintState );
    XP_Bool IsBodyTagRequired();
    static void Write(CStreamOutMemory *pSource, IStreamOut* pDest);
    void AppendTitle( char* pTitleString );

    void RepairAndSet(CEditSelection& selection);
    XP_Bool Reduce( CEditElement* pRoot );
	void Protect( CEditElement *pRoot  ); //protect certain things from reduction.
    void NormalizeTree( );
    
    // Change Table and alls cell width data to match
    //  sizes calculated by Layout. Must do for all tables during Relayout()
    //  else generated HTML is very misleading!
    void FixupTableData();
    CEditElement* FindRelayoutStart( CEditElement *pStartElement, XP_Bool bRelayoutEntireTable = TRUE );
    void Relayout( CEditElement *pStartElement, int iOffset,
            CEditElement *pEndElement = 0, intn relayoutFlags = 0 );

	void Reflow( CEditElement *pStartElement, int iOffset,
            CEditElement *pEndElement = 0, intn relayoutFlags = 0 );

    // Call these instead of Relayout( pTable )
    //  when we want to relayout entire table because we are changing
    //  either the table size or cell size(s)
    // bChangeWidth and bChangeHeight tell us which dimension is changing
    void ResizeTable(CEditTableElement *pTable, XP_Bool bChangeWidth = FALSE, XP_Bool bChangeHeight = FALSE);
    void ResizeTableCell(CEditTableElement *pTable, XP_Bool bChangeWidth = FALSE, XP_Bool bChangeHeight = FALSE);

    // Relayout current selected table (or parent of selected cells)
    void RelayoutSelectedTable();

    void SetCaret();
    void InternalSetCaret(XP_Bool bRevealPosition);
    LO_Position GetEffectiveCaretLOPosition(CEditElement* pElement, intn iOffset, XP_Bool bStickyAfter);
    void RevealPosition(CEditElement* pElement, int iOffset, XP_Bool bStickyAfter);
    void RevealSelection();
    XP_Bool GetLOCaretPosition(CEditElement* pElement, int iOffset, XP_Bool bStickyAfter,
        int32& targetX, int32& targetYLow, int32& targetYHigh);
    void WindowScrolled();
    void NavigateDocument(XP_Bool bSelect, XP_Bool bForward );
    /* Begin of document check preference and if move curosr is enabled, 
        we will move the cursor if not, we leave the cursor alone.
        REQUIRES: (Boolean to select or not), Valid editbuffer
        RETURNS: Nothing
        NOTE: uses
        NavigateChunk( bSelect, LO_NA_DOCUMENT, FALSE ); 
            if we move the cursor.
        and
        FE_ScrollDocTo (MWContext *context, int iLocation, int32 x,int32 y);
            if we do not
    */
    void PageUpDown(XP_Bool select, XP_Bool pagedown);
    /*PageUpDown requires:  Boolean to select the scrolled text if cursor should move
                            Boolean , true if page down, false if page up.
                  effects:  moves cursor or not depending on preferences.*/

    ED_ElementType GetCurrentElementType(); /* CM: "Current" is superfluous! */

    //
    // Doesn't allocate.  Returns the base URL of the document if it has been
    //  saved.  NULL if it hasn't.
    //
    char* GetBaseURL(){ return LO_GetBaseURL( m_pContext); }

    // editor buffer commands
    EDT_ClipboardResult InsertChar( int newChar, XP_Bool bTyping );
    EDT_ClipboardResult InsertChars( char* pNewChars, XP_Bool bTyping , XP_Bool bReduce);
    EDT_ClipboardResult DeletePreviousChar();
    EDT_ClipboardResult DeleteNextChar();
    EDT_ClipboardResult DeleteChar(XP_Bool bForward, XP_Bool bTyping = TRUE);

    // Delete key clears contents, but doesn't delete cells
    EDT_ClipboardResult ClearSelectedCells();

    CPersistentEditSelection GetEffectiveDeleteSelection();

    XP_Bool PreviousChar( XP_Bool bSelect );
    XP_Bool PrevPosition(CEditLeafElement *pEle, ElementOffset iOffset, CEditLeafElement*& pNew,
            ElementOffset& iNewOffset );
    XP_Bool NextPosition(CEditLeafElement *pEle, ElementOffset iOffset, CEditLeafElement*& pNew,
            ElementOffset& iNewOffset );
    void SelectNextChar( );
    void SelectPreviousChar( );
    void NextChar( XP_Bool bSelect );
    // Return FALSE if at the 1st cell and going backward, or last cell and moving forward
    // bEndOfCell determines where caret is placed in the cell
    // Option pRowCounter: if supplied, it is incremented when we move to a new row
    XP_Bool NextTableCell(XP_Bool bForward = TRUE, XP_Bool bEndOfCell = FALSE, intn* pRowCounter = NULL);
    void UpDown( XP_Bool bSelect, XP_Bool bForward );
    void NavigateChunk( XP_Bool bSelect, intn chunkType, XP_Bool bForward );
    void EndOfLine( XP_Bool bSelect );
    //void BeginOfDocument( XP_Bool bSelect );
    //void EndOfDocument( XP_Bool bSelect );
    void ClearMailQuote();
    EDT_ClipboardResult ReturnKey(XP_Bool bTyping, XP_Bool bIndent = FALSE);
    EDT_ClipboardResult TabKey(XP_Bool bForward, XP_Bool bForceTabChar);

    EDT_ClipboardResult InternalReturnKey(XP_Bool bUserTyped);
    CEditElement* SplitAtContainer(XP_Bool bUserTyped, XP_Bool bSplitAtBeginning, CEditElement*& pRelayoutStart);

    void Indent();
    void IndentSelection(CEditSelection& selection);
    // Returns the new list in pList if one was created
    void IndentContainer( CEditContainerElement *pContainer, CEditListElement*& pList );
    XP_Bool Outdent(); /* Returns TRUE if Outdent succeeded */
    XP_Bool OutdentSelection(CEditSelection& selection);
    void OutdentContainer( CEditContainerElement *pContainer,
            CEditListElement *pList );
    void MorphContainer( TagType t );
    void MorphListContainer( TagType t );
    // Outdent the container until we don't have a list
    void TerminateList(CEditContainerElement *pContainer);

    // Added to use for selected regions and table cells
    void MorphContainerSelection( TagType t, CEditSelection& selection  );
    void MorphListContainer2( TagType t, CEditSelection& selection );
    void ToggleList(intn iTagType);
    void ToggleList2(intn iTagType, CEditSelection& selection);

    void SetParagraphAlign( ED_Alignment eAlign );
    void SetTableAlign( ED_Alignment eAlign );
    ED_Alignment GetParagraphAlign();
    void FormatCharacter( ED_TextFormat tf );

    // Format Character was modified to handle selected cells
    enum {
        ED_GET_FORMAT,
        ED_SET_FORMAT,
        ED_CLEAR_FORMAT
    };
    // This does similar scan of elements in selection, but only to find out if we should set
    //   or clear an attribute. Call this for a set of non-contiguous selected cells,
    //   then use result to set the iSetState for FormatCharacterSelection
    XP_Bool GetSetStateForCharacterSelection( ED_TextFormat tf, CEditSelection& selection );

    // iSetState default will get the set state in one pass,
    //   else it will use supplied state
    void FormatCharacterSelection( ED_TextFormat tf, CEditSelection& selection, XP_Bool bRelayout, intn iSetState = 0 );

    void SetCharacterData( EDT_CharacterData *pData );
    void SetCharacterDataSelection( EDT_CharacterData *pData, CEditSelection& selection, XP_Bool bRelayout );
    void SetCharacterDataAtOffset( EDT_CharacterData *pData,
            ED_BufferOffset iBufOffset, int32 iLen );

    EDT_CharacterData* GetCharacterData();
    // Pass in existing data to combine with previous data,
    //   used primarily for selected table cells
    EDT_CharacterData* GetCharacterDataSelection(EDT_CharacterData *pData, CEditSelection& selection);

    // Format all text contents into tab-delimeted cells,
    //  with CR/LF (or appropriate end-line for platform) at end of each row.
    // Use result to paste into spreadsheets like Excel
    char *GetTabDelimitedTextFromSelectedCells();

    // Test if there's a selection, and the beginning and end are not split across a cell boundary
    XP_Bool CanConvertTextToTable();

    // Convert Selected text into a table (put each paragraph in separate cell)
    // Number of rows is automatic - creates as many as needed
    void ConvertTextToTable(intn iColumns);

    // Convert the table into text - unravel existing paragraphs in cells
    void ConvertTableToText();

    // This is TRUE after any HTML is copied
    XP_Bool CanPasteStyle() { return (m_pCopyStyleCharacterData != NULL); }

    // Apply the style to selection or at caret. Use bApplyStyle = FALSE to cancel
    void PasteStyle(XP_Bool bApplyStyle);

    // Get the index of the current font (at caret or selection)
    // Returns 0 (ED_FONT_VARIABLE), 1 (ED_FONT_FIXED), or 2 (ED_FONT_LOCAL)
    int GetFontFaceIndex();
    
    // Get the current font face for current selection or insert point
    // If the current font matches an XP font 'group',
    //    else it is the font face string from EDT_CharacterData.
    //    Use this to search your local font list
    //    in menu or listbox. DO NOT FREE RETURN VALUE (its a static string)
    char * GetFontFace();

    void ReplaceTextAtOffset( char *pText, EDT_CharacterData *pData,
            ED_BufferOffset iBufOffset, int32 iLen );

    void SetRefresh( XP_Bool bRefreshOn );

    void SetDisplayParagraphMarks(XP_Bool bDisplay);
    XP_Bool GetDisplayParagraphMarks();

    void SetDisplayTables(XP_Bool bDisplay);
    XP_Bool GetDisplayTables();

    ED_TextFormat GetCharacterFormatting();
    TagType GetParagraphFormatting();
    TagType GetParagraphFormattingSelection(CEditSelection& selection);
    
    int GetFontSize();
    // If bRelative is TRUE, the iSize changes relative to existing size (usually -1 or +1)
    void SetFontSize(int iSize, XP_Bool bRelative);
    void SetFontSizeSelection(int n, XP_Bool bRelative, CEditSelection& selection, XP_Bool bRelayout);

    int GetFontPointSize();
    void SetFontPointSize(int pointSize);
    ED_Color GetFontColor();
    void SetFontColor(ED_Color n);
    void SetFontColorSelection(ED_Color n, CEditSelection& selection, XP_Bool bRelayout);
    ED_ElementType GetBackgroundColor(LO_Color *pColor);
    void SetBackgroundColor(LO_Color *pColor);
    void InsertLeaf(CEditLeafElement *pLeaf);
    void InsertNonLeaf( CEditElement* pNonLeaf);
    EDT_ImageData* GetImageData();
    void SetImageData( EDT_ImageData* pData, XP_Bool bKeepImagesWithDoc );
    void InsertImage( EDT_ImageData* pData );
    int32 GetDefaultBorderWidth();
    void LoadImage( EDT_ImageData* pData, XP_Bool bKeepImagesWithDoc, XP_Bool bReplaceImage );

    // Tables

    // Like GetInsertPoint, but handles the right edge of the
    // selection differently: If the right edge of a non-empty
    // selection is at the edge of the table cell, the insert point
    // is moved inside the table cell. This gives the
    // correct behavior for table operations.
    void GetTableInsertPoint(CEditInsertPoint& ip);
    
    // Set insert point to beginning or end of cell contents
    // Returns TRUE if we found an appropriate 
    //   paragraph + text element inside cell
    XP_Bool SetTableInsertPoint(CEditTableCellElement *pCell, XP_Bool bStartOfCell = FALSE);

    XP_Bool IsInsertPointInTable();
    XP_Bool IsInsertPointInNestedTable();
    EDT_TableData* GetTableData();
    void SetTableData(EDT_TableData *pData);
    CEditTableElement *InsertTable(EDT_TableData *pData);
    void DeleteTable();

    //cmanske: new:
    ED_MergeType GetMergeTableCellsType();
    XP_Bool CanSplitTableCell();
    void MergeTableCells();
    void SplitTableCell();

    XP_Bool IsInsertPointInTableCaption();
    EDT_TableCaptionData* GetTableCaptionData();
    void SetTableCaptionData(EDT_TableCaptionData *pData);
    void InsertTableCaption(EDT_TableCaptionData *pData);
    void DeleteTableCaption();

    XP_Bool IsInsertPointInTableRow();
    EDT_TableRowData* GetTableRowData();
    void SetTableRowData(EDT_TableRowData *pData);
    void InsertTableRows(EDT_TableRowData *pData, XP_Bool bAfterCurrentRow, intn number);
    void DeleteTableRows(intn number);

    XP_Bool IsInsertPointInTableCell();
    EDT_TableCellData* GetTableCellData();

    void ChangeTableSelection(ED_HitType iHitType, ED_MoveSelType iMoveType, EDT_TableCellData *pData = NULL);
    
    // This examines all selected cells and 
    //  returns appropriate type, including checking if
    //  all cells in a row or column are selected
    ED_HitType GetTableSelectionType();

    void SelectAndMoveToNextTableCell(XP_Bool bForward, EDT_TableCellData *pData = NULL);
    void SetTableCellData(EDT_TableCellData *pData);
    void InsertTableCells(EDT_TableCellData *pData, XP_Bool bAfterCurrentCell, intn number);
    void DeleteTableCells(intn number);
    void InsertTableColumns(EDT_TableCellData *pData, XP_Bool bAfterCurrentColumn, intn number);
    void DeleteTableColumns(intn number);

    XP_Bool IsInsertPointInLayer();
    EDT_LayerData* GetLayerData();
    void SetLayerData(EDT_LayerData *pData);
    void InsertLayer(EDT_LayerData *pData);
    void DeleteLayer();

    EDT_PageData* GetPageData();
    void SetPageData( EDT_PageData* pData );
    static void FreePageData( EDT_PageData* pData );
    void SetImageAsBackground();
    
    intn FindMetaData( EDT_MetaData *pMetaData );
    intn FindContentTypeIndex();
    EDT_MetaData* MakeMetaData( XP_Bool bHttpEquiv, char *pName, char*pContent );
    EDT_MetaData* GetMetaData( intn n );
    void SetMetaData( EDT_MetaData *pMetaData );
    void DeleteMetaData( EDT_MetaData *pMetaData );
    static void FreeMetaData( EDT_MetaData *pMetaData );
    void ParseMetaTag( PA_Tag *pTag, intn& retVal );
    void PrintMetaData( CPrintState *pPrintState );
    void PrintMetaData( CPrintState *pPrintState, int index );
    // Return FALSE only if we are closing down
    XP_Bool CheckCharset( PA_Tag *pTag, EDT_MetaData *pData,int16 win_csid );

    EDT_HorizRuleData* GetHorizRuleData();
    void SetHorizRuleData( EDT_HorizRuleData* pData );
    void InsertHorizRule( EDT_HorizRuleData* pData );

    char* GetTargetData();
    void SetTargetData( char* pData );
    void InsertTarget( char* pData );
    char* GetAllDocumentTargets();
    char* GetAllDocumentTargetsInFile(char *pHref);  //CLM
    char* GetAllDocumentFiles(XP_Bool **, XP_Bool);

    char* GetUnknownTagData();
    void SetUnknownTagData( char* pData );
    void InsertUnknownTag( char* pData );

    EDT_ListData* GetListData();
    void SetListData( EDT_ListData* pData );

    void InsertBreak( ED_BreakType eBreak, XP_Bool bTyping = TRUE );

    void SetInsertPoint( CEditLeafElement* pElement, int iOffset, XP_Bool bStickyAfter );
    void FixupInsertPoint();
    void FixupInsertPoint(CEditInsertPoint& ip);
    EDT_ClipboardResult DeleteSelection(XP_Bool bCopyAppendAttributes = TRUE);
    EDT_ClipboardResult DeleteSelection(CEditSelection& selection, XP_Bool bCopyAppendAttributes = TRUE);
    // If stream is empty, we are deleting, else copy element data to the stream for the clipboard
    EDT_ClipboardResult DeleteOrCopyAcrossCellBorders(CEditSelection& selection, CStreamOutMemory& stream);
    // Should be used ONLY by DeleteOrCopyAcrossCellBorders
    void DeleteOrCopyWithinTable(CEditTableElement *pTable, CEditLeafElement *pBegin, CEditLeafElement *pEnd, CStreamOutMemory& stream);
    void DeleteBetweenElements( CEditLeafElement* pBegin, CEditLeafElement* pEnd, XP_Bool bCopyAppendAttributes = TRUE );
    void PositionCaret( int32 x, int32 y);

    // Show where we can drop during  dragNdrop. Handles tables as well
    XP_Bool PositionDropCaret(int32 x, int32 y);
    void DeleteSelectionAndPositionCaret(int32 x, int32 y);

    // If all cells in a col or row are selected,
    //  this removes the row or col. Otherwise, just cell contents
    //  are deleted to minimize disturbing table structure
    // All users except for Backspace and Delete should use bNoSpaceInNewCells = FALSE;
    void DeleteSelectedCells(XP_Bool bNoSpaceInNewCells = FALSE);

    // Data for table currently being dragged.  Accessible to all edit windows
    static EDT_DragTableData* m_pDragTableData;

    // Setup data for dragging table cells
    XP_Bool StartDragTable(int32 x, int32 y);
    static XP_Bool IsDraggingTable() { return m_pDragTableData != NULL; }
    void StopDragTable();

    /*StartSelection:
        used when mouse is clicked or double clicked.  calls clearmove then done typing before 
        going on to LO_Click/LO_DoubleClick.
    */
    void StartSelection( int32 x, int32 y , XP_Bool doubleClick = FALSE);
    void MoveAndHideCaretInTable(LO_Element *pLoElement); //cmanske: Move caret without scrolling or showing caret

    void SelectObject( int32 x, int32 y);
    void ExtendSelection( int32 x, int32 y );
    void ExtendSelectionElement( CEditLeafElement *pElement, int iOffset, XP_Bool bStickyAfter );
    void EndSelection(int32 x, int32 y);
    void EndSelection();
    void SelectAll();
    void SelectTable();         //See below for new overloaded version

    void SelectTableCell();     //Now selects the cell border, not contents
    // Similar to the old version of SelectTableCell: selects a cells contents
    void SelectCellContents(CEditTableCellElement *pCell);

    // Very important for new Table/Cell selection strategy:
    // 1. Check if IsTableOrCellSelected() is TRUE,
    // 2. Call GetFirstCellSelection to contents of
    //     the "selected" table cell (from m_pSelectedEdTable or m_SelectedEdCells)
    // 3. Do whatever formating on returned selection data
    // 4. Call GetNextCellSelection() and repeat formatting
    //     until return value is FALSE.
    XP_Bool GetFirstCellSelection(CEditSelection& selection);
    XP_Bool GetNextCellSelection(CEditSelection& selection);

    // Similar to above, but just returns the cell pointer
    CEditTableCellElement *GetFirstSelectedCell();
    // *pRowCounter is incremented when 1st cell of next row is returned
    // Use these to build a selected table for cut/copy/paste of cells
    CEditTableCellElement *GetNextSelectedCell(intn *pRowCounter = NULL);


    void SelectRegion(CEditLeafElement *pBegin, intn iBeginPos,
            CEditLeafElement* pEnd, intn iEndPos, XP_Bool bFromStart = FALSE,
            XP_Bool bForward = FALSE );
    void SetSelection(CEditSelection& selection);
    void SetInsertPoint(CEditInsertPoint& insertPoint);
    void SetInsertPoint(CPersistentEditInsertPoint& insertPoint);

    void GetInsertPoint( CEditLeafElement** ppLeaf, ElementOffset *pOffset, XP_Bool * pbStickyAfter);
    XP_Bool GetPropertyPoint( CEditLeafElement** ppLeaf, ElementOffset *pOffset = 0);
    CEditElement *GetSelectedElement();
    void SelectCurrentElement();
    void ClearSelection( XP_Bool bResyncInsertPoint = TRUE, XP_Bool bKeepLeft = FALSE );
    void BeginSelection( XP_Bool bExtend = FALSE, XP_Bool bFromStart = FALSE );
    void MakeSelectionEndPoints( CEditLeafElement*& pBegin, CEditLeafElement*& pEnd );
    void MakeSelectionEndPoints( CEditSelection& selection, CEditLeafElement*& pBegin, CEditLeafElement*& pEnd );
    
    void GetSelection( CEditLeafElement*& pStartElement, ElementOffset& iStartOffset,
                CEditLeafElement*& pEndElement, ElementOffset& iEndOffset, XP_Bool& bFromStart );
    
    // Use data from supplied selection, or get from current selection if supplied is empty
    // Used where above used to be used when you want to work on selected cell contents
    void GetSelection( CEditSelection& selection, CEditLeafElement*& pStartElement, ElementOffset& iStartOffset,
                CEditLeafElement*& pEndElement, ElementOffset& iEndOffset, XP_Bool& bFromStart );

    int Compare( CEditElement *p1, int i1Offset, CEditElement *p2, int i2Offset );

    void FileFetchComplete(ED_FileError m_status = ED_ERROR_NONE);

    void AutoSaveCallback();
    void SetAutoSavePeriod(int32 minutes);
    int32 GetAutoSavePeriod();
    void SuspendAutoSave(); //CLM
    void ResumeAutoSave();

    void ClearMove(XP_Bool bFlushRelayout = TRUE);
    XP_Bool IsSelected(){ return LO_IsSelected( m_pContext ); }
    XP_Bool IsSelecting(){ return m_bSelecting; }
    XP_Bool IsBlocked(){ return this == 0 || m_bBlocked; }
    XP_Bool IsPhantomInsertPoint();
    XP_Bool IsPhantomInsertPoint(CEditInsertPoint& ip);
    void ClearPhantomInsertPoint();
    XP_Bool GetDirtyFlag();
    void DocumentStored();

    // When bCheckForCellBoundary is TRUE, then we return EDT_COP_SELECTION_CROSSES_TABLE_DATA_CELL
    //  when selection crosses a cell boundary. This is used internally to know when to handle this case.
    //  Calls from UI should use FALSE, which will return EDT_OK if we cross cell boundary
    EDT_ClipboardResult CanCut(XP_Bool bStrictChecking, XP_Bool bCheckForCellBoundary);
    EDT_ClipboardResult CanCut(CEditSelection& selection, XP_Bool bStrictChecking, XP_Bool bCheckForCellBoundary);
    EDT_ClipboardResult CanCopy(XP_Bool bStrictChecking, XP_Bool bCheckForCellBoundary = FALSE);
    EDT_ClipboardResult CanCopy(CEditSelection& selection, XP_Bool bStrictChecking, XP_Bool bCheckForCellBoundary);
    EDT_ClipboardResult CanPaste(XP_Bool bStrictChecking);
    EDT_ClipboardResult CanPaste(CEditSelection& selection, XP_Bool bStrictChecking);

    XP_Bool CanSetHREF();
    char *GetHREF();
    ED_LinkId GetHREFLinkID();
    char *GetHREFText();
    void GetHREFData( EDT_HREFData *pData );
    void SetHREFData( EDT_HREFData *pData );
    void SetHREF( char *pHREF, char *pExtra );
    void SetHREFSelection( ED_LinkId eId );

    // Accessor functions
    ED_FileError SaveFile( ED_SaveFinishedOption finishedOpt,
                            char * pSourceURL, // used to resolve links in editor document.
                            ITapeFileSystem *tapeFS,  /* char *pDestURL, */
                            XP_Bool   bSaveAs,
                            XP_Bool   bKeepImagesWithDoc,
                            XP_Bool   bAutoAdjustLinks,
                            XP_Bool   bAutoSave,
                            char **ppIncludedFiles,
                            CEditSaveToTempData *pData = NULL);
    // Does actual save, from plugin callback.
    void SaveFileReal( CEditSaveData *pData);

    // Returns the desired on-disk, published output character set.
    int16 GetDocCharSetID();

    // Returns the current in-memory character set ID.
    // Will be the same as the wincsid, except without the AUTODETECT bits,
    // and except when the user has just changed the view encoding.
    int16 GetRAMCharSetID();

    void ForceDocCharSetID(int16 csid);

    ED_FileError PublishFile( ED_SaveFinishedOption finishedOpt,
                           char *pSourceURL,
                           char **ppIncludedFiles,
                           char *pDestURL, /* Must have trailing slash, ie after HEAD call */
                           char *pUsername,
                           char *pPassword,
                           XP_Bool   bKeepImagesWithDoc,
                           XP_Bool   bAutoAdjustLinks );

////    ED_FileError WriteBufferToFile( char* pFileName );

    //CLM: Get current time and return TRUE if it changed
    XP_Bool IsFileModified();

    // saves the edit buffer to a file.
    //CM: was char *pFileName, added return value 0 for success, -1 if fail
    int  WriteToFile( XP_File hFile );
    // returns length of pBuffer. (You can't use XP_STRLEN on a XP_HUGE_CHAR_PTR.)
    int32 WriteToBuffer( XP_HUGE_CHAR_PTR* pBuffer, XP_Bool bEncodeSelectionAsComment );

    // Warning! This will delete the CEditBuffer.
    void ReadFromBuffer(XP_HUGE_CHAR_PTR pBuffer);

#ifdef MOZ_ENDER_MIME
    void ReadMimeFromBuffer(XP_HUGE_CHAR_PTR pBuffer);
#endif //MOZ_ENDER_MIME

    void WriteToStream( IStreamOut *stream );

    // Delegates to WriteToBuffer() and ReadFromBuffer().
    CEditDocState *RecordState();
    void RestoreState(CEditDocState *);

#ifdef DEBUG
    void DebugPrintState(IStreamOut& stream);
    void ValidateTree();
    void SuppressPhantomInsertPointCheck(XP_Bool bSuppress);
#endif
    void DisplaySource();
    void InitEscapes();
    char* NormalizeText( char* pSrc );
    intn NormalizePreformatText( pa_DocData *pData, PA_Tag *pTag, intn status );
    MWContext *GetContext(){ return m_pContext; }
    EDT_ClipboardResult PasteQuoteBegin(XP_Bool bHTML);
    EDT_ClipboardResult PasteQuote(char *pText);
    EDT_ClipboardResult PasteQuoteINTL(char *pText, int16 csid);
    EDT_ClipboardResult PasteQuoteEnd();
    void PasteHTMLHook(CPrintState* pPrintState); // For CPrintState.

    EDT_ClipboardResult PasteText(char *pText, XP_Bool bMailQuote, XP_Bool bIsContinueTyping, XP_Bool bRelayout, XP_Bool bReduce); /* Deprecated. */
    EDT_ClipboardResult PasteText(char *pText, XP_Bool bMailQuote, XP_Bool bIsContinueTyping, int16 csid,  XP_Bool bRelayout, XP_Bool bReduce);
    EDT_ClipboardResult PasteHTML(char *pText, ED_PasteType iPasteType);
    EDT_ClipboardResult PasteHTML(IStreamIn& stream, ED_PasteType iPasteType);
    EDT_ClipboardResult PasteCellsIntoTable(IStreamIn& stream, ED_PasteType iPasteType);
    void PasteTable( CEditTableCellElement *pCell, CEditTableElement *pSourceTable, ED_PasteType iPasteType );
    EDT_ClipboardResult PasteHREF( char **ppHref, char **ppTitle, int iCount);
    EDT_ClipboardResult CopySelection( char **ppText, int32* pTextLen,
                                       char **ppHtml, int32* pHtmlLen);

    // Next 2 are used only for copying across table cell boundaries. iCopyType is assumed to be ED_COPY_NORMAL.
    void CopySelectionAcrossCellBoundary(CEditSelection& selection, char **ppHtml, int32* pHtmlLen);
    void AppendCopyBetweenElements( CEditLeafElement *pBegin, CEditLeafElement *pEnd, CStreamOutMemory& stream );

    XP_Bool CopyBetweenElements( CEditElement *pBegin,
                                 CEditElement *pEnd, char **ppText, int32* pTextLen,
                                 char **ppHtml, int32* pHtmlLen );
    XP_Bool CopySelectionContents( CEditSelection& selection,
                                   char **ppHtml, int32* pHtmlLen, ED_CopyType iCopyType = ED_COPY_NORMAL );
    //cmanske: Added flags param to pass info about copied table elements
    XP_Bool CopySelectionContents( CEditSelection& selection,
                    IStreamOut& stream, ED_CopyType iCopyType = ED_COPY_NORMAL );
    

    int32 GetClipboardSignature();
    int32 GetClipboardVersion();
    EDT_ClipboardResult CutSelection( char **ppText, int32* pTextLen,
            char **ppHtml, int32* pHtmlLen);
    XP_Bool CutSelectionContents( CEditSelection& selection,
                    char **ppHtml, int32* pHtmlLen );

    // cmanske: New Table-related cut/paste functions
    // Returns FALSE if number of cells in each row are not all the same
    XP_Bool CountRowsAndColsInPasteText(char *pText, intn* pRows, intn* pCols);
    // Supply Rows, Cols if known, else they will be calculated from text 
    //  if in existing table, iPasteType determines whether (and how) we integrate into its cells
    //  or insert a new nested table
    EDT_ClipboardResult PasteTextAsTable(char *pText, ED_PasteType iPasteType, intn iRows = 0, intn iCols = 0);

    void RefreshLayout();
    void FixupSpace( XP_Bool bTyping = FALSE);
    ED_Alignment GetCurrentAlignment();
    int32 GetDesiredX(CEditLeafElement* pEle, intn iOffset, XP_Bool bStickyAfter);

    // Selection utility methods
    void GetInsertPoint(CEditInsertPoint& insertPoint);
    void GetInsertPoint(CPersistentEditInsertPoint& insertPoint);
    void GetSelection(CEditSelection& selection);
    void GetSelection(CPersistentEditSelection& persistentSelection);
    void SetSelection(CPersistentEditSelection& persistentSelection);

    // Navigation
    XP_Bool Move(CEditInsertPoint& pt, XP_Bool forward);
    XP_Bool Move(CPersistentEditInsertPoint& pt, XP_Bool forward);
    XP_Bool CanMove(CEditInsertPoint& pt, XP_Bool forward);
    XP_Bool CanMove(CPersistentEditInsertPoint& pt, XP_Bool forward);

    void CopyEditText(CPersistentEditSelection& selection, CEditText& text);
    void CopyEditText(CEditText& text);
    void CutEditText(CEditText& text);
    void PasteEditText(CEditText& text);

    // Persistent to regular selection conversion routines
    CEditInsertPoint PersistentToEphemeral(CPersistentEditInsertPoint& persistentInsertPoint);
    CPersistentEditInsertPoint EphemeralToPersistent(CEditInsertPoint& insertPoint);
    CEditSelection PersistentToEphemeral(CPersistentEditSelection& persistentInsertPoint);
    CPersistentEditSelection EphemeralToPersistent(CEditSelection& insertPoint);

    // Command methods
    void AdoptAndDo(CEditCommand*);
    void Undo();
    void Redo();
    void Trim();

    // History limits
    intn GetCommandHistoryLimit();
    void SetCommandHistoryLimit(intn newLimit);

    // Returns NULL if out of range
    intn GetUndoCommand(intn);
    intn GetRedoCommand(intn);
    void BeginBatchChanges(intn commandID);
    void EndBatchChanges();

    XP_Bool IsWritable(); // FALSE while a plugin is executing.

    // Typing command methods.
    void DoneTyping();
    void StartTyping(XP_Bool bTyping);

//cmanske - no longer using column/row indexes
//    void SyncCursor(CEditTableElement* pTable, intn iColumn, intn iRow);
//    CEditSelection ComputeCursor(CEditTableElement* pTable, intn iColumn, intn iRow);
    void SyncCursor(CEditLayerElement* pLayer);

    void ReplaceText( char *pReplaceText, XP_Bool bReplaceAll,
					  char *pTextToLookFor, XP_Bool bCaseless, XP_Bool bBackward, XP_Bool bDoWrap );

    /* function for finding and replacing text once */
    XP_Bool ReplaceOnce(char *pReplaceText, XP_Bool bRelayout, XP_Bool bReduce);

    void ReplaceLoop(char *pReplaceText, XP_Bool bReplaceAll,
                         char *pTextToLookFor, XP_Bool bCaseless,
                         XP_Bool bBackward, XP_Bool bDoWrap );

#ifdef FIND_REPLACE
    XP_Bool FindAndReplace( EDT_FindAndReplaceData *pData );
#endif

    XP_Bool IsMultiSpaceMode(){ return m_bMultiSpaceMode; }

private:
    // CLM: Dynamic object sizing
    CSizingObject     *m_pSizingObject;

public:
    // Table sizing, selection, add row or col interface
    
    // Get the hit type from current mouse location in the doc
    //  (See ED_HitType enum in include/edttypes.h)
    // Optional: Returns the table or cell element clicked on
    // bModifierKeyPressed is applicable if selecting table (upper left corner),
    //  or moving mouse over cell to extend selection.
    //  If TRUE, returns ED_HIT_SEL_ALL_CELLS instead of ED_HIT_SEL_TABLE
    ED_HitType GetTableHitRegion(int32 xVal, int32 yVal, LO_Element **ppElement, XP_Bool bModifierKeyPressed = FALSE);

    // Tells us where to insert or replace cell 
    // (LO_Cell we are over is returned in *ppElement)
    ED_DropType GetTableDropRegion(int32 *pX, int32 *pY, int32 *pWidth, int32 *pHeight, LO_Element **ppElement);

    // Used within editor - use supplied cell's X and Y and get LO_CellStruct from it
    //   to pass to following version.
    // iHitType can be set to just 1 cell, or entire row or column
    XP_Bool SelectTableElement(CEditTableCellElement *pCell, ED_HitType iHitType);

    // This is only table select function exposed to FEs via EDT_SelectTableElement
    // Select a table, cell, row, or column and redraw table to show new selection
    // If selecting cells and bAppendSelection is TRUE, then current selected items will not be cleared
    //  (ignored if selecting a table - cell selection will be cleared)
    // All uses ignore x and y except when ED_HitType = ED_HIT_SEL_COL or ED_HIT_SEL_ROW,
    //   which need those coordinates to find the REAL column or row 
    //   when ROWSPAN or COLSPAN is used.
    // If pLoElement == NULL, then the current caret location is used
    //   to locate element by calling GetCurrentLoTableElement
    XP_Bool SelectTableElement(int32, int32 y, LO_Element *pLoElement, ED_HitType iHitType, 
                               XP_Bool bModifierKeyPressed = FALSE,
                               XP_Bool bExtendSelection = FALSE );

    // Helper for SelectTableElement - find appropriate element at current caret location
    LO_Element* GetCurrentLoTableElement(ED_HitType iHitType, int32 *pX, int32 *pY);

       
    // Called on mouse-move message after selection was started
    // on a row, column, or cell element
    // Returns the hit type: ED_HIT_SEL_ROW, ED_HIT_SEL_COL, ED_HIT_SEL_CELL, or ED_HIT_NONE
    //   reflecting what type of block we are extended,
    //     or ED_HIT_NONE if mouse is outside of the table
    //   Use this to set the type of cursor by the FEs
    ED_HitType ExtendTableCellSelection(int32 x, int32 y);

    // Used by ExtendTableCellSelection
    //  and SelectTableElement when bExtendSelection is TRUE,
    // Select all cells whose top and left are within a rect formed by
    //   left and top last selected cell (m_pSelectedTableElement) and pLastCell
    void SelectBlockOfCells(LO_CellStruct *pLastCell);

    // Get corresponding layout cell struct containing the given edit element
    // Null if not in a table, of course
    LO_CellStruct* GetLoCell(CEditElement *pEdElement);

    // Set or clear the two table pointers (m_pSelectedEdTable, m_pSelectedLoTable)
    // pLoTable must be supplied if bSelect is TRUE. 
    //   If FALSE, existing selected table is unselected
    // Table selection is redisplayed if changed from existing state
    //   pEdTable is optional - it will be found from pLoTable if pEdTable = NULL
    //   and returned
    CEditTableElement* SelectTable(XP_Bool bSelect, LO_TableStruct *pLoTable = NULL, CEditTableElement *pEdTable = NULL);

    // Helper to select a single cell - both Lo and Edit arrays updated
    //   and cells are redisplayed. pLoCell must be supplied, but
    //   pEdCell is optional - it will be found from pLoCell if pEdCell = NULL
    //   and returned
    CEditTableCellElement* SelectCell(XP_Bool bSelect, LO_CellStruct *pLoCell, CEditTableCellElement *pEdCell = NULL);
    
    // Set the special selection attribute used for all currently-selected cells,
    //  except for the supplied "focus" cell.
    // Front ends should always display the "special" attribute
    //  if that bit (LO_ELE_SELECTED_SPECIAL) even if LO_ELE_SELECTED ) is also set
    void DisplaySpecialCellSelection(CEditTableCellElement *pFocusCell = NULL,  EDT_TableCellData *pCellData = NULL);
    
    // Select current cell and change other currently-selected cells
    //  to LO_ELE_SELECTED_SPECIAL so user can tell difference between
    //  the "focus" cell (current, where caret is) and other selected cells
    //  Call just before Table Cell properties dialog is created
    // Supply pCellData to update iSelectionType and iSelectedCount values
    void StartSpecialCellSelection(EDT_TableCellData *pCellData = NULL);

    // Do multi-cell selection highlighting of cells that will be replaced
    //  when pasting table cells from clipboard or dragging 
    //  on other table cells based on data in m_pDragTableData
    // Uses the same "special selection" style as for StartSpecialCellSelection()
    void SetReplaceCellSelection();

    // If pDragOverCell is supplied, clear all cells with LO_ELE_SELECTED_SPECIAL
    //  in the table containing that cell
    // Remove LO_ELE_SELECTED_SPECIAL from all currently-selected cells
    // Call after closing the Table Cell properties dialog
    void ClearSpecialCellSelection(LO_Element *pDragOverCell = NULL);

    // Rearrange order of cells in selected cell lists as they
    //   appear from upper left to lower right (rows first) 
    void SortSelectedCells();
    
    // Remove selection from all tables and cells (both Editor and LO_Element elements affected)
    void ClearTableAndCellSelection();
    
    // Clear any existing cells selected if current edit element is not inside selection
    void ClearCellSelectionIfNotInside();

    // Do stuff necessary before deleting an element:
    // 1. If the supplied element is in our Table or Selection list,
    //    clear the selection.
    // 2. Clear saved pointer (m_pWatchForDeletionElement) if it = pElement
    void CleanupForDeletedElement(CEditElement *pElement);
    
    XP_Bool IsTableSelected() {return m_pSelectedEdTable != NULL; }
    XP_Bool IsTableOrCellSelected() { return m_pSelectedEdTable ? TRUE : (m_SelectedEdCells.Size() > 0 ? TRUE : FALSE); }
    int     GetSelectedCellCount() { return m_SelectedEdCells.Size(); }
    CEditTableElement* GetSelectedTable() { return m_pSelectedEdTable; }
    
    // New cell with space management. 
    // This is complicated by the fact the relevant FinishedLoad() methods
    //   are used by both initial loading of page and table elements
    //   created internally. We should only insert extra space when creating internally
    // This is set from preferences
    XP_Bool NewCellHasSpace() { return m_bNewCellHasSpace; }
    // Before creating new cells internally, call this
    //  so new cells are filled with a space if pref was set
    void SetFillNewCellWithSpace() { m_bFillNewCellWithSpace = m_bNewCellHasSpace; }
    // Reset when done creating new cells
    void ClearFillNewCellWithSpace() { m_bFillNewCellWithSpace = FALSE; }
    // Call in FinishedLoad methods to check if we should insert the space
    XP_Bool FillNewCellWithSpace() { return m_bFillNewCellWithSpace; }

    // For special cell highlighting during drag and drop
    // pLoElement can be the table or any cell that is starting cell,
    //  all cells from starting cell will have attribute removed
//NOT USED???
//    void ClearCellAttrmask(LO_Element *pLoElement, uint16 attrmask );

    // Start Column or Row search from current element
    // This works on geometric location data, not "logical" row or column
    CEditTableCellElement* GetFirstCellInCurrentColumn();
    CEditTableCellElement* GetFirstCellInCurrentRow();

    intn GetNumberOfSelectedColumns();
    intn GetNumberOfSelectedRows();
    void MoveToFirstSelectedCell();
    void MoveToLastSelectedCell();

    // Dynamic object sizing interface
    XP_Bool       IsSizing() { return (m_pSizingObject != 0); }
    ED_SizeStyle  CanSizeObject(LO_Element *pLoElement, int32 xVal, int32 yVal, XP_Bool bModifierKeyPressed = FALSE);
    ED_SizeStyle  StartSizing(LO_Element *pLoElement, int32 xVal, int32 yVal, XP_Bool bModifierKeyPressed, XP_Rect *pRect);
    XP_Bool       GetSizingRect(int32 xVal, int32 yVal, XP_Bool bModifierKeyPressed, XP_Rect *pRect);
    void          EndSizing();
    void          CancelSizing();
    
    XP_Bool       IsReady();

    // Spellcheck api
    XP_Bool FindNextMisspelledWord( XP_Bool bFirst, XP_Bool bSelect,
            CEditLeafElement **ppWordStart );

    // Iterate over mispelled words, replace or ignore them.
    enum EMSW_FUNC { EMSW_IGNORE, EMSW_REPLACE };
    void IterateMisspelledWords( EMSW_FUNC eFunc, char* pOldWord, char* 
            pNewWord, XP_Bool bAll );

    LO_Element* FirstElementOnLine(LO_Element* pTarget, int32* pLineNum);

    // Return TRUE if delete the buffer by calling ChangeEncoding
    XP_Bool SetEncoding(int16 csid);
    // Change encoding and translate current doc
    void ChangeEncoding(int16 csid);
    // Change just the metatag charset value
    void SetEncodingTag(int16 csid);
    void SetEncodingTag(char *pCharset);

    XP_Bool HasEncoding();
    
    // This signals replacing the charset string in metatag
    //  after reloading URL when we are fixing a bad original charset
    int16 m_iReplaceCSID;

    // Used for QA only - Ctrl+Alt+Shift+N accelerator for automated testing
    void SelectNextNonTextObject();
    CEditTableElement *m_pNonTextSelectedTable;

#ifdef EDITOR_JAVA
    EditorPluginManager GetPlugins();
#endif

public:
    static XP_Bool IsAlive(CEditBuffer* pBuffer); // Tells you if the pointer is valid.

private:
    void CheckAndPrintComment(CEditLeafElement* pElement, CEditSelection& selection, XP_Bool bEnd);
    void CheckAndPrintComment2(const CEditInsertPoint& where, CEditSelection& selection, XP_Bool bEnd);

    void SetSelectionInNewDocument();
    void ParseBodyTag(PA_Tag *pTag);
    void RecordTag(PA_Tag* pTag, XP_Bool bWithLinefeed);
    void RecordJavaScriptAsUnknownTag(CStreamOutMemory* pOut);

    void SetBaseTarget(char* pTarget);
    char* GetBaseTarget(); /* NULL if no BASE TARGET */

    CFinishLoadTimer m_finishLoadTimer;
    CRelayoutTimer m_relayoutTimer;
    CAutoSaveTimer m_autoSaveTimer;
    XP_Bool m_bDisplayTables;
    XP_Bool m_bDummyCharacterAddedDuringLoad;
    static XP_Bool m_bAutoSaving;
    XP_Bool m_bReady;
    XP_Bool m_bPasteQuoteMode;
    XP_Bool m_bPasteHTML;
    XP_Bool m_bPasteHTMLWhenSavingDocument;
    CStreamOutMemory* m_pPasteHTMLModeText;
    CConvertCSIDStreamOut* m_pPasteTranscoder;
    XP_Bool m_bAbortPasteQuote;
    // In case the user sets the encoding
    int16 m_originalWinCSID;
    XP_Bool m_bForceDocCSID;
    int16 m_forceDocCSID;
    XP_Bool m_bImportText;
    
    // Used during creation of new cells
    // This is set to the value of m_bNewCellHasSpace by SetFillNewCellWithSpace()
    XP_Bool m_bFillNewCellWithSpace;

//preference information
    static XP_Bool m_bNewCellHasSpace; //New cells we create have an &nbsp in them so border displays


    static XP_Bool m_bMoveCursor; //true = move cursor when pageup/down false, just move scrollbar
    static XP_Bool m_bEdtBufPrefInitialized; //are the preferences initialized
    static int PrefCallback(const char *,void *);//callback for preferences
    static void InitializePrefs();//call this function to force initialization of preferences
};


//
// CEditTagCursor -
//
class CEditTagCursor {
private: // types
    enum TagPosition { tagOpen, tagEnd };

private: // data

    CEditBuffer *m_pEditBuffer;
    CEditElement *m_pCurrentElement;
    CEditPositionComparable m_endPos;
    TagPosition m_tagPosition;
    int m_stateDepth;
    int m_currentStateDepth;
    int m_iEditOffset;
    XP_Bool m_bClearRelayoutState;
    MWContext *m_pContext;
    PA_Tag* m_pStateTags;


public:  // routines
    CEditTagCursor( CEditBuffer* pEditBuffer, CEditElement *pElement,
            int iEditOffset, CEditElement* pEndElement );
    ~CEditTagCursor();

    PA_Tag* GetNextTag();
    PA_Tag* GetNextTagState();
    XP_Bool AtBreak(XP_Bool* pEndTag);
    int32 CurrentLine();
    XP_Bool ClearRelayoutState() { return m_bClearRelayoutState; }
    CEditTagCursor* Clone();
};

//-----------------------------------------------------------------------------
//  CEditImageLoader
//-----------------------------------------------------------------------------
class CEditImageLoader {
private:
    CEditBuffer *m_pBuffer;
    EDT_ImageData *m_pImageData;
    LO_ImageStruct *m_pLoImage;
    XP_Bool m_bReplaceImage;

public:
    CEditImageLoader( CEditBuffer *pBuffer, EDT_ImageData *pImageData,
            XP_Bool bReplaceImage );
    ~CEditImageLoader();

    void LoadImage();
#if 0
    void SetImageInfo(int32 ele_id, int32 width, int32 height);
#endif
    void SetImageInfo(int32 width, int32 height);
};

//-----------------------------------------------------------------------------
// CEditSaveToTempData: used to call back to FE after saving document to temp
// file.  Could be expanded to be a general callback mechanism for reporting
// when saving is complete.
//-----------------------------------------------------------------------------
class CEditSaveToTempData {
public:
  CEditSaveToTempData() : doneFn(NULL), hook(NULL), pFileURL(NULL) {}
  ~CEditSaveToTempData() {XP_FREEIF(pFileURL);}

  EDT_SaveToTempCallbackFn doneFn;
  void *hook;
  char *pFileURL;
};

//-----------------------------------------------------------------------------
//  CFileSaveObject
//-----------------------------------------------------------------------------
// Takes care of FE interaction, does not know that there is anything
// special about the first file (the root HTML document for CEditSaveObject).
class CFileSaveObject {
    friend void edt_CFileSaveObjectDone(XP_Bool,void *); // A callback.

private:
    XP_Bool m_bOverwriteAll;
    XP_Bool m_bDontOverwriteAll;
    XP_Bool m_bDontOverwrite;
    int m_iCurFile; // 1-based
    int m_iErrorCount;
    IStreamOut *m_pOutStream;
    XP_Bool m_bOpenOutputHandledError;
    CEditSaveToTempData *m_pSaveToTempData;

protected:
    // Override this if the child of CFileSaveObject needs to do anything special to save the
    // first file.  O.w. it will just be copied from source to dest like everything else.
    // Return TRUE if the child took care of saving the first file.
    virtual XP_Bool SaveFirstFile() {return FALSE;}

    // can be a full file path.  Grabs the path part automatically.
    // Return the path part of pFileURL, alloced with XP_STRDUP.
    char *GetPathURL( char* pFileURL );

    // Check to see if we should call FE_FinishedSave() to tell
    // the front end that a new file has been created.
    void CheckFinishedSave(intn iFileIndex,ED_FileError iError);

    MWContext *m_pContext;
    ITapeFileSystem *m_tapeFS;
    ED_FileError m_status;
    XP_Bool m_bFromAutoSave; // This save was initiated from the auto save callback.

public:
    //
    // inherited interface.
    //
#if 0
    CFileSaveObject( MWContext *pContext, char *pSrcURL, ITapeFileSystem *tapeFS, XP_Bool bAutoSave,
                     CEditSaveToTempData * ) ;
#endif
    CFileSaveObject( MWContext *pContext, ITapeFileSystem *tapeFS, XP_Bool bAutoSave,
                     CEditSaveToTempData * ) ;
    virtual ~CFileSaveObject();

    // Return values like ITapeFileSystem::AddFile().
    intn AddFile( char *pSrcURL, char *pMIMEType, int16 iDocCharSetID );

    ED_FileError SaveFiles();

    char *GetDestName( intn index );
    char *GetDestAbsoluteURL( intn index );
    char *GetSrcName( intn index );
    // Return newly allocated string.

    // Inherit from CFileSaveObject and implement FileFetchComplete.
    //
    virtual ED_FileError FileFetchComplete();

    void Cancel();

	// Communicate content type and other information to the tape file system.
	// This function is called from edt_MakeFileSaveStream 
	// after OpenOutputFile() and before FileFetchComplete().
	// Necessary so that libmime can convey the mime type of an inferior URL
	// that represents, for example, part of a mail or news message.
	void CopyURLInfo(const URL_Struct *pURL);
	
private:
    ED_FileError FetchNextFile();
/*    intn OpenOutputFile( int iFile ); */

    // Report error given by iError on the current file being processed.
    // Return whether we sould continue.  
    // Replaces FE_SaveErrorContinueDialog().
    XP_Bool SaveErrorContinueDialog(ED_FileError iError);

// Netlib interface
public:
    // Made Public so we can access from file save stream
    //  (We don't open file until
    //   libnet succeeds in finding source data)
    intn OpenOutputFile(/*int iFile*/);
    // Net Callbacks
    int NetStreamWrite( const char *block, int32 length );
#if 0
    void NetFetchDone( URL_Struct *pUrl, int status, MWContext *pContext );
#endif
    void NetFetchDone( int status );

};


//-----------------------------------------------------------------------------
//  CEditSaveObject
//-----------------------------------------------------------------------------
class CEditSaveObject: public CFileSaveObject{
private:
    enum {IgnoreImage = -1, AttemptAdjust = -2};

    // Can return IgnoreImage or AttemptAdjust
    // If ppIncludedFiles is non-NULL, image will only be added if it is in
    // the list.
    // If ppIncludeFiles is NULL, use bNoSave to decide whether to add it.
    intn CheckAddFile( char *pSrc, char *pMIMEType, char **ppIncludedFiles, XP_Bool bNoSave );

    ////XP_Bool IsSameURL( char* pSrcURL, char *pLocalName );

   // ppList is a NULL-terminated list of absolute URLs.
   XP_Bool URLInList (char **ppList, char *pURL);

    // helper for FixupLinks().
    void FixupLink(intn iIndex, // index to tape file system
                   char **ppImageURL,   // Value to fixup.
                   char *pDestPathURL,
                   ED_HREFList *badLinks);

    char *FixupLinks();

    CEditBuffer *m_pBuffer;
    CEditDocState *m_pDocStateSave; // Backup of m_pBuffer before doing anything.
    char *m_pSrcURL;
    //XP_Bool m_bSaveAs;
    ED_SaveFinishedOption m_finishedOpt; // Should we be editing the newly saved doc after saving is done.
    XP_Bool m_bKeepImagesWithDoc;
    XP_Bool m_bAutoAdjustLinks;
    intn m_backgroundIndex;
    // Must use array since we now support > 1 FontDefURL per page
    //intn m_fontDefIndex;
    TXP_GrowableArray_intn m_FontDefIndex;

public:
    CEditSaveObject( CEditBuffer *pBuffer, 
                            ED_SaveFinishedOption finishedOpt, char *pSrcURL, ITapeFileSystem *tapeFS,
                            XP_Bool bSaveAs,
                            XP_Bool bKeepImagesWithDoc, 
                            XP_Bool bAutoAdjustLinks,
                            XP_Bool bAutoSave,
                            CEditSaveToTempData *pSaveToTempData ); 
    ~CEditSaveObject();

    // Add HTML document, then find and add all images in document.
    // Returns success or not.
    // If pIncludedFiles in non-NULL, it is a NULL-terminated list of absolute
    // URLs telling which images may be published..  
    // Free all memory pointed to by ppIncludedFiles when done.
    XP_Bool AddAllFiles(char **ppIncludedFiles);

    virtual ED_FileError FileFetchComplete();

    // If list is non-null, free it element-wise, then free the list itself.
    // list is NULL-terminated if it exists.
    static void FreeList( char **list );

    // Save the source URL when we fail to publish
    // Used by EDT_GetDefaultPublishUrl to return the previous failed destination
    static char * m_pFailedPublishUrl;

protected:
    virtual XP_Bool SaveFirstFile();
};


#if 0 //// Now obsolete
//-----------------------------------------------------------------------------
//  CEditImageSaveObject
//-----------------------------------------------------------------------------
class CEditImageSaveObject: public CFileSaveObject{
private:
    CEditBuffer *m_pBuffer;
    EDT_ImageData *m_pData;
    XP_Bool m_bReplaceImage;

public:
    intn m_srcIndex;
    intn m_lowSrcIndex;

    CEditImageSaveObject( CEditBuffer *pBuffer, EDT_ImageData *pData,
                        XP_Bool bReplaceImage );
    ~CEditImageSaveObject();

    virtual ED_FileError FileFetchComplete();
};
#endif

#if 0
//-----------------------------------------------------------------------------
//  CEditBackgroundImageSaveObject
//-----------------------------------------------------------------------------
class CEditBackgroundImageSaveObject: public CFileSaveObject{
private:
    CEditBuffer *m_pBuffer;

public:
    CEditBackgroundImageSaveObject( CEditBuffer *pBuffer );
    ~CEditBackgroundImageSaveObject();

    virtual ED_FileError FileFetchComplete();
};
#endif

extern CBitArray *edt_setNoEndTag;
extern CBitArray *edt_setWriteEndTag;
extern CBitArray *edt_setHeadTags;
extern CBitArray *edt_setSoloTags;
extern CBitArray *edt_setBlockFormat;
extern CBitArray *edt_setCharFormat;
extern CBitArray *edt_setList;
extern CBitArray *edt_setUnsupported;
extern CBitArray *edt_setAutoStartBody;
extern CBitArray *edt_setTextContainer;
extern CBitArray *edt_setListContainer;
extern CBitArray *edt_setParagraphBreak;
extern CBitArray *edt_setFormattedText;
extern CBitArray *edt_setContainerSupportsAlign;
extern CBitArray *edt_setIgnoreWhiteSpace;
extern CBitArray *edt_setSuppressNewlineBefore;
extern CBitArray *edt_setRequireNewlineAfter;
extern CBitArray *edt_setContainerBreakConvert;
extern CBitArray *edt_setContainerHasLineAfter;
extern CBitArray *edt_setIgnoreBreakAfterClose;

inline XP_Bool BitSet( CBitArray* pBitArray, int i ){ if ( i < 0 ) return FALSE;
    else return (*pBitArray)[i]; }

inline int IsListContainer( TagType i ){ return BitSet( edt_setListContainer, i ); }

inline int TagHasClose( TagType i ){ return !BitSet( edt_setNoEndTag, i ); }
inline int WriteTagClose( TagType i ){ return (BitSet( edt_setWriteEndTag, i ) ||
                TagHasClose(i)); }

//
// Utility functions.
//
char *EDT_TagString(int32 tagType);
ED_TextFormat edt_TagType2TextFormat( TagType t );
char *edt_WorkBuf( int iSize );
char *edt_QuoteString( char* pString );
char *edt_MakeParamString( char* pString );

char *edt_FetchParamString( PA_Tag *pTag, char* param, int16 win_csid );
XP_Bool edt_FetchParamBoolExist( PA_Tag *pTag, char* param, int16 win_csid );
XP_Bool edt_FetchDimension( PA_Tag *pTag, char* param,
                         int32 *pValue, XP_Bool *pPercent,
                         int32 nDefaultValue, XP_Bool bDefaultPercent, int16 win_csid );
// Old defaults: ED_ALIGN_BASELINE, FALSE
ED_Alignment edt_FetchParamAlignment( PA_Tag* pTag,
                ED_Alignment eDefault, XP_Bool bVAlign, int16 win_csid );
int32 edt_FetchParamInt( PA_Tag *pTag, char* param, int32 defValue, int16 win_csid );
int32 edt_FetchParamInt( PA_Tag *pTag, char* param, int32 defValue, int32 defValueIfParamButNoValue, int16 win_csid );
ED_Color edt_FetchParamColor( PA_Tag *pTag, char* param, int16 win_csid );

// Preserves the old value of data if there's no parameter.
void edt_FetchParamString2(PA_Tag* pTag, char* param, char*& data, int16 win_csid);
void edt_FetchParamColor2( PA_Tag *pTag, char* param, ED_Color& data, int16 win_csid );

// Concatenates onto the old value
void edt_FetchParamExtras2( PA_Tag *pTag, char**ppKnownParams, char*& data, int16 win_csid );

LO_Color* edt_MakeLoColor( ED_Color c );
void edt_SetLoColor( ED_Color c, LO_Color *pColor );

void edt_InitEscapes(int16 csid, XP_Bool bQuoteHiBits);
void edt_PrintWithEscapes( CPrintState *ps, char *p, XP_Bool bBreakLines);
char *edt_LocalName( char *pURL );
PA_Block PA_strdup( char* s );

inline char *edt_StrDup( char *pStr );
EDT_ImageData* edt_NewImageData();
EDT_ImageData* edt_DupImageData( EDT_ImageData *pOldData );
void edt_FreeImageData( EDT_ImageData *pData );

void edt_SetTagData( PA_Tag* pTag, char* pTagData);
void edt_AddTag( PA_Tag*& pStart, PA_Tag*& pEnd, TagType t, XP_Bool bIsEnd,
        char *pTagData = 0 );

void edt_CopyTableCellData( EDT_TableCellData *pDestData, EDT_TableCellData *pSourceData );

void edt_InitBitArrays();

// Given an absolute URL, return the path portion of it, allocated with XP_STRDUP.
char *edt_GetPathURL(char *);

//
// Convert NBSPs into spaces.
//
void edt_RemoveNBSP( int16 csid, char *pString );

//
// Retreive extra parameters and return them in the form:
//
//  ' foo=bar zoo mombo="fds ifds ifds">'
//
char* edt_FetchParamExtras( PA_Tag *pTag, char**ppKnownParams, int16 win_csid );

// Replace the Value of a Param, rebuilding the Tag data within given tag
// Returns TRUE if param NAME was already in the list. If it wasn't,
//   it is added to end of tag data. If pValue is NULL, pName is removed from tag
XP_Bool edt_ReplaceParamValue( PA_Tag *pTag, char * pName, char * pValue, int16 csid );

// Copies text out of a Huge pointer. Truncates it if it's too large for the platform.
// Returns a copy of the text. Caller owns the copy.
// csid is the character set id of the text. Used to make sure truncation occurs on a
// character boundary.
// pOutLength is the output length in bytes. Pass NULL if you don't care about the new length.
// The result is always zero terminated, so that if the input does not contain nulls,
// XP_STRLEN(result) == *pOutLenth.

char* edt_CopyFromHuge(int16 csid, XP_HUGE_CHAR_PTR text, int32 length, int32* pOutLength);


// Return dup'd string that is the same as pUrl except that any username/password info is removed.
char *edt_StripUsernamePassword(char *pUrl);

// Terminate string in place at "#" or "?"
void edt_StripAtHashOrQuestionMark(char *pUrl);

// Kills directory pName and, recursively, everything under it.
// pName is in xpURL format.
void edt_RemoveDirectoryR(char *pName);

// Just wrappers around the XP_* functions.  The only difference is that
// these functions will work if the directory ends in a trailing slash,
// avoiding obscure bugs on Win16.
XP_Dir edt_OpenDir(const char * name, XP_FileType type);
int edt_MakeDirectory(const char* name, XP_FileType type);
int edt_RemoveDirectory(const char *name, XP_FileType type);

// Returns the URL that should be used as the base for relative URLs in 
// the document.  Similar to just calling LO_GetBaseURL(), except returns
// the document temp directory for untitled documents.
// Must free returned memory.
char *edt_GetDocRelativeBaseURL(MWContext *pContext);

// Platform-specific end-of-line character(s) added to string,
//  returning in possibly-reallocated buffer that caller must free
char *edt_AppendEndOfLine(char *pText);
//
// Parse return values.
//
#define OK_IGNORE       2
#define OK_CONTINUE     1
#define OK_STOP         0
#define NOT_OK          -1

// Inline function implementations

inline char *edt_StrDup( char *pStr ){
    if( pStr ){ 
        return XP_STRDUP( pStr );
    }
    else {
        return 0;
    }
}

// Moved from EDT.H since we don't call it from FE any more
void edt_SyncPublishingHistory(MWContext *pMWContext);

#ifdef DEBUG

class CEditTestManager {
public:
    CEditTestManager(CEditBuffer* pBuffer);
    XP_Bool Key(char key);
    XP_Bool Backspace();
    XP_Bool ReturnKey();

protected:

    void PowerOnTest();

    void DumpLoElements();
    void VerifyLoElements();
    void DumpDocumentContents();

    void PasteINTL();
    void PasteINTLText();

    void CopyBufferToDocument();
    void CopyDocumentToBuffer();

    XP_Bool ArrowTest();
    XP_Bool LArrowTest(XP_Bool bSelect);
    XP_Bool RArrowTest(XP_Bool bSelect);
    XP_Bool UArrowTest(XP_Bool bSelect);
    XP_Bool DArrowTest(XP_Bool bSelect);
    XP_Bool EveryNavigationKeyEverywhereTest();
    XP_Bool NavigateChunkCrashTest();
    XP_Bool NavChunkCrashTest(XP_Bool bSelect, int chunk, XP_Bool bDirection);
    XP_Bool DeleteKeyTest();
    XP_Bool BackspaceKeyTest();
    XP_Bool ZeroDocumentCursorTest();
    XP_Bool OneCharDocumentCursorTest();
    XP_Bool OneDayTest(int32 rounds);
    XP_Bool BoldTest(int32 rounds);
    XP_Bool TextFETest(); // Not really a test.

    void GetWholeDocumentSelection(CPersistentEditSelection& selection);
    void    DumpMemoryDelta();
#ifdef EDITOR_JAVA
    void DumpPlugins();
    void PerformFirstPlugin();
    void PerformPluginByName();
    void PerformFirstEncoder();
    void PerformPreOpen();
#endif
    void TestHTMLPaste();
    void SaveToTempFile();
    static void SaveToTempFileCB(char *pFileURL,void *hook);
    void RemoveTempFile();
    // Create the document-specific temporary directory.
    void GetDocTempDir();
private:
    CEditBuffer* m_pBuffer;
    XP_Bool m_bTesting;
    int m_iTriggerIndex;
    static const char* m_kTrigger;

    XP_HUGE_CHAR_PTR m_pSaveBuffer;

#ifdef XP_WIN32
    _CrtMemState m_state;
#endif
    char *m_pTempFileURL; // for SaveToTempFile() and RemoveTempFile().
};

#endif  //DEBUG

// Semantic sugar for debugging. Validates the tree on construction and
// destruction. Place in every method that munges the tree.
//
// VALIDATE_TREE(this);

#ifdef DEBUG
class CTreeValidater {
    CEditBuffer* m_pBuffer;
public:
    CTreeValidater(CEditBuffer* pBuffer)
     : m_pBuffer(pBuffer)
    {
        m_pBuffer->ValidateTree();
    }
    ~CTreeValidater() {
        m_pBuffer->ValidateTree();
    }
};

class CSuppressPhantomInsertPointCheck {
    CEditBuffer* m_pBuffer;
public:
    CSuppressPhantomInsertPointCheck(CEditBuffer* pBuffer)
     : m_pBuffer(pBuffer)
    {
        m_pBuffer->SuppressPhantomInsertPointCheck(TRUE);
    }
    ~CSuppressPhantomInsertPointCheck() {
        m_pBuffer->SuppressPhantomInsertPointCheck(FALSE);
    }
};

// The local variable names will cause problems if you try to
// use these macros twice in the same scope. However,
// they are nescessary to ensure that some compilers (MS VC 2.2)
// keep the object alive for the duration of the scope, instead
// of constructing and destructing it at the point of declaration.
// I think this may be a bug in the compiler -- but I'd have
// to check the ANSI standard to make sure.

#define VALIDATE_TREE(BUFFER) CTreeValidater CTreeValidater_x_zzx1(BUFFER)
#define SUPPRESS_PHANTOMINSERTPOINTCHECK(BUFFER) \
    CSuppressPhantomInsertPointCheck CSuppressPhantomInsertPointCheck_x_zzx2(BUFFER)
#else

#define VALIDATE_TREE(BUFFER)
#define SUPPRESS_PHANTOMINSERTPOINTCHECK(BUFFER)

#endif

// Find the current context's URL in the cached history data and update the
//   corresponding Title. Used by CEditBuffer::SetPageData()
void edt_UpdateEditHistoryTitle(MWContext * pMWContext, char * pTitle);

// Get the corresponding CEditTableElement if LoElementType == LO_TABLE,
//   or CEditTableCellElement if LoElementType = LO_CELL
CEditElement* edt_GetTableElementFromLO_Element(LO_Element *pLoElement, int16 LoElementType);

#endif  // _EDITOR_H
#endif  // EDITOR