1 // Copyright (c) 1998-2010 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 //#include <textbase.h>

    17 #include <openfont.h>

    18 #include "GlyphSel.h"

    19 #include "FontThai.h"

    20 #include "FontArabic.h"

    21 #include "FontIndic.h"

    22 #include "TextBasePanic.h"

    23 #include "glyphsample.h"

    24 #include "gdiinline.inl"

    25 //#include "gdistructs.h"

    26 //#include "gdiconsts.h"

    27 #include <graphics/gdi/gdistructs.h>

    28 #include <graphics/gdi/gdiconsts.h>

    29 #include "gdiplatapi.h"

    30 

    31 /**

    32  Names holds the types & data associated with the glyph selection

    33  algorithm in CFont::GetCharacterPosition().

    34 @internalComponent

    35 */

    36 namespace GlyphSelection

    37     {

    38 

    39     typedef TBool (*ProcessFunc)(TGlyphSelectionState& aGss, RShapeInfo&);

    40 

    41     /**

    42      This structure defines the fields present in each row of the GlyphTable

    43      datat table below. 

    44     @internalComponent

    45     */

    46     struct TTableEntry 

    47     	{

    48     	TUint            iLow;

    49     	TUint            iHigh;

    50     	ProcessFunc	 iProcessFunc;

    51     	};

    52 

    53     /**

    54      This table encodes the Unicode character ranges and the glyph selector

    55      classes to be used for each character range when processing characters

    56      into glyph clusters in CFont::GetCharacterPosition().

    57      New glyph selection classes must make sure they are listed in this 

    58      table to ensure they are invoked as required.

    59      A '0' iProcessFunc entry tells the algorithm to skip the character.

    60     @internalComponent

    61     */

    62     static const TTableEntry Table[] =

    63     	{

    64     	//    iLow,     iHigh,    iProcessFunc

    65     		{ 0x0000,   0x00AC,   GlyphSelector_Default::Process},

    66     		{ 0x00AD,   0x00AD,   GlyphSelector_SoftHyphen::Process},

    67     		{ 0x00AE,   0x05FF,   GlyphSelector_Default::Process},

    68     		{ 0x0600,   0x06FF,   GlyphSelector_Arabic::Process},

    69     		{ 0x0700,   0x08FF,   GlyphSelector_Default::Process},

    70     		{ 0x0900,   0x0970,   GlyphSelector_Devanagari::Process},

    71     		{ 0x0980,   0x09FF,   GlyphSelector_Bengali::Process},

    72     		{ 0x0A00,   0x0A7F,   GlyphSelector_Gurmukhi::Process},

    73     		{ 0x0A80,   0x0AFF,   GlyphSelector_Gujarati::Process},

    74     		{ 0x0B80,   0x0BFF,   GlyphSelector_Tamil::Process},

    75     		{ 0x0C00,	0x0C7F,   GlyphSelector_Telugu::Process},

    76     		{ 0x0C80,	0x0CFF,   GlyphSelector_Kannada::Process},

    77     		{ 0x0D00,   0x0D7F,   GlyphSelector_Malayalam::Process},    		

    78     		{ 0x0D80,   0x0DFF,   GlyphSelector_Default::Process},

    79     		{ 0x0E00,   0x0E32,   GlyphSelector_Thai::Process},

    80     		{ 0x0E33,   0x0E33,   GlyphSelector_ThaiSaraAm::Process},

    81     		{ 0x0E34,   0x0E7F,   GlyphSelector_Thai::Process},

    82     		{ 0x0E80,   0x200B,   GlyphSelector_Default::Process},

    83     		{ 0x200C,   0x200F,   0},

    84     		{ 0x2010,   0x2029,   GlyphSelector_Default::Process},

    85     		{ 0x202A,   0x202E,   0},

    86     		{ 0x202F,   0xFFFD,   GlyphSelector_Default::Process},

    87     		{ 0xFFFE,   0xFFFF,   0},

    88     		{ 0x10000,	0x10FFFF, GlyphSelector_Default::Process},

    89     		{0xFFFFFFFF,0xFFFFFFFF, 0}

    90     	};

    91     }

    92 

    93 /** Find appropriate processor function for the given character.

    94 @param aChar Character for processing.

    95 @return processor function or 0 if the character is to be skipped.

    96 @internalComponent */

    97 GlyphSelection::ProcessFunc CharacterToProcessFunction(TInt aChar)

    98 	{

    99 	for (const GlyphSelection::TTableEntry* glyphSel = GlyphSelection::Table;

   100 		glyphSel->iLow != 0xFFFFFFFF; glyphSel++)

   101 		{

   102 		if ((glyphSel->iLow <= aChar) && (aChar <= glyphSel->iHigh))

   103 			return glyphSel->iProcessFunc;

   104 		}

   105 	return 0;

   106 	}

   107 

   108 /**

   109 @internalTechnology For use by TFontStyle/TOpenFontSpec.

   110 */

   111 EXPORT_C TBool FontEffect::IsEffectOn(TEffect aEffect, TUint32 aFontEffect)

   112 	{

   113 	return aEffect & aFontEffect;

   114 	}

   115 

   116 /**

   117 @internalTechnology For use by TFontStyle/TOpenFontSpec.

   118 */

   119 EXPORT_C void FontEffect::SetEffect(TEffect aEffect, TBool aOn, TUint32& aFontEffect)

   120 	{

   121 	if (aOn)

   122 		aFontEffect |= aEffect;

   123 	else

   124 		aFontEffect &= ~aEffect;

   125 	}

   126 

   127 

   128 //

   129 // TFontStyle

   130 //

   131 

   132 /** Default C++ constructor. */

   133 EXPORT_C TFontStyle::TFontStyle():

   134 	iFlags(0), iReserved1(0), iReserved2(0)

   135 	{}

   136 

   137 

   138 /** Constructs a TFontStyle object with the specified attributes.

   139 @param aPost The posture attribute. 

   140 @param aStrWgt The stroke weight attribute. 

   141 @param aPrintPos The print position attribute. */

   142 EXPORT_C TFontStyle::TFontStyle(TFontPosture aPostr,TFontStrokeWeight aWgt,TFontPrintPosition aPos):

   143 	iFlags(0), iReserved1(0), iReserved2(0)

   144 	{

   145 	if (aPostr == EPostureItalic)

   146 		{

   147 		iFlags |= EItalic;

   148 		}

   149 	if (aWgt == EStrokeWeightBold)

   150 		{

   151 		iFlags |= EBold;

   152 		}

   153 	if (aPos == EPrintPosSuperscript)

   154 		{

   155 		iFlags |= ESuper;

   156 		}

   157 	else if (aPos == EPrintPosSubscript)

   158 		{

   159 		iFlags |= ESub;

   160 		}

   161 	}

   162 

   163 

   164 EXPORT_C void TFontStyle::InternalizeL(RReadStream& aStream)

   165 /** Internalises a font style from a read stream.

   166 

   167 The presence of this function means that the standard templated operator>>() 

   168 (defined in s32strm.h) is available to internalise objects of this class.

   169 

   170 @param aStream The stream from which the font style is to be internalised 

   171 @leave KErrNoMemory If there is a problem reading from the stream.

   172 If internalisation causes an out of memory error. */

   173 	{

   174 	iFlags = aStream.ReadUint32L();

   175 	}

   176 

   177 

   178 EXPORT_C void TFontStyle::ExternalizeL(RWriteStream& aStream) const

   179 /** Externalises the font style to a write stream.

   180 

   181 The presence of this function means that the standard templated operator<<() 

   182 (defined in s32strm.h) is available to externalise objects of this class.

   183 

   184 @param aStream The stream to which the font style is to be externalised.

   185 @leave KErrNoMemory This function may leave, if the write action causes the 

   186 stream's resources to be exhausted. */

   187 	{

   188 	aStream.WriteUint32L(iFlags);

   189 	}

   190 

   191 

   192 EXPORT_C TFontPosture TFontStyle::Posture() const

   193 /** Gets the posture attribute.

   194 

   195 @return The font style's posture. */

   196 	{

   197 	if(iFlags&EItalic) return(EPostureItalic);

   198 	return(EPostureUpright);

   199 	}

   200 

   201 

   202 EXPORT_C TFontStrokeWeight TFontStyle::StrokeWeight() const

   203 /** Gets the stroke weight attribute.

   204 

   205 @return The font style's stroke weight. */

   206 	{

   207 	if(iFlags&EBold) return(EStrokeWeightBold);

   208 	return(EStrokeWeightNormal);

   209 	}

   210 

   211 

   212 EXPORT_C TFontPrintPosition TFontStyle::PrintPosition() const

   213 /** Gets the print position attribute.

   214 

   215 @return The font style's print position. */

   216 	{

   217 	if((iFlags&ESuper) && !(iFlags&ESub)) return(EPrintPosSuperscript);

   218 	else if((iFlags&ESub) && !(iFlags&ESuper)) return(EPrintPosSubscript);

   219 	return(EPrintPosNormal);

   220 	}

   221 

   222 

   223 EXPORT_C void TFontStyle::SetPosture(TFontPosture aPosture)

   224 /** Sets the posture attribute.

   225 

   226 @param aPosture The posture to be set. */

   227 	{

   228 	if(aPosture==EPostureItalic) iFlags|=EItalic;

   229 	else iFlags&=~EItalic;

   230 	}

   231 

   232 

   233 EXPORT_C void TFontStyle::SetStrokeWeight(TFontStrokeWeight aStrokeWeight)

   234 /** Sets the stroke weight attribute.

   235 

   236 @param aStrokeWeight The stroke weight to be set. */

   237 	{

   238 	if(aStrokeWeight==EStrokeWeightBold) iFlags|=EBold;

   239 	else iFlags&=~EBold;

   240 	}

   241 

   242 

   243 EXPORT_C void TFontStyle::SetPrintPosition(TFontPrintPosition aPrintPosition)

   244 /** Sets the print position attribute.

   245 

   246 @param aPrintPosition The print position to be set. */

   247 	{

   248 	switch(aPrintPosition)

   249 		{

   250 		case EPrintPosSuperscript:

   251 			{

   252 			iFlags|=ESuper;

   253 			iFlags&=~ESub;

   254 			break;

   255 			}

   256 		case EPrintPosSubscript:

   257 			{

   258 			iFlags&=~ESuper;

   259 			iFlags|=ESub;

   260 			break;

   261 			}

   262 		default:

   263 			{

   264 			iFlags&=~ESuper;

   265 			iFlags&=~ESub;

   266 			}

   267 	 	}

   268 	}

   269 

   270 /** Gets the font effects flags.

   271 @publishedAll

   272 @released

   273 @return The font effects flags.

   274 @see TFontStyle::SetEffects()

   275 */

   276 EXPORT_C TUint32 TFontStyle::Effects() const

   277 	{

   278 	return 0xFFF0 & iFlags;

   279 	}

   280 

   281 /** Checks if a font effect is on.

   282 @publishedAll

   283 @released

   284 @return True represents the specified font effect is on, otherwise off.

   285 @param aEffect The font effect to be checked.

   286 @see TFontStyle::SetEffects()

   287 */

   288 EXPORT_C TBool TFontStyle::IsEffectOn(FontEffect::TEffect aEffect) const

   289 	{

   290 	return FontEffect::IsEffectOn(aEffect, iFlags);

   291 	}

   292 

   293 /** Sets the font effects flags.

   294 @publishedAll

   295 @released

   296 @param aEffect The font effects flags to be set.

   297 @see TFontStyle::Effects()

   298 */

   299 EXPORT_C void TFontStyle::SetEffects(TUint32 aEffects)

   300 	{

   301 	iFlags &= 0xFFFF000F;

   302 	iFlags |= 0xFFF0 & aEffects;

   303 	}

   304 

   305 /** Sets a font effect to the given state.

   306 @publishedAll

   307 @released

   308 @param aEffect The font effect to be set.

   309 @param aOn True represents on, otherwise off.

   310 @see TFontStyle::IsEffectOn()

   311 */

   312 EXPORT_C void TFontStyle::SetEffects(FontEffect::TEffect aEffect, TBool aOn)

   313 	{

   314 	FontEffect::SetEffect(aEffect, aOn, iFlags);

   315 	}

   316 

   317 /** Compares a font style for equality.

   318 @publishedAll

   319 @released

   320 @param aFontStyle The font style to be compared with this font style.

   321 @return ETrue, if this TFontStyle is equal to aFontStyle, EFalse, otherwise.

   322 */

   323 EXPORT_C TBool TFontStyle::operator==(const TFontStyle& aFontStyle) const

   324 	{

   325 	return iFlags == aFontStyle.iFlags;

   326 	}

   327 

   328 //

   329 // TFontSpec

   330 //

   331 EXPORT_C TFontSpec::TFontSpec():

   332 	iTypeface(),

   333 	iHeight(0),

   334 	iFontStyle()

   335 /** Default constructor.

   336 

   337 The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 

   338 and EPrintPosNormal. */

   339 	{}

   340 

   341 

   342 EXPORT_C TFontSpec::TFontSpec(const TDesC& aTypefaceName,TInt aHeight):

   343 	iTypeface(),

   344 	iHeight(aHeight),

   345 	iFontStyle(EPostureUpright,EStrokeWeightNormal,EPrintPosNormal)

   346 /** Constructs a TFontSpec object with the specified typeface and height. 

   347 

   348 The object's font style is set to the default: EPostureUpright, EStrokeWeightNormal, 

   349 and EPrintPosNormal.

   350 

   351 @param aTypefaceName The name of the typeface (e.g. "Roman"). It should be no

   352 	longer than KMaxTypefaceNameLength characters in length.

   353 @param aHeight The height of the typeface, in twips. 

   354 @panic GDI 6, if aTypefaceName is more than KMaxTypefaceNameLength characters long.

   355 */

   356 	{

   357 	iTypeface.SetName(aTypefaceName);

   358 	}

   359 

   360 

   361 EXPORT_C TBool TFontSpec::operator==(const TFontSpec& aFontSpec) const

   362 /** Compares this font specification with another.

   363 @param aFontSpec The font specification to be compared with this one. 

   364 @return ETrue, if the TFontSpecs are identical, EFalse otherwise.

   365 */

   366 	{

   367 	return

   368 		iHeight		== aFontSpec.iHeight &&

   369 		iFontStyle	== aFontSpec.iFontStyle &&

   370 		iTypeface	== aFontSpec.iTypeface;

   371 	}

   372 

   373 

   374 EXPORT_C void TFontSpec::InternalizeL(RReadStream& aStream)

   375 /** Internalises a font specification from a read stream.

   376 

   377 The presence of this function means that the standard templated operator>>() 

   378 (defined in s32strm.h) is available to internalise objects of this class.

   379 

   380 @param aStream The stream from which the font specification is to be internalised.

   381 @leave KErrNoMemory If internalisation causes an out of memory error. */

   382 	{

   383 	iTypeface.InternalizeL(aStream);

   384 	iHeight=aStream.ReadUint16L();

   385 	iFontStyle.InternalizeL(aStream);

   386 	}

   387 

   388 

   389 EXPORT_C void TFontSpec::ExternalizeL(RWriteStream& aStream) const

   390 /** Externalises the font specification to a write stream.

   391 

   392 The presence of this function means that the standard templated operator<<() 

   393 (defined in s32strm.h) is available to externalise objects of this class.

   394 

   395 @param aStream The stream to which the font specification is to be externalised 

   396 

   397 @leave KErrNoMemory If the write action causes the stream's resources to be 

   398 exhausted. */

   399 	{

   400 	iTypeface.ExternalizeL(aStream);

   401 	aStream.WriteUint16L(iHeight);

   402 	iFontStyle.ExternalizeL(aStream);

   403 	}

   404 

   405 EXPORT_C void TFontSpec::SetScriptTypeForMetrics(TLanguage aLanguage)

   406 /** Specifies the script with which font metrics calculation will be based on.

   407 @param aLanguage The language used to derive the required script.

   408 @publishedAll

   409 @released

   410 */

   411 	{

   412 	iTypeface.SetScriptTypeForMetrics(aLanguage);

   413 	}

   414 

   415 EXPORT_C TInt TFontSpec::ScriptTypeForMetrics() const

   416 /** Returns the script with which font metrics calculation will be based on.

   417 @internalTechnology

   418 */

   419 	{

   420 	return iTypeface.ScriptTypeForMetrics();

   421 	}

   422 

   423 //

   424 // TTypeface

   425 //

   426 static const TInt KTTypefaceBitsNumAttrib = 3;

   427 static const TInt KTTypefaceBitsNumScript = 4;

   428 static const TInt KTTypefaceMaskAttrib = (1 << KTTypefaceBitsNumAttrib) - 1;

   429 static const TInt KTTypefaceMaskScript = ((1 << KTTypefaceBitsNumScript) - 1) << KTTypefaceBitsNumAttrib;

   430 EXPORT_C TTypeface::TTypeface():

   431 	iName(),

   432 	iFlags(0)

   433 /** Default C++ constructor. */

   434 	{}

   435 

   436 /**

   437 @internalComponent

   438 */

   439 void TTypeface::ResetAttributes()

   440 	{

   441 	iFlags &= KTTypefaceMaskScript;

   442 	}

   443 

   444 /**

   445 @internalComponent

   446 */

   447 void TTypeface::ResetScriptType()

   448 	{

   449 	iFlags &= KTTypefaceMaskAttrib;

   450 	}

   451 

   452 EXPORT_C void TTypeface::InternalizeL(RReadStream& aStream)

   453 /** Internalises a typeface from a read stream. 

   454 

   455 The presence of this function means that the standard templated operator>>() 

   456 (defined in s32strm.h) is available to internalise objects of this class.

   457 

   458 @param aStream Stream from which the typeface is to be internalised. */

   459 	{

   460 	TBuf<KMaxTypefaceNameLength> tempname;

   461 	aStream >> tempname;

   462 	new(&iName) TBufC<KMaxTypefaceNameLength>(tempname);

   463 	iFlags = aStream.ReadInt8L();

   464 	}

   465 

   466 

   467 EXPORT_C void TTypeface::ExternalizeL(RWriteStream& aStream) const

   468 /** Externalises a typeface to a write stream. 

   469 

   470 The presence of this function means that the standard templated operator<<() 

   471 (defined in s32strm.h) is available to externalise objects of this class.

   472 

   473 @param aStream The stream to which the typeface is to be externalised. */

   474 	{

   475 	aStream << iName;

   476 	aStream.WriteInt8L(static_cast<TInt8>(iFlags));

   477 	}

   478 

   479 

   480 EXPORT_C TBool TTypeface::operator==(const TTypeface& aTypeface) const

   481 /** Compares two typefaces for equality.

   482 

   483 @param aTypeface The typeface to be compared with. 

   484 @return ETrue, if this TTypeface is equal to aTypeface, otherwise EFalse. */

   485 	{

   486 	return

   487 		iFlags == aTypeface.iFlags &&

   488 		iName == aTypeface.iName;

   489 	}

   490 

   491 EXPORT_C void TTypeface::SetAttributes(TInt aAttributes)

   492 /** Set the combination of attributes for this typeface.

   493 

   494 @param aAttributes A bitmap defining the combination of attributes. */

   495 	{

   496 	ResetAttributes();

   497 	iFlags |= KTTypefaceMaskAttrib & aAttributes & (EProportional | ESerif | ESymbol);

   498 	}

   499 

   500 

   501 EXPORT_C void TTypeface::SetIsProportional(TBool aIsProportional)

   502 /** Sets the typeface's proportional attribute.

   503 

   504 @param aIsProportional ETrue if the typeface is a proportional typeface, otherwise 

   505 EFalse. */

   506 	{

   507 	if (aIsProportional)

   508 		{

   509 		iFlags |= EProportional;

   510 		}

   511 	else

   512 		{

   513 		iFlags &= ~EProportional;

   514 		}

   515 	}

   516 

   517 

   518 EXPORT_C void TTypeface::SetIsSerif(TBool aIsSerif)

   519 /** Sets the typeface's serif attribute.

   520 

   521 @param aIsSerif ETrue if the typeface is a serif typeface, otherwise EFalse. */

   522 	{

   523 	if (aIsSerif)

   524 		{

   525 		iFlags |= ESerif;

   526 		}

   527 	else

   528 		{

   529 		iFlags &= ~ESerif;

   530 		}

   531 	}

   532 

   533 

   534 EXPORT_C void TTypeface::SetIsSymbol(TBool aIsSymbol)

   535 /** Sets the typeface's symbol attribute.

   536 

   537 @param aIsSymbol ETrue if the typeface is a symbol typeface, otherwise EFalse. */

   538 	{

   539 	if (aIsSymbol)

   540 		{

   541 		iFlags |= ESymbol;

   542 		}

   543 	else

   544 		{

   545 		iFlags &= ~ESymbol;

   546 		}

   547 	}

   548 

   549 

   550 EXPORT_C TInt TTypeface::Attributes() const

   551 /** Gets the combination of attributes of the typeface.

   552 

   553 @return The combination of attributes of the typeface. */

   554 	{

   555 	return KTTypefaceMaskAttrib & iFlags;

   556 	}

   557 

   558 

   559 EXPORT_C TBool TTypeface::IsProportional() const

   560 /** Gets the typeface's proportional attribute.

   561 

   562 @return ETrue if the typeface is proportional, EFalse otherwise. */

   563 	{

   564 	return KTTypefaceMaskAttrib & iFlags & EProportional;

   565 	}

   566 

   567 

   568 EXPORT_C TBool TTypeface::IsSerif() const

   569 /** Gets the typeface's serif attribute.

   570 

   571 @return ETrue if the typeface is a serif typeface, EFalse otherwise */

   572 	{

   573 	return KTTypefaceMaskAttrib & iFlags & ESerif;

   574 	}

   575 

   576 

   577 EXPORT_C TBool TTypeface::IsSymbol() const

   578 /** Gets the typeface's symbol attribute.

   579 

   580 @return ETrue if the typeface is a symbol typeface, EFalse otherwise */

   581 	{

   582 	return KTTypefaceMaskAttrib & iFlags & ESymbol;

   583 	}

   584 

   585 

   586 /** Specifies the script with which font metrics calculation will be based on.

   587 @param aLanguage The language used to derive the required script.

   588 @internalTechnology

   589 */

   590 EXPORT_C void TTypeface::SetScriptTypeForMetrics(TLanguage aLanguage)

   591 	{

   592 	SetScriptTypeForMetrics(GlyphSample::TLanguage2TScript(aLanguage));

   593 	}

   594 

   595 /** Specifies the script with which font metrics calculation will be based on.

   596 @param aScript The script.

   597 @internalTechnology

   598 */

   599 EXPORT_C void TTypeface::SetScriptTypeForMetrics(TInt aScript)

   600 	{

   601 	ResetScriptType();

   602 	iFlags |= KTTypefaceMaskScript & (aScript << KTTypefaceBitsNumAttrib);

   603 	}

   604 

   605 /** Gets the script with which font metrics calculation will be based on.

   606 @return The script.

   607 @internalTechnology

   608 */

   609 EXPORT_C TInt TTypeface::ScriptTypeForMetrics() const

   610 	{

   611 	return (KTTypefaceMaskScript & iFlags) >> KTTypefaceBitsNumAttrib;

   612 	}

   613 

   614 /**

   615 Sets the name of the typeface. This method should be used rather than

   616 directly accessing the iName public member.

   617 @param aName The name of the typeface (e.g. "Roman"). It should be no 

   618 	longer than KMaxTypefaceNameLength characters in length.

   619 @panic GDI 6, if aName is more than KMaxTypefaceNameLength characters

   620 	long.

   621 */

   622 EXPORT_C void TTypeface::SetName(const TDesC& aName)

   623 	{

   624     TEXTBASE_ASSERT_ALWAYS(aName.Length() <= KMaxTypefaceNameLength, ETextBasePanic_TypefaceNameOverflow);

   625 	iName=aName;

   626 	}

   627 

   628 /**

   629 Returns the name of the typeface.

   630 @return The name of the typeface.

   631 */

   632 EXPORT_C const TDesC& TTypeface::Name() const

   633 	{

   634 	return iName;

   635 	}

   636 

   637 

   638 //

   639 // CFont

   640 //

   641 

   642 /** Default destructor. */

   643 EXPORT_C CFont::~CFont()

   644 	{}

   645 

   646 _LIT(KGdiZeroCharacter,"0");

   647 

   648 /** Gets the width of the zero character of this font in pixels. 

   649 

   650 This function is provided as the "0" character is roughly the average width 

   651 of the characters of any font.

   652 

   653 @return The width of the "0" character, in pixels. */

   654 EXPORT_C TInt CFont::WidthZeroInPixels() const

   655 	{

   656 	return(TextWidthInPixels(KGdiZeroCharacter));

   657 	}

   658 

   659 

   660 /** Gets the font descent in pixels.

   661 It is defined to be HeightInPixels() minus AscentInPixels().

   662 Note that this deprecated function is replaced by the new @c FontMaxDescent()

   663 or in some cases @c FontStandardDescent().

   664 

   665 @return The font descent in pixels.

   666 @see FontStandardDescent() 

   667 @see FontMaxDescent()

   668 @deprecated */

   669 EXPORT_C TInt CFont::DoDescentInPixels() const

   670 	{

   671 	return HeightInPixels() - AscentInPixels();

   672 	}

   673 

   674 

   675 /** Checks to see if the pen position needs to be included in the bounds

   676 calculation for purposes of considering side-bearings in the line break point

   677 

   678 @param aInput The input block. Contains the check flag and maxbounds.

   679 @param aPenPos The current value of the pen position.

   680 @param aBoundsBR Bottom-right bounds value.

   681 @param aBoundsTL Top-left bounds value.

   682 @return Whether or not MaxBounds has been exceeded

   683 */

   684 LOCAL_C TBool BoundsExceeded(const CFont::TMeasureTextInput& aInput,

   685 	const TInt& aPenPos, TInt& aBoundsBR, TInt& aBoundsTL)

   686 	{

   687 	if (aInput.iFlags & CFont::TMeasureTextInput::EFIncludePenPositionInBoundsCheck)

   688 		{

   689 		if (aInput.iFlags & CFont::TMeasureTextInput::EFVisualOrderRightToLeft)

   690 			{

   691 			aBoundsTL = Min(aBoundsTL, aPenPos);

   692 			}

   693 		else

   694 			{

   695 		 	aBoundsBR = Max(aBoundsBR, aPenPos);

   696 			}

   697 		}

   698  	return (aBoundsBR - aBoundsTL > aInput.iMaxBounds);

   699 	}

   700 

   701 

   702 /** Text measurement function.

   703 

   704 This is a powerful text measurement function underlying all the

   705 other text measurement functions. It takes optional input and output

   706 parameter blocks, which may be null, and returns the advance 

   707 width (change in pen position when drawn horizontally) of the text, or the advance

   708 height, if the text is drawn vertically.

   709 

   710 Some of the functions that can be performed using this

   711 function are listed below. Many of them are used by the Text Views

   712 API to do its typographic layout.

   713 - Get the advance width or advance height (return value).

   714 The advance width is the amount by which the pen advances when drawing

   715 the text horizontally, while the advance height is the amount by which 

   716 the pen advances when drawing the text vertically.

   717 - Measure some text in context, so that shaping behaviour

   718 (e.g. in Arabic) can be affected by what comes before and after the

   719 text. Do this using TMeasureTextInput::iStartInputChar and 

   720 TMeasureTextInput::iEndInputChar to tell the function where to start and end 

   721 in the supplied descriptor.

   722 - Determine how much text fits a given size by setting 

   723 TMeasureTextInput::iMaxAdvance or TMeasureTextInput::iMaxBounds. 

   724 - Specify letter spacing and word spacing using TMeasureTextInput::iCharJustNum,

   725 TMeasureTextInput::iCharJustExcess, 

   726 TMeasureTextInput::iWordJustNum and 

   727 TMeasureTextInput::iWordJustExcess. 

   728 - Get the number of characters drawn in TMeasureTextOutput::iChars 

   729 when applying the various constraints in TMeasureTextInput. 

   730 - Get the number of glyphs drawn in TMeasureTextOutput::iGlyphs. 

   731 - Get the number of groups (formed by ligation or diacritic placement) in 

   732 TMeasureTextOutput::iGroups. Groups are units of cursor

   733 movement: the cursor hops over a character-plus-accent group or an

   734 Arabic or other ligature in one go.

   735 - Get the number of word spaces in TMeasureTextOutput::iSpaces. 

   736 - Get the bounds of the inked-in pixels in TMeasureTextOutput::iBounds. 

   737 - Get the size of the biggest glyph that would be drawn in TMeasureTextOutput::iMaxGlyphSize.

   738 

   739 @param aText The text to be measured.

   740 @param aInput The input block. This may be NULL.

   741 @param aOutput The output block. This may be NULL.

   742 @return The advance width if the text is drawn horizontally or the advance 

   743 height if the text is drawn vertically. 

   744 

   745 @panic GDI 1 In debug builds only, if TMeasureTextInput::iStartInputChar is negative.

   746 */

   747 EXPORT_C TInt CFont::MeasureText(const TDesC& aText,const TMeasureTextInput* aInput,TMeasureTextOutput* aOutput) const

   748 	{

   749 	TMeasureTextInput input;

   750 	if (aInput)

   751 		input = *aInput;

   752 	if (aOutput)

   753 		{

   754 		Mem::FillZ(aOutput,sizeof(*aOutput));

   755 		aOutput->iChars = input.iStartInputChar;

   756 		}

   757 	TPositionParam param;

   758 	param.iDirection = input.iDirection;

   759  

   760  	TBool vertical = param.iDirection == EVertical;

   761  	TBool penMovesLeft = EFalse;

   762  	if (input.iFlags & TMeasureTextInput::EFVisualOrderRightToLeft)

   763  		{

   764  		if (!vertical)

   765  			penMovesLeft = ETrue;

   766  		param.iFlags |= TPositionParam::EFLogicalOrder;

   767  		}

   768  	else if (!(input.iFlags & TMeasureTextInput::EFVisualOrder))

   769    		param.iFlags |= TPositionParam::EFLogicalOrder;

   770 

   771 

   772 	param.iText.Set(aText);

   773 

   774 	int advance = 0;

   775 	int groups = 0;

   776 	int spaces = 0;

   777 	param.iPosInText = input.iStartInputChar;

   778 	int end_char = Min(aText.Length(),input.iEndInputChar);

   779 	TRect bounds;

   780 	// Total advance if pen is moving left. Positive.

   781  	TInt rightToLeftAdvance = 0;

   782 	// Shaping information of the text

   783 	RShapeInfo shapeInfo;

   784 	while (param.iPosInText < end_char)

   785 		{

   786 		if (!GetCharacterPosition2(param, shapeInfo))

   787 			{

   788 			if (aOutput)

   789 				aOutput->iChars = param.iPosInText;

   790 			continue;

   791 			}

   792 

   793 		int new_advance = vertical ? param.iPen.iY : param.iPen.iX;

   794 		if (input.iCharJustExcess != 0)

   795 			new_advance += CGraphicsContext::JustificationInPixels(input.iCharJustExcess,input.iCharJustNum,groups,1);

   796 		groups++;

   797 		// Allow justification to occur at spaces

   798 		if (param.iOutput[0].iCode == 0x0020)

   799 			{

   800 			if (input.iWordJustExcess != 0)

   801 				new_advance += CGraphicsContext::JustificationInPixels(input.iWordJustExcess,input.iWordJustNum,spaces,1);

   802 			spaces++;

   803 			}

   804 		if (vertical)

   805 			param.iPen.iY = new_advance;

   806 		else

   807 			param.iPen.iX = new_advance;

   808 		

   809 		if (penMovesLeft)

   810  			{

   811  			// If the pen is moving left, we will begin each cluster at (0,0)

   812  			// and shift the bounds to the right to compensate.

   813  			bounds.iTl.iX += param.iPen.iX;

   814  			bounds.iBr.iX += param.iPen.iX;

   815  			bounds.iTl.iY += param.iPen.iY;

   816  			bounds.iBr.iY += param.iPen.iY;

   817  			rightToLeftAdvance += param.iPen.iX;

   818  			new_advance = rightToLeftAdvance;

   819  			param.iPen.iX = 0;

   820  			param.iPen.iY = 0;

   821  			}

   822 

   823 		if (aInput || aOutput)

   824 			{

   825 			const TPositionParam::TOutput* output = param.iOutput;

   826 			for (int i = 0; i < param.iOutputGlyphs; i++, output++)

   827 				{

   828 				//if (!output->iBounds.IsEmpty()) -- optimized to:

   829 				if (output->iBounds.iTl.iX != output->iBounds.iBr.iX

   830 					|| output->iBounds.iTl.iY != output->iBounds.iBr.iY)

   831 					{

   832 					if (aOutput)

   833 						{

   834 						// increase iMaxGlyphSize if either dimension smaller than

   835 						// current glyph

   836 						TInt boundsDim = output->iBounds.iBr.iX - output->iBounds.iTl.iX;

   837 						aOutput->iMaxGlyphSize.iWidth = aOutput->iMaxGlyphSize.iWidth < boundsDim?

   838 							boundsDim : aOutput->iMaxGlyphSize.iWidth;

   839 						boundsDim = output->iBounds.iBr.iY - output->iBounds.iTl.iY;

   840 						aOutput->iMaxGlyphSize.iHeight = aOutput->iMaxGlyphSize.iHeight < boundsDim?

   841 							boundsDim : aOutput->iMaxGlyphSize.iHeight;

   842 						}

   843 					//bounds.BoundingRect(output->iBounds); -- optimized to:

   844 					if (output->iBounds.iTl.iX < bounds.iTl.iX)

   845 						bounds.iTl.iX = output->iBounds.iTl.iX;

   846 					if (bounds.iBr.iX < output->iBounds.iBr.iX)

   847 						bounds.iBr.iX = output->iBounds.iBr.iX;

   848 					if (output->iBounds.iTl.iY < bounds.iTl.iY)

   849 						bounds.iTl.iY = output->iBounds.iTl.iY;

   850 					if (bounds.iBr.iY < output->iBounds.iBr.iY)

   851 						bounds.iBr.iY = output->iBounds.iBr.iY;

   852 					}

   853 				}

   854 

   855 			// Would any limits be exceeded by adding this group?

   856 			if (param.iPosInText > end_char)

   857 				break;

   858 			if (new_advance > input.iMaxAdvance)

   859 				break;

   860 			if (vertical)

   861 				{

   862 				if (BoundsExceeded(input, param.iPen.iY, bounds.iBr.iY, bounds.iTl.iY))

   863 					break;

   864 				}

   865 			else

   866 				{

   867 				if (BoundsExceeded(input, param.iPen.iX, bounds.iBr.iX, bounds.iTl.iX))

   868 					break;

   869 				}

   870 

   871 			if (aOutput)

   872 				{

   873 				aOutput->iChars = param.iPosInText;		// should this not be aOutput->iChars = param.iPosInText - input.iShartInputChar;?

   874 				aOutput->iGlyphs += param.iOutputGlyphs;

   875 				aOutput->iGroups = groups;

   876 				aOutput->iSpaces = spaces;

   877 				aOutput->iBounds = bounds;

   878 				}

   879 			}

   880 

   881 		advance = new_advance;

   882 		}

   883 	if(shapeInfo.IsOpen())

   884 		shapeInfo.Close();

   885 	return advance;

   886 	}

   887 

   888 // These 3 functions should probably be moved to E32/Euser as part of TChar or

   889 // similar as there seem to be several local copies of similar functions in

   890 // various OS modules so we should remove duplication

   891 

   892 TUint16 HighSurrogate(TUint aCode)

   893 	{

   894 	TEXTBASE_ASSERT_DEBUG(aCode  > 0xFFFF, ETextBasePanic_InvalidInputParam);

   895 	return STATIC_CAST(TUint16, 0xD7C0 + (aCode >> 10));

   896 	}

   897 	

   898 TUint16 LowSurrogate(TUint aCode)

   899 	{

   900 	TEXTBASE_ASSERT_DEBUG(aCode  > 0xFFFF, ETextBasePanic_InvalidInputParam);

   901 	return STATIC_CAST(TUint16, 0xDC00 | (aCode & 0x3FF));

   902 	}

   903 	

   904 TUint CombineSurrogates(TUint aHighSurrogate, TUint aLowSurrogate)

   905 	{

   906 	TEXTBASE_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xF800)), ETextBasePanic_InvalidInputParam);

   907 	TEXTBASE_ASSERT_DEBUG((0xD800 == (aHighSurrogate & 0xFC00)), ETextBasePanic_InvalidInputParam);

   908 	TEXTBASE_ASSERT_DEBUG((0xDC00 == (aLowSurrogate & 0xFC00)), ETextBasePanic_InvalidInputParam);

   909 	return ((aHighSurrogate - 0xD7F7) << 10) + aLowSurrogate;

   910 	}

   911 

   912 

   913 /** Overridable function innards of GetCharacterPosition and

   914 GetCharacterPosition2. It is generally not useful to override this function.

   915 @publishedAll

   916 @see GetCharacterPosition

   917 @see GetCharacterPosition2

   918 */

   919 EXPORT_C TBool CFont::DoGetCharacterPosition(TPositionParam& aParam) const

   920 	{

   921 	RShapeInfo shapeInfo;

   922 	TBool r = GetCharacterPosition2(aParam, shapeInfo);

   923 	if (shapeInfo.IsOpen())

   924 		shapeInfo.Close();

   925 	return r;

   926 	}

   927 

   928 // Find the script (and hence the correct process function) that any punctuation or digit may belong to

   929 LOCAL_C GlyphSelection::ProcessFunc FindContextualProcessFunc(RShapeInfo& aShapeInfo, const TGlyphSelectionState aGss)

   930 	{

   931 	GlyphSelection::ProcessFunc processFunc = CharacterToProcessFunction(aGss.iCodeChar);

   932 	GlyphSelection::ProcessFunc contextProcessFunc = (GlyphSelection::ProcessFunc)aShapeInfo.GetContext();

   933 	

   934 	// If context or prevCode is NULL, use processFunc,

   935 	// else use function of context or prevCode

   936 	if ((aGss.iCodeChar.IsDigit() || aGss.iCodeChar.IsPunctuation()) && !QuoteOrBracketPair(aGss.iCodeChar) && processFunc!=GlyphSelector_SoftHyphen::Process)

   937 		{

   938 		// If context is not set, check the previous char for context.

   939 		if (contextProcessFunc == NULL)

   940 			{

   941 			if (aGss.iParam.iPosInText > 0)

   942 				{

   943 				TChar prevCode = aGss.iText.Get(-1);

   944 				GlyphSelection::ProcessFunc prevProcessFunc = CharacterToProcessFunction(prevCode);

   945 				if (prevProcessFunc != NULL && (prevCode.IsAlpha() || prevProcessFunc != GlyphSelector_Default::Process))

   946 					{

   947 					aShapeInfo.SetContext((TAny *)prevProcessFunc);

   948 					return prevProcessFunc;

   949 					}

   950 				}

   951 			} 

   952 		else 

   953 			return contextProcessFunc;

   954 		

   955 		return processFunc;

   956 		}

   957 	

   958 	// set the context with current processFunc only if current char is not ignored for context.

   959  	if (processFunc != NULL && (aGss.iCodeChar.IsAlpha() || processFunc != GlyphSelector_Default::Process))

   960  			aShapeInfo.SetContext((TAny *)processFunc);

   961  	return processFunc;

   962 	}

   963 

   964 /** Takes Unicode text and produces the glyph cluster for the first character

   965 in that text plus any combining mark characters, or for the first indic

   966 syllable. It is responsible for contextual glyph selection, ligature creation

   967 and diacritic placement.

   968 

   969 @param aParam

   970 	The input/output parameter of the text/glyph data for the algorithm.

   971 @param aShapeInfo

   972 	The function will cache "shaped" text (e.g. complex scripts such as

   973 	Devanagari) here. aShapeInfo must be freshly-constructed or closed for each

   974 	new piece of text in aParam.iText. If aParam.iText is unchanged between

   975 	calls, aShapeInfo should be passed back in unchanged as well.

   976 @return

   977 	ETrue if glyphs for supplied text have been produced, EFalse in failure.

   978 @see CFont::TPositionParam

   979 @publishedAll

   980 @released */

   981 EXPORT_C TBool CFont::GetCharacterPosition2(TPositionParam& aParam, RShapeInfo& aShapeInfo) const

   982 	{

   983 	TEXTBASE_ASSERT_DEBUG(aParam.iPosInText>=0, ETextBasePanic_InvalidInputParam);

   984 	TEXTBASE_ASSERT_DEBUG(aParam.iText.Ptr(), ETextBasePanic_InvalidInputParam);

   985 

   986 	aParam.iOutputGlyphs = 0;

   987 	TInt textLen = aParam.iText.Length();

   988 	TBool outputOk = ETrue;

   989 	TPoint penCopy = aParam.iPen;

   990 

   991 	// Verify input parameters are sane

   992 	if (aParam.iPosInText >= textLen)

   993 		return EFalse;

   994 

   995 	// Setup glyph selection algorithm data

   996 	TUtf32Iterator textIter(aParam.iText.Ptr(), aParam.iText.Ptr()+textLen, aParam.iPosInText);

   997 	if (textIter.AtEnd())

   998 		{

   999 		aParam.iPosInText = textIter.LengthToStart();

  1000 		return outputOk;

  1001 		}

  1002 

  1003 	// Process each character in the text in turn until we reach the end of

  1004 	// the iterator, the next base (non-mark/combining) character or reach

  1005 	// the limit in a glyph cluster.

  1006 	GlyphSelection::ProcessFunc firstProcessFn = 0;

  1007 	TGlyphSelectionState gss(textIter, this, aParam);

  1008 	do

  1009 		{

  1010 		// Retrieve character info for processing.

  1011 		gss.iCodePt = gss.iCodeChar = textIter.Get();

  1012 		gss.iCombCls = gss.iCodeChar.GetCombiningClass();

  1013 		gss.iCats = gss.iCodeChar.GetCategory();

  1014 		gss.iClusterState = TGlyphSelectionState::EGClusterNotComplete;

  1015 		gss.iPen = TGlyphSelectionState::EPenAdvance_No;

  1016 

  1017 		// Find the correct processesing function for the script being used.

  1018 		// If gss.iCodePt is a strongly directional character, then simply map it in TTableEntry Table[]

  1019 		// and use the returned process function pointer.

  1020 		// If gss.iCodePt is a punctuation or a digit, then use a context character in the text (if

  1021 		// available) to find the contextual script being rendered and use its process function pointer.

  1022 		GlyphSelection::ProcessFunc processFn = FindContextualProcessFunc(aShapeInfo, gss);

  1023 

  1024 		if (!firstProcessFn)

  1025 			firstProcessFn = processFn;

  1026 

  1027 		if (processFn)

  1028 			{

  1029 			if (firstProcessFn == processFn)

  1030 				outputOk = processFn(gss, aShapeInfo);

  1031 			else

  1032 				break;

  1033 			}

  1034 		else

  1035 			{

  1036 			// Table entry blank, unicode char to be skipped

  1037 			outputOk = ETrue;

  1038 			textIter.Next();

  1039 			gss.iClusterState = 

  1040 				(!textIter.AtEnd() &&

  1041 				((textIter.Get().GetCategory() & 0xF0) 

  1042 				== TChar::EMarkGroup)) ?

  1043 					TGlyphSelectionState::EGClusterNotComplete : TGlyphSelectionState::EGClusterComplete;

  1044 			}

  1045 

  1046 		// Abort if no class was available to process the character or if

  1047 		// processing failed.

  1048 		if (!outputOk)

  1049 			{

  1050 			aParam.iPosInText = textIter.LengthToStart();

  1051 			return outputOk;

  1052 			}

  1053 

  1054 		// Did the glyph selector that processed the character want the 

  1055 		// pen to advance?

  1056 		if (gss.iPen == TGlyphSelectionState::EPenAdvance_Yes)

  1057 			{

  1058 			aParam.iPen.iX += gss.iAdvance.iWidth;

  1059 			aParam.iPen.iY += gss.iAdvance.iHeight;

  1060 			gss.iPen = TGlyphSelectionState::EPenAdvance_No;

  1061 			}

  1062 

  1063 		// Here we assume the Process() methods have advanced the iterator as

  1064 		// they consume characters they handle so that it now points to the

  1065 		// character to process next time around the loop.

  1066 		}

  1067 	while (!textIter.AtEnd()	// We still have more text to process

  1068 		&& (gss.iClusterState == TGlyphSelectionState::EGClusterNotComplete) // Glyph cluster !complete

  1069 		&& (aParam.iOutputGlyphs < TPositionParam::EMaxOutputGlyphs)); // Room for another glyph entry

  1070 

  1071 	// If a complete glyph cluster has been identified then we should try to

  1072 	// compose it as fully as possible. Obviously, if it only contains one

  1073 	// character then it is already fully composed so we can ignore it.

  1074 	// Skip this if any language-specific processing has taken place.

  1075 	if (gss.iGlyphPostCombine == TGlyphSelectionState::EGPostCombine_Yes

  1076 		&& gss.iClusterState == TGlyphSelectionState::EGClusterComplete)

  1077 		{

  1078 		// Leave room to handle surrogates - Decompose() outputs UTF-16

  1079 		// The max that can come out of the previous stage is TPositionParam::EMaxOutputGlyphs

  1080 		// long with only one base char at the start. Even if that base char decomposed to the

  1081 		// max it could only be MaxOutputGlyphs long, giving a total of (2 * MaxOutputGlyphs)-1

  1082 		// Conceivably the use of surrogates throughout could double that when converting to UTF-16

  1083 		TBuf<TPositionParam::EMaxOutputGlyphs * 4> decomposeArray;

  1084 		TBool success = ETrue;

  1085 		// Go through the glyph cluster one char at a time

  1086 		for (TInt i = 0; i < aParam.iOutputGlyphs; i++)

  1087 			{

  1088 			TChar singleChar(aParam.iOutput[i].iCode);

  1089 			// If first character try to decompose it otherwise just take the character

  1090 			TBool decomposed = EFalse;

  1091 			TPtrC16 decomposition;

  1092 			if (i == 0)

  1093 				decomposed = singleChar.Decompose(decomposition);

  1094 			if (decomposed)

  1095 				{ // Pick up the sequence of characters

  1096 				decomposeArray.Append(decomposition);

  1097 				}

  1098 			else

  1099 				{ // Keep the original character

  1100 				if (singleChar > 0xFFFF)

  1101 					{ // Above the BMP so we need a surrogate pair for UTF-16

  1102 					// This calculation really ought to go into a separate routine - probably part of TChar

  1103 					decomposeArray.Append(HighSurrogate(singleChar));

  1104 					decomposeArray.Append(LowSurrogate(singleChar));

  1105 					}

  1106 				else

  1107 					{ // It's not a surrogate so we just need to cast it down (since it's safe)

  1108 					decomposeArray.Append(singleChar);

  1109 					}

  1110 				}

  1111 			// Guard against bad input overflowing the array and causing a panic

  1112 			if (decomposeArray.Length() > (TPositionParam::EMaxOutputGlyphs * 4) - 2)

  1113 				{ // too long to be a viable composition so don't try

  1114 				success = EFalse;

  1115 				break;

  1116 				}

  1117 			}

  1118 		TUint composedChar = 0;

  1119 		TOpenFontCharMetrics metrics;

  1120 		TPositionParam::TOutput output;

  1121 		TSize advance; // gets initialized to 0,0

  1122 		if (success)

  1123 			{

  1124 			//Now try and compose the string to a single character

  1125 			success = TChar::Compose(composedChar, decomposeArray);

  1126 			}

  1127 		if (success)

  1128 			{

  1129 			// if single char is not in font or can't get char metrics for it

  1130 			// N.B. This will probably always return metrics because if the

  1131 			// char is not in the font this will usually return the substitute

  1132 			// "missing" glyph (and its metrics). There should be a function to

  1133 			// really tell you if a glyph is in the font - but there isn't.

  1134 			if (GetCharacterData(composedChar, metrics, output.iBitmap, output.iBitmapSize) == CFont::ENoCharacterData)

  1135 				success = EFalse;