diff -r 000000000000 -r 1fb32624e06b textrendering/texthandling/stext/TXTGLOBL.CPP --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/textrendering/texthandling/stext/TXTGLOBL.CPP Tue Feb 02 02:02:46 2010 +0200 @@ -0,0 +1,325 @@ +/* +* Copyright (c) 2003-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: +* +*/ + + +#include +#include +#include + +#include "TXTFMLYR.H" +#include "TXTGLOBL.H" + +#include "TXTSTD.H" + +/** +@internalAll +*/ +EXPORT_C void MLayDoc::MLayDoc_Reserved_1() {} +EXPORT_C void CGlobalText::__DbgTestInvariant()const +// Class Invariants. +// + { +#ifdef _DEBUG +// ASSERT: The global format layers are never null. + __ASSERT_DEBUG(iGlobalParaFormatLayer!=NULL,User::Invariant()); + __ASSERT_DEBUG(iGlobalCharFormatLayer!=NULL,User::Invariant()); +#endif + } + + +EXPORT_C CGlobalText* CGlobalText::NewL(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer, + TDocumentStorage aStorage,TInt aDefaultTextGranularity) +/** Allocates and constructs an empty global text object with a paragraph and a +character format layer. A single end-of-document delimiter is inserted. + +@param aGlobalParaLayer Pointer to the paragraph format layer referenced by +the text object. Must not be NULL, or a panic occurs. +@param aGlobalCharLayer Pointer to the character format layer referenced by +the text object. Must not be NULL, or a panic occurs. +@param aStorage The type of in-memory buffer to use. Defaults to +ESegmentedStorage. +@param aDefaultTextGranularity Specifies the granularity of the in-memory buffer. +Default is EDefaultTextGranularity bytes (=256). +@return Pointer to the global text object. */ + { + __ASSERT_ALWAYS(aGlobalParaLayer!=NULL,Panic(ENullFormatLayerHandle)); + __ASSERT_ALWAYS(aGlobalCharLayer!=NULL,Panic(ENullFormatLayerHandle)); + + CGlobalText* self=new(ELeave) CGlobalText(aGlobalParaLayer,aGlobalCharLayer); + CleanupStack::PushL(self); + self->ConstructL(aStorage,aDefaultTextGranularity); + CleanupStack::Pop(); + return self; + } + +EXPORT_C CGlobalText* CGlobalText::NewL(const CStreamStore& aStore,TStreamId aStreamId, + const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer, + MTextFieldFactory* aFactory, + TDocumentStorage aStorage) +/** Returns a handle to a new instance of this class, whose textual content is +restored from the specified read-stream. The global text object *uses* (does +not own) the supplied global format layers.*/ + { + __ASSERT_ALWAYS(aGlobalParaLayer!=NULL,Panic(ENullFormatLayerHandle)); + __ASSERT_ALWAYS(aGlobalCharLayer!=NULL,Panic(ENullFormatLayerHandle)); + + CGlobalText* self=new(ELeave) CGlobalText(aGlobalParaLayer,aGlobalCharLayer); + CleanupStack::PushL(self); + self->ConstructL(aStore,aStreamId,aFactory,aStorage); + CleanupStack::Pop(); + return self; + } + + +EXPORT_C CGlobalText::CGlobalText() + {} + + +EXPORT_C CGlobalText::CGlobalText(const CParaFormatLayer* aGlobalParaLayer,const CCharFormatLayer* aGlobalCharLayer): + iGlobalParaFormatLayer(aGlobalParaLayer), + iGlobalCharFormatLayer(aGlobalCharLayer) + { + __TEST_INVARIANT; + } + +EXPORT_C CGlobalText::~CGlobalText() +/** The destructor is empty, and is present only to cause the virtual function +table to be defined in a unique module. */ + {} + +EXPORT_C void CGlobalText::SetGlobalParaFormat(const CParaFormatLayer* aParaFormatLayer) +/** Replaces the paragraph format layer referenced by the global text object. + +@param aParaFormatLayer Pointer to the paragraph format layer to be referenced +by the global text object. */ + { + iGlobalParaFormatLayer=aParaFormatLayer; + CEditableText::SetHasChanged(ETrue); + + __TEST_INVARIANT; + } + +EXPORT_C void CGlobalText::SetGlobalCharFormat(const CCharFormatLayer* aCharFormatLayer) +/** Replaces the character format layer referenced by the global text object. + +@param aCharFormatLayer Pointer to the character format layer to be referenced +by the global text object. */ + { + iGlobalCharFormatLayer=aCharFormatLayer; + CEditableText::SetHasChanged(ETrue); + + __TEST_INVARIANT; + } + + +EXPORT_C void CGlobalText::ApplyParaFormatL(const CParaFormat* aFormat,const TParaFormatMask& aMask, + TInt /*aPos*/,TInt /*aLength*/) +/** Changes the text object's paragraph formatting. The attributes which are +set in the mask are read from aFormat into the text object's paragraph format +layer. The attributes which are not set in the mask are not changed. Note +that the position and length arguments are only used in the rich text +implementation of this function. + +@param aFormat Contains the paragraph format attribute values to apply. +@param aMask Bitmask specifying the paragraph format attributes to change. +@param aPos This argument is not used for global text. +@param aLength This argument is not used for global text. */ + { + + __TEST_INVARIANT; + + TParaFormatMask applyMask=aMask; + CParaFormat* pf=CParaFormat::NewL(*aFormat); + CleanupStack::PushL(pf); + iGlobalParaFormatLayer->SenseL(pf,applyMask); + CONST_CAST(CParaFormatLayer*,iGlobalParaFormatLayer)->SetL(pf,applyMask); + CleanupStack::PopAndDestroy(); // pf + CEditableText::SetHasChanged(ETrue); + + __TEST_INVARIANT; + } + +EXPORT_C void CGlobalText::ApplyCharFormatL(const TCharFormat& aFormat,const TCharFormatMask& aMask, + TInt /*aPos*/,TInt /*aLength*/) +/** Changes the text object's character formatting. The attributes which are +set in the mask are read from aFormat into the text object's character format +layer. The attributes which are not set in the mask are not changed. Note +that the position and length arguments are only used in the rich text +implementation of this function. + +@param aFormat Contains the character format attribute values to apply. +@param aMask Bitmask specifying the character format attributes to change. +@param aPos This argument is not used for global text. +@param aLength This argument is not used for global text. */ + { + + __TEST_INVARIANT; + + TCharFormatMask applyMask=aMask; + TCharFormat cf(aFormat); + iGlobalCharFormatLayer->Sense(cf,applyMask); + (CONST_CAST(CCharFormatLayer*,iGlobalCharFormatLayer))->SetL(cf,applyMask); + CEditableText::SetHasChanged(ETrue); + + __TEST_INVARIANT; + } + +EXPORT_C TInt CGlobalText::LdDocumentLength()const +/** Gets the the number of characters in the document. + +Note: the count includes all non-printing characters but excludes the end +of text paragraph delimiter, so that the smallest return value is always zero. + +@return The number of characters contained in the document. */ + { + __TEST_INVARIANT; + + return CPlainText::DocumentLength(); + } + +EXPORT_C TInt CGlobalText::LdToParagraphStart(TInt& aCurrentPos)const +/** Gets the document position of the start of the paragraph containing a +specified document position. + +@param aCurrentPos Specifies a document position: must be valid or a panic +occurs. On return, specifies the document position of the first character +in the paragraph in which it is located. +@return The number of characters skipped in scanning to the start of the +paragraph. */ + { + __TEST_INVARIANT; + + return CPlainText::ToParagraphStart(aCurrentPos); + } + +EXPORT_C TBool CGlobalText::EnquirePageBreak(TInt aPos,TInt aLength)const +/** Tests whether a page break occurs within a range of characters. Returns +false if no page table has been set up: see CPlainText::SetPageTable(). The +start and end of the range must be valid document positions, or a panic occurs. + +@param aPos The document position from which to begin searching for a page +break. +@param aLength The number of characters to search for a page break, beginning +at aPos. The default is zero. +@return ETrue if a page break occurs within the specified range, otherwise +EFalse. */ + { + __TEST_INVARIANT; + + return PageContainingPos(aPos+aLength)>PageContainingPos(aPos); + } + +EXPORT_C void CGlobalText::GetChars(TPtrC& aView,TCharFormat& aFormat,TInt aStartPos)const +/** Gets a constant pointer descriptor to a portion of the text object. The +portion starts at document position aStartPos, and ends at the end of the +document, or the end of the segment, if segmented storage is being used. Also +fills a character format object with the text object's effective character +formatting. The start position must be valid, or a panic occurs. + +@param aView On return, a constant pointer to a portion of the text. +@param aFormat On return, contains the text object's effective character +formatting. +@param aStartPos The start position for the view. */ + { + __ASSERT_ALWAYS(aStartPos>=0 && aStartPos<=DocumentLength(),Panic(ECharPosBeyondDocument)); + + aView.Set(Read(aStartPos)); + iGlobalCharFormatLayer->SenseEffective(aFormat); + OverrideFormatOfInlineTextIfApplicable(aView,aFormat,aStartPos); + } + +EXPORT_C void CGlobalText::GetParagraphFormatL(CParaFormat* aFormat,TInt /*aPos*/) const +/** Gets the text object's effective paragraph formatting. The aPos value is +only used in the rich text implementation of this function. + +@param aFormat On return, filled with the text object's effective paragraph +formatting. +@param aPos This argument is not used for global text. */ + { + // Get the paragraph format. Global text has a single unvarying character format so aPos is ignored. + iGlobalParaFormatLayer->SenseEffectiveL(aFormat); + } + + +EXPORT_C void CGlobalText::GetParaFormatL(CParaFormat* aFormat,TParaFormatMask& aVaries,TInt /*aPos*/,TInt /*aLength*/, + CParaFormat::TParaFormatGetMode aMode) const +/** Gets the the global text object's effective paragraph formatting. Note that +the position and length arguments are only used in the rich text implementation +of this function. + +@param aFormat Must not be NULL or a panic occurs. On return, contains the +effective paragraph formatting for the global text object. +@param aVaries On return, a bitmask indicating which paragraph format attributes +vary over the range of characters selected. This is only relevant for rich +text, so for global text returns a value of zero for all attributes. +@param aPos This argument is not used for global text. +@param aLength This argument is not used for global text. +@param aMode The default, EAllAttributes indicates that values for all paragraph +format attributes are written to aFormat. EFixedAttributes indicates that +tabs, bullets and borders are not written to aFormat. */ + { + iGlobalParaFormatLayer->SenseEffectiveL(aFormat,aMode); + aVaries.ClearAll(); + } + + + +EXPORT_C void CGlobalText::GetCharFormat(TCharFormat& aFormat,TCharFormatMask& aVaries, + TInt /*aPos*/,TInt /*aLength*/) const +/** Gets the global text object's effective character formatting. Note that the +last three arguments are not relevant to the global text implementation of +this function. + +@param aFormat On return, contains the effective character formatting for +the global text object. +@param aVaries On return, a bitmask indicating which character format attributes +vary over the range of characters selected. This is only relevant for rich +text, so for global text returns a value of zero for all attributes. +@param aPos This argument is not used for global text. +@param aLength This argument is not used for global text. */ + { + iGlobalCharFormatLayer->SenseEffective(aFormat); + aVaries.ClearAll(); + } + +EXPORT_C CPicture* CGlobalText::PictureHandleL(TInt /*aPos*/,MLayDoc::TForcePictureLoad /*aForceLoad*/) const +/** Global text provides no support for pictures, so this implementation +of the function returns NULL. */ + { + // Global text provides no support for pictures. + return NULL; + } + +EXPORT_C TInt CGlobalText::GetPictureSizeInTwips(TSize& /*aSize*/, TInt /*aPos*/) const +/** Global text provides no support for pictures, so this implementation +of the function returns KErrNotFound. */ + { + // Global text provides no support for pictures. + return KErrNotFound; + } + +EXPORT_C TBool CGlobalText::SelectParagraphLabel(TInt /*aPos*/) +/** Global text does not support paragraph labels, so this function +returns EFalse. */ + { + return EFalse; + } + +EXPORT_C void CGlobalText::CancelSelectLabel() +/** Not supported. */ + { + }