зеркало из https://github.com/mozilla/gecko-dev.git
4674 строки
172 KiB
C++
4674 строки
172 KiB
C++
/* -*- 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   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
|
|
|
|
|