diff -r 000000000000 -r 1fb32624e06b textrendering/texthandling/stext/TXTINDEX.H --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textrendering/texthandling/stext/TXTINDEX.H Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,764 @@ +/* +* Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies). +* All rights reserved. +* This component and the accompanying materials are made available +* under the terms of "Eclipse Public License v1.0" +* which accompanies this distribution, and is available +* at the URL "http://www.eclipse.org/legal/epl-v10.html". +* +* Initial Contributors: +* Nokia Corporation - initial contribution. +* +* Contributors: +* +* Description: +* +*/ + + +#ifndef __TXTINDEX_H__ +#define __TXTINDEX_H__ + +#include +#include +#include +#include +#include "TXTSTD.H" + +// forward declarations +class CParaAttribs; +class CPicturePhrase; +class RReadStream; +class RWriteStream; +class CStoreMap; +class CStreamStore; +class CPicture; +class CCharFormatLayer; +class CParaFormatLayer; +class CRichText; +class MPictureFactory; + +/** +@internalComponent +*/ +enum TRichTextStylePasteMode + { + EAddNewStyles, + EConvertNewStyles, + EIgnoreNewStyles + }; + +class TTextFragment +/** +Describes a fragment of text that does not conform to the ERA text model. +@internalComponent +*/ + { +public: + TTextFragment(); +public: + TInt iLength; // Number of characters in text fragment + TInt iPhraseCount; // Number of distinct phrases in text fragment. + }; + + +class RPhraseAttribsEntry +/** +Provides a full description of a phrase. +A phrase consists of a specified number of contiguous characters [the phrase length] +of identical character format. +Where a picture is included as text content, it is described by its own phrase. +@internalComponent +*/ + { +public: + enum {EPictureIndicator = -1}; + enum {EPicturePhraseLength = 1}; +public: + RPhraseAttribsEntry(); + RPhraseAttribsEntry(CCharFormatLayer* aCharFormat, TInt aLength = 0); // Sets iLen to zero - empty text phrase + RPhraseAttribsEntry(CPicturePhrase* aPicturePhrase); // Sets iLen to EPictureIndicator + inline RPhraseAttribsEntry(const RPhraseAttribsEntry& aPhrase); + void Discard(); + inline RPhraseAttribsEntry& operator=(const RPhraseAttribsEntry& aPhrase); + // + // Persist + void ExternalizeL(RWriteStream& aStream) const; + // + // General enquiry + inline TBool IsPicturePhrase() const; + TBool IsIdentical(const RPhraseAttribsEntry& aPhrase) const; + // + // Getters + inline TInt Length() const; + CCharFormatLayer* CharFormat() const; + CCharFormatLayer* ReleaseCharFormatLayerOwnership(); + TInt GetPictureSizeInTwips(TSize& aSize) const; + TPictureHeader* PictureHeaderPtr() const; + TPictureHeader PictureHeader() const; + const CPicture* PictureHandleL(const MPictureFactory* aFactory, + const MRichTextStoreResolver* aResolver, + TInt aPos, + MLayDoc::TForcePictureLoad aForceLoad) const; + // + // Setters + void AdjustLength(TInt aIncrement); + void SetLength(TInt aLength); +private: + void AssignAndRelease(const RPhraseAttribsEntry& aPhrase); +private: + TInt iLength; // No. of characters covered by this phrase + union + { + CCharFormatLayer* iCharFormat; // *OWNED* format of this text phrase + CPicturePhrase* iPicturePhrase; // *OWNED* pointer to picture phrase information + }; + __DECLARE_TEST; + }; + + +NONSHARABLE_CLASS(CPicturePhrase) : public CBase +/** +A low-level class providing a pointer to the character format layer for this picture phrase, +and a pointer to a picture itself. (Which may be expressed in its persistent form). +@internalComponent +*/ + { +public: + static CPicturePhrase* NewL(const TPictureHeader& aPicHdr, + TCharFormatX& aFormat, + TCharFormatXMask& aMask, + CCharFormatLayer* aCharBase, + TBool& aPictureOwnershipTaken); + + static CPicturePhrase* NewL(const TPictureHeader& aPicHdr, + CCharFormatLayer* aCharLayer, + TBool& aPictureOwnershipTaken); + ~CPicturePhrase(); +protected: + CPicturePhrase(const TPictureHeader& aPicHdr,TBool& aPictureOwnershipTaken); + CPicturePhrase(const TPictureHeader& aPicHdr, CCharFormatLayer* aCharLayer,TBool& aPictureOwnershipTaken); + void ConstructL(TCharFormatX& aFormat, TCharFormatXMask& aMask, CCharFormatLayer* aCharBase); +public: + CCharFormatLayer* iCharFormat; + TPictureHeader iPicHdr; + }; + + +class TParaAttribsEntry +/** +Records the length of a paragraph (no. of characters). +and references a CParaAttributes. +@internalComponent +*/ + { +public: + TParaAttribsEntry(); + TParaAttribsEntry(TInt aLength, CParaAttribs* aParaAttribs); +public: + TInt iLength; // Number of characters in the paragraph (paragraph delimiter inclusive). + CParaAttribs* iParaAttribs; // Only references this, does not own it. + }; + + +class TCurrentIndexRecords +/** +Packages current phrase & para records. +@internalComponent +*/ + { +public: + TCurrentIndexRecords(); +public: + TParaAttribsEntry* iParaEntry; + CParaAttribs* iParaAttribs; + RPhraseAttribsEntry* iPhrase; // May be NULL. + }; + + + +class TLogicalPosition +/** +Locates the current cursor position within all aspects of the index. +@internalComponent +*/ + { +public: + TLogicalPosition(); + void Clear(); +public: + TInt iDocPos; // Absolute document position. + TInt iParaElement; // paragraph index + TInt iParaElementOffset; // position from start of paragraph + TInt iParaBasePhraseElement; // index of the first phrase in the paragraph + TInt iPhraseElement; + TInt iPhraseElementOffset; + }; + + + +NONSHARABLE_CLASS(CParaAttribs) : public CBase +/** +Describes the attributes that apply to the paragraph. +*owns* an iParaFormat(Layer), and *owns* an iPhraseAttribsIndex +or charFormatLayer. +@internalComponent +*/ + { +public: + enum TParaRefCount {EPrimeNonSharedCount, EPrimeSharedCount}; + enum {EPhraseIxGranularity = 1}; +public: + // Create a CParaAttribs with constant character formatting. + static CParaAttribs* NewL(const CParaFormatLayer* aParaLayer, const CCharFormatLayer* aCharLayer); + // Create a CParaAttribs with specific character formatting. + static CParaAttribs* NewL(const CParaFormatLayer* aParaLayer); + static CParaAttribs* NewL(const CParaAttribs* aParaAttribs); + void Release(); + void Release(TInt aCount); + // + // Utility functions + inline TBool IsShared() const; + TInt PhraseCount() const; +protected: + CParaAttribs(); + ~CParaAttribs(); + CParaAttribs* CopyParaFormatL(); +private: +public: + TDblQueLink link; + TInt iRefCount; // Indicates re-use of this. + CParaFormatLayer* iParaFormat; + union + { + CCharFormatLayer* iCharFormat; // iRefCount>0 - a single shared phrase - constant char format. + TInt iPhraseCount; // iRefCount==0 - the number of phrases in this para. + }; + }; + + +// + +class TRtPasteContext +/** +Provides the context for pasting of pictures from a clipboard. +@internalComponent +*/ + { +public: + TRtPasteContext(const CStreamStore* aStore, const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer, const CStyleList* aStyleList); +public: + const CStreamStore* iStore; // the clipboard store + const CParaFormatLayer* iGlobalParaLayer; // the global para layer of the target text document + const CCharFormatLayer* iGlobalCharLayer; // the global char layer of the target text document + const CStyleList* iStyleList; // style list is present + TBool iParagraphStylesFlag; // ETrue indicates presence of inline style references in index data + TBool iIncompleteParaFlag; // ETrue indicates the pasted text fragment has no final para delimiter + TBool iApplyFormatToLastFlag; // ETrue indicates that para format should be applied to last text fragment + TLogicalPosition iPastePos; // the character position at which the text is to be pasted + TInt iParasPasted; // the number of paragraphs successfully pasted + TInt iStylePasteMode; + }; + + + +class TIndexDeleteInfo +/** +Contains information pertaining to an index delete operation. +Carries between a SetForDeleteL and a DeleteNow method call. +@internalComponent +*/ + { +public: + enum TDeleteType + { + EDeleteFromParagraph, + EDeleteParagraph, + ENonspecificDelete + }; +public: + TInt iStartPara; + TInt iEndPara; + TLogicalPosition iDeletePos; + TInt iDeleteLength; + TDeleteType iDeleteType; + }; + + +class TRichTextMapEntry +/** +A utility class for patching references to persisted shared objects +of the specified type. +Code at the bottom of the header +@internalComponent +*/ + { +public: + TRichTextMapEntry(TInt aRefNumber, TAny* aItem); + TRichTextMapEntry(TAny* aS, TAny* aT); +public: + union + {// The source item - a reference to a persistent one, or the in-memory original. + TInt iRefNumber; + TAny* iS; // only used in appending one rich text to another + }; + TAny* iT; // the newly created/restored item - the target + }; + + +template +class CRichTextStoreMap : public CBase +/** +// +A utility class for patching references to persisted shared objects +of the specified type. +Code at the bottom of the header +Used for clipboarding to i) patch references to paragraph styles +ii) patch references to shared paragraph formats +and also used in the appending of one rich text to another. +@internalComponent +*/ + { +public: + static CRichTextStoreMap* NewLC(TInt aMaximumCapacity); + ~CRichTextStoreMap(); + // + void Bind(TInt aRefNumber, T* aItem); + void Bind(T* aS, T* aT); + // + T* Item(TInt aRefNo)const; + T* Item(const T* aS)const; + inline const TRichTextMapEntry& At(TInt aIndex)const; + // + inline TInt Count()const; + // + void __DbgTestInvariant()const; +private: + void ConstructL(TInt aMaximumCapacity); +private: + CArrayFixFlat* iMap; +public: + TInt iCapacity; + }; + + +class TGlobalLayerInfoAppend +/** +@internalComponent +*/ + { +public: + TGlobalLayerInfoAppend(); + TGlobalLayerInfoAppend(const CParaFormatLayer* aAggParaFormatLayer, const CCharFormatLayer* aAggCharFormatLayer, + const CParaFormatLayer* aComParaFormatLayer, const CCharFormatLayer* aComCharFormatLayer); +public: + const CParaFormatLayer* iAggParaFormatLayer; + const CCharFormatLayer* iAggCharFormatLayer; + const CParaFormatLayer* iComParaFormatLayer; + const CCharFormatLayer* iComCharFormatLayer; + }; + +const TInt KSingleParaGranularity = 1; +const TInt KMultiParaGranularity = 16; +const TInt KSmallPhraseGranularity = 5; +const TInt KLargePhraseGranularity = 16; +const TUint32 KPhraseSplit = 0x01; +const TUint32 KSpecificMarkupInternalized = 0x04; + +/** +@internalComponent +*/ +typedef CRichTextStoreMap CStyleMap; +typedef CRichTextStoreMap CParaAttribsMap; + +/** Stores the paragraph and character formatting information for CRichText. + +iParaIx stores the paragraph formatting, one entry per paragraph. Paragraphs +are pieces of text delimited by the Unicode Paragraph Delimiter character +U+2029. + +iPhraseIx stores the character formatting. + +Paragraph formatting information can be shared or not shared between +paragraphs. Sharing is only permitted for paragraphs that do not have any +character formatting applied to their text. + +A phrase is a run of consistently formatted characters. A phrase may only +contain a paragraph delimiter in its last character. In other words, phrases +are not permitted to span paragraph boundaries. + +iPhraseIx only stores formatting for the non-shared paragraphs. Therefore +adding up the lengths of all the phrases in iPhraseIx will yield the sum of the +non-shared paragraphs stored in iParaIx. + +Note that the "nominal" paragraph delimiter at the end of the text which is not +stored by CRichText is covered by both character and paragraph formatting. So +the length of the final paragraph and final phrase (if appropriate) includes +this character. + +@internalComponent +*/ +class CRichTextIndex : public CBase + { +public: + static CRichTextIndex* NewL(const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer, + const CRichText& aText, + TInt aParaGran,TInt aPhraseGran); + static CRichTextIndex* NewL(const CStreamStore& aStore, TStreamId aId, + const CParaFormatLayer* aGlobalParaLayer, + const CCharFormatLayer* aGlobalCharLayer, + const CRichText& aText); + ~CRichTextIndex(); + // + // Store/Restore functions - Deferred loading of pictures + TStreamId StoreMarkupL(CStreamStore& aStore, const CStyleList* aStyleList) const; + // + void RestoreL(const CStreamStore& aStore, TStreamId aId, + const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer, + const CStyleList* aStyleList); + // + void StorePicturesL(CStreamStore& aStore, CStoreMap& aMap) const; + void StorePicturesL(CStreamStore& aStore, CStoreMap& aMap, TInt aPos, TInt aLength) const; + void DetachFromStoreL(CPicture::TDetach aDegree, TInt aPos, TInt aLength); + void ExternalizeL(RWriteStream& aStream) const; + void InternalizeL(RReadStream& aStream, const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer, + const CStyleList* aStyleList); + // + // 3n Persist functions + TBool HasMarkupData(const CFormatLayer* aGlobalParaFormatLayer) const; + TPictureHeader PictureHeader(TInt aPos) const; + TPictureHeader* PictureHeaderPtr(TInt aPos); + // + // Undo/CutPaste + void CopyToStreamL(RWriteStream& aStream, TInt aPos, TInt aLength, TBool aCopyStyles) const; + void PasteFromStreamL(const CStreamStore& aStore, RReadStream& aStream, TInt aPos, CParagraphStyle::TStylePasteMode aStylePasteMode, const CParaFormatLayer* aGlobalParaLayer, const CCharFormatLayer* aGlobalCharLayer); + // + // Content modifier functions + void Reset(const CParaFormatLayer& aNormalParagraphStyle); + void InsertL(TInt aPos, const TDesC& aBuf, const CParaFormatLayer& aGlobalParaFormatLayer); + void InsertL(TInt aPos, const TPictureHeader& aPicHdr, TBool& aPictureOwnershipTaken); + void SetForDeleteL(TIndexDeleteInfo& aInfo, TInt aPos, TInt aLength); + TBool DeleteNow(TIndexDeleteInfo& aInfo); + void DeleteFromParagraph(TInt aPos, TInt aLength); + TBool DeleteParagraph(TInt aPos, TInt aLength); + void Normalize(TInt aPos); + // + // Insert a new paragraph at position aPos, based on the 'Normal' global defaults. + // Any explicit paragraph/character formatting is carried forward into this paragraph. + void InsertParagraphL(TInt aPos, const CParaFormatLayer& aGlobalParaFormatLayer); + // + // Special behaviour format modifier functions. + TBool InsertCharFormatIsActive(); + void SetInsertCharFormatL(const TCharFormatX& aFormat, const TCharFormatXMask& aMask, TInt aPos); + void NewInsertCharFormatL(const TCharFormatX& aFormat, + const TCharFormatXMask& aMask, TInt aPos); + void UpdateInsertCharFormatL(const TCharFormatX& aFormat, + const TCharFormatXMask& aMask); + CCharFormatLayer* GetCurrentInsertCharFormat(); + void CancelInsertCharFormat(); + TBool DelSetInsertCharFormatL(TInt aPos, TInt aLength); + // + // Laydoc interface support + void GetParagraphFormatL(CParaFormat* aFormat,TInt aPos) const; + TInt GetChars(TCharFormatX& aFormat,TInt aPos) const; + TInt GetPictureSizeInTwips(TSize& aSize, TInt aPos) const; + CPicture* PictureHandleL(TInt aPos, MLayDoc::TForcePictureLoad aForceLoad) const; + // + // FormatText interface support + void GetParaFormatL(CParaFormat* aFormat, TParaFormatMask& aUndeterminedMask, TInt aPos, TInt aLength, + CParaFormat::TParaFormatGetMode aMode) const; + void ApplyParaFormatL(const CParaFormat* aFormat, const TParaFormatMask& aMask, TInt aPos, TInt aLength); + void GetCharFormat(TCharFormatX& aFormat, TCharFormatXMask& aMask,TInt aPos, TInt aLength) const; + void ApplyCharFormatL(const TCharFormatX& aFormat, const TCharFormatXMask& aMask, TInt aPos, TInt aLength, TBool aRemoveSpecific = EFalse); + void RemoveSpecificCharFormatL(TInt aPos, TInt aLength); + void RemoveSpecificParaFormatL(TInt aPos, TInt aLength); + // + // + void GetSpecificCharFormat(TCharFormatX& aFormat, TCharFormatXMask& aMask, TInt aPos) const; + void GetSpecificCharFormatDirection(TCharFormatX& aFormat, TCharFormatXMask& aMask, + TInt aPos, TBool aGetLeft) const; + // + // Paragraph style implementation + void ApplyParagraphStyleL(const CParagraphStyle& aStyle, TInt aPos, TInt aLength, const CCharFormatLayer* aCharStyleNormal, CParagraphStyle::TApplyParaStyleMode aMode); + void NotifyStyleChangedL(const CParagraphStyle* aTo, const CParagraphStyle* aFrom, const CParaFormatLayer& aGlobalParaFormatLayer, const CCharFormatLayer& aGlobalCharFormatLayer); + const CParaFormatLayer* ParagraphStyle(TBool& aStylesChangesOverRange, TInt aPos, TInt aLength) const; + // + // Utility functions + inline TInt ParagraphCount() const; + TInt CharPosOfParagraph(TInt& aLength, TInt aParaOffset) const; + TInt ParagraphNumberForPos(TInt& aPos) const; + inline void SetSpecificMarkupInternalized(TBool aBool); + inline TBool SpecificMarkupInternalized() const; + void DocumentChanged()const; + // + // Speciality functions + void AppendTakingSolePictureOwnershipL(const CRichTextIndex* aSource, const TGlobalLayerInfoAppend& aGlobalLayerInfo); + void AppendParagraphL(const CParaFormatLayer* aGlobalParaFormatLayer, const CCharFormatLayer* aGlobalCharFormatLayer, + TInt aReplicas); + TInt SharedParaCount(const CRichTextIndex* aSource) const; + void GetSpecificParagraphFormatL(CParaFormat* aFormat, + TParaFormatMask& aMask, + TInt aPos) const; +private: + enum TScanToPositionMode {EScanToPositionMatchLeft, EScanToPositionAbsolute}; + enum {EInsertCharFormatReset = -1}; + enum TPositionOrPhrase {EPositionOnly, EFollowingPhrase}; +private: + CRichTextIndex(const CRichText& aText); + void ConstructL(const CParaFormatLayer* aGlobalParaFormat, const CCharFormatLayer* aGlobalCharFormat, TInt aParaGran, TInt aPhraseGran); + // + // Persistence/Copy,Paste + void InternalizeRtiHeaderL(RReadStream& aStream, TRtPasteContext& aContext); + void ExternalizeRtiHeaderL(RWriteStream& aStream, const TLogicalPosition& aEnd, const CStyleList* aStyleList) const; + void ExternalizeReferencedStylesL(RWriteStream& aStream, const TLogicalPosition& aStart, const TLogicalPosition& aEnd) const; + void InternalizeSharedFormatsL(RReadStream& aStream, const TRtPasteContext& aContext); + void ExternalizeSharedFormatsL(RWriteStream& aStream, const TLogicalPosition& aStart, const TLogicalPosition& aEnd, const CStyleList* aStyleList) const; + void InternalizeParaIxL(RReadStream& aStream, const TRtPasteContext& aContext); + void ExternalizeParagraphFormatL(RWriteStream& aStream, const CParaFormatLayer& aSpecificParaFormatLayer, const CStyleList* aStyleList) const; + CParaFormatLayer* InternalizeParagraphFormatL(RReadStream& aStream, const TRtPasteContext& aContext); + CParaFormatLayer* PasteParagraphFormatL(RReadStream& aStream, const TRtPasteContext& aContext, CStyleMap* styleMap); + RPhraseAttribsEntry* ExternalizeParaIxL(RWriteStream& aStream, const TLogicalPosition& aStart, + const TLogicalPosition& aEnd, const CStyleList* aStyleList) const; + void InternalizePhraseIxL(RReadStream& aStream, const CCharFormatLayer* aGlobalCharFormat); + void ExternalizePhraseIxL(RWriteStream& aStream) const; + void ExternalizePhraseIxL(RWriteStream& aStream, + const TLogicalPosition& aStartPos, + TLogicalPosition& aEndPos, + const RPhraseAttribsEntry* aVirtualTrailingText) const; + inline void ExternalizePhraseCountL(RWriteStream& aStream, TInt aPhraseCount) const; + void ExternalizePhrasesL(RWriteStream& aStream, TInt aStart, TInt aPhraseCount, const RPhraseAttribsEntry* aVirtualPhrase = NULL) const; + TInt MarkStyleRegister(TDes8& aBuf, TInt aStartPara, TInt aEndPara) const; + TInt MarkRegister(TDes8& aBuf, TInt aStartPara, TInt aEndPara) const; + void GenerateAllPhraseLinksL(); + void GeneratePhraseLink(CCharFormatLayer* aPhraseCharFormatLayer, const CParaFormatLayer* aBase); + void ExternalizeItemsPresentInStyleRegisterL(RWriteStream& aStream, TInt aRefStyleCount, const TDes8& aBuf) const; + void ExternalizeItemsPresentInRegisterL(RWriteStream& aStream, TInt aParaCount, const TDes8& aBuf, const CStyleList* aStyleList) const; + CParaAttribs* SharedParaAttribs(TUint8 aOrdinal); + TUint8 RefNum(const CParaAttribs* aParaAttribs) const; + // + // Copy,Paste + void PasteStylesL(RReadStream& aStream, CStyleMap& aMap, const TRtPasteContext& aContext); + void PasteSharedFormatsL(RReadStream& aStream, CParaAttribsMap& aMap, const TRtPasteContext& aContext, CStyleMap* aStyleMap); + void ImposeCharacterStyleL(CCharFormatLayer** aCharLayer); + void PasteIxL(RReadStream& aStream, TRtPasteContext& aContext, const CParaAttribsMap& aMap, CStyleMap* aStyleMap/*,CParaAttribs* aSecondReserved*/); + TInt PasteParaIxL(RReadStream& aStream, TRtPasteContext& aContext, TInt aCompleteParaCount, const CParaAttribsMap& aMap, RPhraseAttribsEntry*& aFirstParaVirtualPhrase, CStyleMap* aStyleMap); + TParaAttribsEntry DoPasteIntoParaL(RReadStream& aStream, const CParaAttribsMap& aMap, const TRtPasteContext& aContext, CStyleMap* aStyleMap); + TParaAttribsEntry DoPasteFirstIntoParaL(RReadStream& aStream, const CParaAttribsMap& aMap, const TRtPasteContext& aContext, RPhraseAttribsEntry*& aFirstParaVirtualPhrase, CStyleMap* aStyleMap); + void DoPasteCleanup(TLogicalPosition& aNormalizePos, CParaAttribs* aReclaimed); + TTextFragment GetTextFragmentL(RReadStream& aStream); + void PastePhraseIxL(RReadStream& aStream, TRtPasteContext& aContext, const RPhraseAttribsEntry* aFirstParaVirtualPhrase); + void DoPastePhraseL(RReadStream& aStream, const TRtPasteContext& aContext, RPhraseAttribsEntry& aPhrase); + void RbPasteSharedFormatsL(TInt aRet); + void NormalizeSharedList(); + void RbRemoveInsertedParaAttribsEntries(TInt aFirstParaInsertPos, TInt aInsertedParaCount); + void RbPasteParaIxL(const TLogicalPosition& aPastePos, TInt aParaCount, TInt aRet); + void RbPastePhraseIxL(const TLogicalPosition& aPos,TInt aPhraseCount, TInt aRet); + void RbRemoveInsertedPhraseAttribsEntries(TInt aFirstPhraseInsertPos, TInt aInsertedPhraseCount); + TUint8 ReadTUint8CountL(RReadStream& aStream) const; + // + // General utility + void DoSoloInsertL(TInt aPos, TInt aLength); + void ScanToPosition(TInt aCharPos, TScanToPositionMode aMode, TLogicalPosition* aLastUsed=NULL); // Reset the logical position to the passed document position. + inline TInt PhraseCount() const; + TBool FirstPhraseOfParagraph() const; // Interrogates current iPos record. + TInt CurrentPhraseLength() const; // Encapsulates constant/specific character formatting. + TInt CurrentPhraseOffset() const; // Encapsulates constant/specific character formatting. + void CheckForUndetermined(const TCharFormatX& aFormatA, const TCharFormatX& aFormatB, TCharFormatXMask& aVaries) const; + void GetCurrentRecords(TCurrentIndexRecords& aRecord) const; + void GetPhraseFormat(TCurrentIndexRecords& aCurrent, TCharFormatX& aFormat, TCharFormatXMask& aMask, CCharFormatLayer*& aCharBase) const; + TInt OwningParagraph(TInt aPos, TLogicalPosition* aLastUsed = NULL) const; + TBool MergePhrases(TInt aPos); + TBool MergePhrases(const TLogicalPosition& aPos); + TBool DeleteInsertCharFormat(); + void ConsolidateAt(TInt aPosition, TPositionOrPhrase aPositionOrPhrase); + void RemoveFromPhraseIx(TInt aPos, TInt aCount = 1); + void SplitPhraseL(TInt aSplitPos); + void SplitPhraseL(TInt aPhraseElement, TInt aPhraseOffset, CParaAttribs* aParaAttribs); + void DoSplitPhraseL(RPhraseAttribsEntry& aCurrentPhrase, TInt aPhraseOffset, CParaAttribs* aParaAttribs); + TUint8 SharedParaAttribsEntryCountL() const; + void ModifySpecificFormatting(CParaFormatLayer& aPl, CCharFormatLayer& aCl, CParagraphStyle::TApplyParaStyleMode aMode); +// +// support for applycharformat + static void ApplyCharFormatCleanup(TAny* aPtr); + void ApplyCharFormatRollback(); + TInt MergePhrases(TInt aPhrase, RPhraseAttribsEntry& aPhraseAttribs, CParaAttribs& aParaAttribs); + void SplitPhraseL(TInt aPhrase, TInt anOffset, RPhraseAttribsEntry& aPhraseAttribs, CParaAttribs& aParaAttribs); + void Share(TParaAttribsEntry& aParaEntry, TInt aPhrase); + // + // Specific rollback + void RbInsertPicture(CParaAttribs* aGoodParaAttribs); + // + // General implementation + void NormalizeNow(const TLogicalPosition& aNormalizePos); + TBool DeleteParagraphText(TInt& aLength); + TBool DoDeleteFromParagraph(const TIndexDeleteInfo& aInfo); + void TidyAfterDelete(const TIndexDeleteInfo& aInfo); + CParaAttribs* ReserveCellL(); + CParaAttribs* ReserveCellLC(); + void DoNewInsertCharFormatL(const TCharFormatX& aFormat, + const TCharFormatXMask& aMask, CCharFormatLayer* aBasedOn, + CParaAttribs* aParaAttribs); + TInt ParaLengthFromBuffer(TDesC& aBuf) const; + inline const CStreamStore* ResolvedStreamStore(TInt aPos) const; + // + // Agenda functions + void AppendSharedFormatsL(CParaAttribsMap& aMap, const CRichTextIndex* aSource, const TGlobalLayerInfoAppend& aGlobalLayerInfo); + void AppendParaIndexL(const CRichTextIndex* aSource, const TGlobalLayerInfoAppend& aGlobalLayerInfo); + void AppendPhraseIndexL(const CRichTextIndex* aSource, const TGlobalLayerInfoAppend& aGlobalLayerInfo); + // + // Shared list management utilities + CParaAttribs* RequestReclaimShareL(CParaAttribs* aParaAttribs, TParaAttribsEntry* aParaEntry); + CParaAttribs* RequestShareL(CParaAttribs* aParaAttribs, CCharFormatLayer* aCharFormat = NULL, CParaAttribs* aReservedCell = NULL); + CParaAttribs* GetParaAttribsL(const CParaFormatLayer* aParaFormat, const CCharFormatLayer* aCharFormat, CParaAttribs* aReservedCell = NULL); + CParaAttribs* RequestShare(const TLogicalPosition& aLogicalPosition); + CParaAttribs* GetParaAttribs(const TLogicalPosition& aLogicalPosition); + CParaAttribs* GetParaAttribs(CParaAttribs* aParaAttribs, CCharFormatLayer& aCharFormatLayer); + CParaAttribs* FindSharedParaAttribs(const CParaFormatLayer& aParaFormatLayer, const CCharFormatLayer& aCharFormatLayer); + void RebalanceIndex(); + void SplitParagraphAtPastePosL(TLogicalPosition& aPastePos, TLogicalPosition& aNewPos, + const CParaFormatLayer& aGlobalParaFormatLayer); + // + inline void SetPhraseSplit(TBool aBool); + inline TBool PhraseSplit() const; +private: + const CRichText& iText; // backward reference to owning rich text. + TUint32 iFlags; + TInt iPendingNewPhrasePos; // When *INSERTSTATE* is active, this is used to place the zero-length phrase. + CParaAttribs* iRollbackParaAttribsHandle; + __MUTABLE TDblQue iSharedParaQueHead; + __MUTABLE TLogicalPosition iLastUsed; + CCharFormatLayer* iLastCharacterStyle; +public: + CArrayFixSeg* iParaIx; // One entry per paragraph + CArrayFixSeg* iPhraseIx; // One entry per phrase in the rich text + __MUTABLE TLogicalPosition iPos; + TInt iPictureCount; // a count of the number of pictures contained by this text + + __DECLARE_TEST; + }; + +//////////////////////////////////////// + +template +void CRichTextStoreMap::__DbgTestInvariant() const +// Provides class invariants. Explanations below: +// + { +#ifdef _DEBUG + TInt count = Count(); + for (TInt ii = 0; ii < count; ii++) + { + TInt ref = (*iMap)[ii].iRefNumber; + __ASSERT_DEBUG(ref > 0, User::Invariant()); + } +#endif + } + + +template +CRichTextStoreMap* CRichTextStoreMap::NewLC(TInt aMaximumCapacity) +// Return a handle to a new instance of this class. +// + { + CRichTextStoreMap* self = new(ELeave) CRichTextStoreMap(); + CleanupStack::PushL(self); + self->ConstructL(aMaximumCapacity); + return self; + } + + + +template +void CRichTextStoreMap::ConstructL(TInt aMaximumCapacity) +// +// + { + if (aMaximumCapacity > 0) + { + iMap = new(ELeave) CArrayFixFlat(aMaximumCapacity); + iMap->SetReserveL(aMaximumCapacity); // never need to allocate memory + } + iCapacity = aMaximumCapacity; + } + + +template +CRichTextStoreMap::~CRichTextStoreMap() +// +// + {delete iMap;} + + +template +void CRichTextStoreMap::Bind(TInt aRef, T* aT) +// +// + { + __TEST_INVARIANT; + __ASSERT_ALWAYS(Count() <= iCapacity, Panic(ESharedFormatsMapOverFlow)); + + TRichTextMapEntry entry(aRef, aT); + iMap->AppendL(entry); // will not fail: we have reserved the space + + __TEST_INVARIANT; + } + + + +template +void CRichTextStoreMap::Bind(T* aS, T* aT) +// +// + { + __TEST_INVARIANT; + __ASSERT_ALWAYS(Count() <= iCapacity, Panic(ESharedFormatsMapOverFlow)); + + TRichTextMapEntry entry(aS, aT); + iMap->AppendL(entry); // will not fail: we have reserved the space + + __TEST_INVARIANT; + } + + +template +T* CRichTextStoreMap::Item(TInt aRef) const +// +// + { + TInt count = Count(); + if (count > 0) + { + const TRichTextMapEntry* entry = &(*iMap)[0]; + for (const TRichTextMapEntry* end = entry + count; entry < end; entry++) + { + if (entry->iRefNumber == aRef) + return (T*)entry->iT; + } + } + return NULL; + } + + +template +T* CRichTextStoreMap::Item(const T* aS) const +// +// + { + TInt count = Count(); + if (count > 0) + { + const TRichTextMapEntry* entry = &(*iMap)[0]; + for (const TRichTextMapEntry* end = entry + count; entry < end; entry++) + { + if (entry->iS == (TAny*)aS) + return (T*)entry->iT; + } + } + return NULL; + } + + +#include "TXTINDEX.INL" + + +#endif