--- a/epoc32/include/gdi.inl Tue Nov 24 13:55:44 2009 +0000
+++ b/epoc32/include/gdi.inl Tue Mar 16 16:12:26 2010 +0000
@@ -1,1 +1,718 @@
-gdi.inl
+// Copyright (c) 1998-2009 Nokia Corporation and/or its subsidiary(-ies).
+// All rights reserved.
+// This component and the accompanying materials are made available
+// under the terms of the License "Symbian Foundation License v1.0" to Symbian Foundation members and "Symbian Foundation End User License Agreement v1.0" to non-members
+// which accompanies this distribution, and is available
+// at the URL "http://www.symbianfoundation.org/legal/licencesv10.html".
+//
+// Initial Contributors:
+// Nokia Corporation - initial contribution.
+//
+// Contributors:
+//
+// Description:
+// TRgb
+//
+//
+
+
+inline TRgb::TRgb():
+ iValue(0xffffffff)
+ /** Constructs a TRgb initialised to KRgbWhite.*/
+ {}
+
+
+inline TRgb::TRgb(TUint32 aValue):
+ iValue(((aValue & 0xff0000) >> 16) | (aValue & 0x00ff00) | ((aValue & 0x0000ff) << 16) | (0xff000000 - (aValue & 0xff000000)))
+/** Constructs a TRgb directly from a single 32-bit integer.
+
+The integer is of the form 0xaabbggrr, where bb is the hex number of blue,
+gg is the hex number for green, and rr is the hex number for red, aa is the hex number of
+alpha (0 means opaque, 255 means transparent).
+
+For example, TRgb(2,4,8) using the 3 colour constructor is equal to TRgb(0x00080402) using
+this constructor.
+
+The constructor is deprecated. Use others constructor or SetInternal() instead.
+
+@param aValue Integer representing colour value. Takes form 0x00bbggrr.
+@deprecated */
+ {}
+
+inline TRgb::TRgb(TUint32 aInternalValue, TInt aAlpha) :
+ iValue((aInternalValue & 0x00ffffff) | (aAlpha << 24))
+/** Constructs a TRgb from a 32-bit integer (which corresponds to a colour) and from an alpha value.
+
+The first parameter is of the form 0x00rrggbb, where rr is the hex number for red,
+gg is the hex number for green, and bb is the hex number of blue.
+
+The second parameter corresponds to an alpha channel (0 means transparent, 255 means opaque).
+
+For example, TRgb(2,4,8,255) using the 3 colour constructor is equal to TRgb(0x00020408, 255) using
+this constructor.
+
+The constructor is a replacement for TRgb(TUint32 aValue).
+
+@param aInternalValue Integer representing a colour value, which takes the form 0x00rrggbb.
+@param aAlpha Alpha component of the colour (0 - 255).*/
+ {
+ }
+
+inline TRgb::TRgb(TInt aRed,TInt aGreen,TInt aBlue):
+ iValue(aRed<<16|aGreen<<8|aBlue|0xff000000)
+/** Constructs a TRgb from its three component colours.
+
+Each colour has a value between 0 and 255.
+
+@param aRed Red component of the colour (0 - 255).
+@param aGreen Green component of the colour (0 - 255).
+@param aBlue Blue component of the colour (0 - 255). */
+ {}
+
+/** Constructs a TRgb from its three colour components and alpha component.
+
+Each component has a value between 0 and 255.
+The fourth parameter corresponds to an alpha channel (0 means transparent, 255 means opaque).
+
+@param aRed Red component of the colour (0 - 255).
+@param aGreen Green component of the colour (0 - 255).
+@param aBlue Blue component of the colour (0 - 255).
+@param aAlpha Alpha component of the colour (0 - 255).*/
+inline TRgb::TRgb(TInt aRed,TInt aGreen,TInt aBlue, TInt aAlpha):
+ iValue(aRed<<16|aGreen<<8|aBlue|aAlpha<<24)
+ {}
+
+
+inline TInt TRgb::Red() const
+/** Gets the red component.
+
+@return The red component (0 - 255). */
+ {return((iValue&0xff0000)>>16);}
+
+
+inline TInt TRgb::Green() const
+/** Gets the green component.
+
+@return The green component (0 - 255). */
+ {return((iValue&0xff00)>>8);}
+
+
+inline TInt TRgb::Blue() const
+/** Gets the blue component.
+
+@return The blue component (0 - 255). */
+ {return(iValue&0xff);}
+
+
+inline TBool TRgb::operator==(const TRgb& aColor) const
+/** Compares this colour with the specified colour for equality.
+
+For two colours to be equal, their red, green and blue components must all
+be equal.
+
+@param aColor Colour to be compared.
+@return ETrue. if the colours are equal; EFalse, otherwise. */
+
+ {return(iValue==aColor.iValue);}
+
+
+inline TBool TRgb::operator!=(const TRgb& aColor) const
+/** Compares this colour with the specified colour for inequality.
+
+Two colours are unequal if one at least one of their red, green and blue components
+are unequal.
+
+@param aColor Colour to be compared.
+@return ETrue, if the colours are not equal; EFalse, otherwise.
+ */
+ {return(!(*this==aColor));}
+
+inline TRgb& TRgb::operator&=(const TRgb& aColor)
+/** Logical AND assignment operator.
+
+The operator ANDs the first operand with the second and then assigns the result
+back to the first operand.
+
+Note:
+
+This operates in the TRgb domain. Graphics defines logical operations for
+drawing primitives which operate in the device colour domain.
+
+@param aColor Colour to be compared.
+@return First operand-contains result of logical AND. */
+ {iValue&=aColor.iValue;return(*this);}
+
+inline TRgb& TRgb::operator|=(const TRgb& aColor)
+/** Logical OR assignment operator.
+
+The operator ORs the first operand with the second and then assigns the result
+back to the first operand.
+
+Note:
+
+This operates in the TRgb domain. Graphics defines logical operations for
+drawing primitives which operate in the device colour domain.
+
+@param aColor Colour to be compared.
+@return First operand- contains result of logical OR. */
+ {iValue|=aColor.iValue;return(*this);}
+
+
+inline TRgb& TRgb::operator^=(const TRgb& aColor)
+/** Logical EXCLUSIVE OR assignment operator.
+
+The operator Exclusive ORs the first operand with the second and then assigns
+the result back to the first operand.
+
+Note:
+
+This operates in the TRgb domain. Graphics defines logical operations for
+drawing primitives which operate in the device colour domain.
+
+@param aColor Colour to be compared.
+@return First operand contains result of logical Exclusive OR. */
+ {iValue^=aColor.iValue;iValue^=0xff000000; return(*this);}
+
+
+inline TUint32 TRgb::Value() const
+/** Gets the 32-bit value of the TRgb as an integer.
+This function is deprecated. Use Internal() instead.
+
+@return The 32 bit value of the TRgb. Has the form 0xaabbggrr, where bb is the hex number of blue,
+gg is the hex number for green, rr is the hex number for red and aa is the hex number of
+alpha (0 means opaque, 255 means transparent).
+@deprecated */
+ // rr gg bb aa
+ {return (((iValue & 0xff0000) >> 16) | (iValue & 0x00ff00) | ((iValue & 0x0000ff) << 16) | (0xff000000 - (iValue & 0xff000000)));}
+
+inline TUint32 TRgb::Internal() const
+/** Gets the 32-bit value of the TRgb as an integer.
+
+@return The 32 bit value of the TRgb. Has the form 0xaarrggbb. */
+ {return (iValue);}
+
+inline void TRgb::SetInternal(TUint32 aInternal)
+/** Sets the 32-bit value of the TRgb as a 32-bit integer.
+@param aInternal Colour internal representation. Has the form 0xaarrggbb.
+*/
+ {iValue = aInternal;}
+
+inline TRgb TRgb::operator~() const
+/** Bitwise logical inversion operator.
+
+@return Contains results of logical inversion. */
+ {TRgb rgb; rgb.SetInternal(iValue^0x00ffffff); return rgb;}
+
+
+inline TRgb TRgb::operator&(const TRgb& aColor)
+/** Bitwise logical AND operator.
+
+@param aColor Colour to be compared.
+@return Contains results of logical AND. */
+ {TRgb rgb; rgb.SetInternal(iValue&aColor.iValue); return rgb;}
+
+
+inline TRgb TRgb::operator|(const TRgb& aColor)
+/** Bitwise logical OR operator.
+
+@param aColor Colour to be compared.
+@return Contains results of logical OR. */
+ {TRgb rgb; rgb.SetInternal(iValue|aColor.iValue); return rgb;}
+
+
+inline TRgb TRgb::operator^(const TRgb& aColor)
+/** Bitwise EXCLUSIVE OR operator
+
+@param aColor Colour to be compared.
+@return Contains results of logical EXCLUSIVE OR. */
+ {TRgb rgb; rgb.SetInternal(iValue^aColor.iValue); return rgb;}
+
+
+/** Gets TRgb from 2 level grayscale.
+
+The function takes a grayscale argument and return a TRgb whose red, green
+and blue values are set to an appropriate level.
+
+@param aGray2 Grayscale value to be converted.
+@return Equivalent 24 bit colour. Gray2 has only 2 levels (black and white),
+the function returns r=g=b=0 or r=g=b=255. */
+inline TRgb TRgb::_Gray2(TInt aGray2)
+ {
+ if(aGray2) return(TRgb(0xffffff, 0xff));
+ return(TRgb(0, 0xff));
+ }
+
+/** Gets TRgb from 4 level grayscale.
+
+The function takes a grayscale argument and return a TRgb whose red, green
+and blue values are set to an appropriate level.
+
+@param aGray4 Grayscale value to be converted.
+@return Equivalent 24 bit colour. Gray4 has 4 levels- the function returns
+r=g=b=85*c, where c=0,1,2, or 3. */
+inline TRgb TRgb::_Gray4(TInt aGray4)
+ {
+ aGray4&=3;
+ aGray4|=aGray4<<2;
+ aGray4|=aGray4<<4;
+ return(TRgb(aGray4,aGray4,aGray4));
+ }
+
+/** Gets TRgb from 16 level grayscale.
+
+The function takes a grayscale argument and return a TRgb whose red, green
+and blue values are set to an appropriate level.
+
+@param aGray16 Grayscale value to be converted.
+@return Equivalent 24 bit colour. Gray16 has 16 levels - the function returns
+r=g=b=17*c, where c=0, 1, ... 15. */
+inline TRgb TRgb::_Gray16(TInt aGray16)
+ {
+ aGray16&=0xf;
+ aGray16|=aGray16<<4;
+ return(TRgb(aGray16,aGray16,aGray16));
+ }
+
+/** Gets TRgb from 256 level grayscale.
+
+The function takes a grayscale argument and return a TRgb whose red, green
+and blue values are set to an appropriate level.
+
+@param aGray256 Grayscale value to be converted.
+@return Equivalent 24 bit colour. Gray256 has 256 levels- the function
+returns r=g=b=c, where c=0, 1, ... 255. */
+inline TRgb TRgb::_Gray256(TInt aGray256)
+ {
+ aGray256&=0xff;
+ return(TRgb(aGray256,aGray256,aGray256));
+ }
+
+/** Gets TRgb from 4K colour index.
+
+The function takes a 12 bit index into a colour palette and returns a TRgb
+whose red, green and blue values are set to an appropriate level.
+
+@param aColor4K 12 bit index into a colour palette
+@return Equivalent 24 bit colour. */
+inline TRgb TRgb::_Color4K(TInt aColor4K)
+ {
+ TUint32 value = (aColor4K & 0xf00) << 8;
+ value |= (aColor4K & 0x0f0) << 4;
+ value |= (aColor4K & 0x00f);
+ return TRgb(value | (value << 4), 0xff);
+ }
+
+/** Gets TRgb from 64K colour index.
+
+The function takes a 16 bit index into a colour palette and returns a TRgb
+whose red, green and blue values are set to an appropriate level.
+
+@param aColor64K 16 bit index into a colour palette
+@return Equivalent 24 bit colour. */
+inline TRgb TRgb::_Color64K(TInt aColor64K)
+ {
+ TInt red = (aColor64K&0xF800)>>8;
+ red += red>>5;
+ TInt green = (aColor64K&0x07E0)>>3;
+ green += green>>6;
+ TInt blue = (aColor64K&0x001F)<<3;
+ blue += blue>>5;
+ return TRgb(red,green,blue);
+ }
+
+/** Gets TRgb from 16M colour index.
+
+The function takes a 24 bit index into a colour palette and returns the TRgb
+whose red, green and blue values represent it exactly.
+
+@param a0RGB 24 bit index into a colour palette
+@return The TRgb which represents the index exactly. */
+inline TRgb TRgb::_Color16M(TInt a0RGB)
+ {
+ return TRgb(a0RGB, 0xff);
+ }
+
+/** Gets TRgb from 16MU colour index.
+The function takes a 24 bit colour value with eight bits for each
+component, blue in the low byte, and returns the TRgb
+whose red, green and blue values represent it exactly.
+@param a0RGB The color - 0, R, G, B bytes. / BGR0 - little endian format /
+@return The TRgb which represents the index exactly. */
+inline TRgb TRgb::_Color16MU(TInt a0RGB)
+ {
+ return TRgb(a0RGB, 0xff);
+ }
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 1) representing the nearest TRgb. */
+inline TInt TRgb::_Gray2() const
+ {
+ return(Gray256()>>7);
+ }
+
+/**Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 3) representing the nearest TRgb. */
+inline TInt TRgb::_Gray4() const
+ {
+ return(Gray256()>>6);
+ }
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 15) representing the nearest TRgb.*/
+inline TInt TRgb::_Gray16() const
+ {
+ return(Gray256()>>4);
+ }
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 255) representing the nearest TRgb.*/
+inline TInt TRgb::_Gray256() const
+ {
+ return(((Red()<<1)+Green()+(Green()<<2)+Blue())>>3);
+ }
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 4095) representing the nearest TRgb. */
+inline TInt TRgb::_Color4K() const
+ {
+ TInt color4K = (iValue & 0x0000f0) >> 4;
+ color4K |= (iValue & 0x00f000) >> 8;
+ color4K |= (iValue & 0xf00000) >> 12;
+ return color4K;
+ } //0RGB
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 65535) representing the nearest TRgb.*/
+inline TInt TRgb::_Color64K() const
+ {
+ TInt color64K = (iValue & 0x0000f8) >> 3;
+ color64K |= (iValue & 0x00fc00) >> 5;
+ color64K |= (iValue & 0xf80000) >> 8;
+ return color64K;
+ }
+
+/** Gets the index of the closest TRgb value to this,
+based on the matching display mode.
+
+@return The index (0 - 16777215) representing the nearest TRgb.*/
+inline TInt TRgb::_Color16M() const
+ {
+ return (iValue & 0xffffff);
+ // 0RGB
+ }
+
+/** Gets the index of the closest TRgb value to this, based on the matching display mode.
+@return The index (0 - 16777215) representing the nearest TRgb. */
+inline TInt TRgb::_Color16MU() const
+ {
+ return (iValue & 0xffffff);
+ // 0RGB
+ }
+
+
+/** Gets the alpha component.
+@return The alpha component (0 - 255). */
+inline TInt TRgb::Alpha() const
+ {return (iValue >> 24);}
+
+
+/** Gets TRgb from 16MA colour index.
+The function takes a 32 bit colour value with eight bits for each
+component, blue in the low byte, and returns the TRgb
+whose red, green, blue and alpha values represent it exactly.
+@param aARGB The color - A, R, G, B bytes. / BGR0 - little endian format /
+@return The TRgb which represents the index exactly. */
+inline TRgb TRgb::_Color16MA(TUint aARGB)
+ {
+ TRgb col; col.SetInternal(aARGB);
+ return col;
+ }
+
+/** Gets the index of the closest TRgb value to this, based on the matching display mode.
+@return The index (0 - 16777215) representing the nearest TRgb. */
+inline TUint TRgb::_Color16MA() const
+ {
+ return (iValue);
+ // ARGB
+ }
+//
+// CPalette
+//
+
+
+inline TInt CPalette::Entries() const
+/** Gets the number of entries in the palette
+
+@return The number of entries in the palette. */
+ {return(iNumEntries);}
+
+//
+// TColor256Utils
+//
+
+
+inline TRgb TColor256Util::Color256(TInt aColor256) const
+/** Gets the TRgb value of the entry at the specified index in the colour lookup
+table.
+
+@param aColor256 The index into the colour lookup table.
+@return The TRgb value of the entry at the specified index. */
+ { return TRgb(iColorTable[aColor256]); }
+
+//
+// TFontStyle
+//
+inline TGlyphBitmapType TFontStyle::BitmapType() const
+/** Gets the anti-aliasing setting for the font, as set by SetBitmapType().
+
+@return Indicates whether or not this font should be drawn using anti-aliasing. */
+ {
+ return (TGlyphBitmapType)(iFlags >> 16);
+ }
+
+
+inline void TFontStyle::SetBitmapType(TGlyphBitmapType aBitmapType)
+/** Sets whether the font should be drawn using anti-aliasing. If set, this value
+overrides the default setting (set by CFbsTypefaceStore::SetDefaultBitmapType())
+for this font.
+
+Anti-aliasing can only be used for scalable fonts. There is currently no anti-aliasing
+support for bitmapped fonts.
+
+@param aBitmapType Indicates whether or not this font should be drawn using
+anti-aliasing. */
+ {
+ iFlags &= 0xFFFF;
+ iFlags |= (aBitmapType << 16);
+ }
+
+//
+// CBitmapDevice
+//
+
+
+inline TInt CBitmapDevice::CreateBitmapContext(CBitmapContext*& aGC)
+/** Creates a bitmap context for this bitmap device.
+
+@param aGC On return, holds a pointer to the created bitmap context.
+@return KErrNone, if successful; otherwise, another of the system-wide error
+codes. */
+ {return(CreateContext((CGraphicsContext*&)aGC));} // relies on CBitmapContext deriving _only_ from CGraphicsContext
+
+//
+// TPictureCapability
+//
+
+inline TPictureCapability::TPictureCapability(TScalingType aScalingType,TBool aCroppable):
+ iScalingType(aScalingType),iIsCroppable(aCroppable)
+/** Constructs the object setting the scaling-type and croppability properties.
+
+@param aScalingType Whether or not the picture is scalable.
+@param aCroppable Whether or not the picture is croppable. */
+ {}
+
+//
+// TZoomFactor
+//
+
+
+inline TZoomFactor::TZoomFactor(const MGraphicsDeviceMap* aDevice):
+ iZoomFactor(TZoomFactor::EZoomOneToOne),
+ iDevice(aDevice)
+/** Constructs a zoom factor object for a specific graphics device map.
+
+The graphics map is either directly associated with a particular graphics
+device itself, or is associated with a hierarchy of device maps whose root
+map is associated with a particular graphics device.
+
+@param aDevice The graphics device map with which the zoom factor is associated. */
+ {}
+
+inline TZoomFactor::TZoomFactor(const TZoomFactor* aDevice):
+ iDevice(aDevice)
+ {
+ iZoomFactor=aDevice->iZoomFactor;
+ }
+
+
+inline void TZoomFactor::SetGraphicsDeviceMap(const MGraphicsDeviceMap* aDevice)
+/** Sets the graphics device map for this zoom factor object.
+
+@param aDevice The graphics device map for this TZoomFactor. */
+ {iDevice=aDevice;}
+
+
+inline const MGraphicsDeviceMap* TZoomFactor::GraphicsDeviceMap() const
+/** Gets the graphics device map of this zoom factor object.
+
+@return The graphics device map of the TZoomFactor. */
+ {return(iDevice);}
+
+
+
+/** Gets the ascent of an ANSI capital letter in the font whether or not
+there are any ANSI capitals in the font.
+@return The positive distance from the font baseline to the top of a
+standard ANSI capital letter
+@publishedAll
+@released
+*/
+inline TInt CFont::FontCapitalAscent() const
+ {
+ return ExtendedFunction(KFontCapitalAscent);
+ }
+
+/** Gets the max ascent of any pre-composed glyph in the font. This will
+include accents or diacritics that form part of pre-composed glyphs. It is
+not guaranteed to cover the max ascent of composite glyphs that have to be
+created by a layout engine. This is also the recommended distance between
+the top of a text box and the baseline of the first line of text.
+@return The positive distance from the font baseline to the top of the
+highest pre-composed glyph (including accents) above the baseline
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxAscent() const
+ {
+ return ExtendedFunction(KFontMaxAscent);
+ }
+
+/** Gets the descent of an ANSI descending character in the font.
+Whether or not there are any ANSI descenders in the font.
+@return The positive distance from the font baseline to the bottom of the
+lowest ANSI descender
+@publishedAll
+@released
+*/
+inline TInt CFont::FontStandardDescent() const
+ {
+ return ExtendedFunction(KFontStandardDescent);
+ }
+
+/** Gets the max descent of any pre-composed glyph in the font. This will
+include accents or diacritics that form part of pre-composed glyphs. It is
+not guaranteed to cover the max descent of composite glyphs that have to be
+created by a layout engine.
+@return The positive distance from the font baseline to the bottom of the
+lowest pre-composed glyph (including accents) below the baseline
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxDescent() const
+ {
+ return ExtendedFunction(KFontMaxDescent);
+ }
+
+/** Gets the suggested line gap for the font. This is the recommended
+baseline to baseline distance between successive lines of text in the font.
+@return The positive recommended gap between successive lines
+@publishedAll
+@released
+*/
+inline TInt CFont::FontLineGap() const
+ {
+ return ExtendedFunction(KFontLineGap);
+ }
+
+/**
+Gets the (positive) maximum height in pixels of the font.
+This may differ from the design height.
+
+@return The maximum height of the font.
+@publishedAll
+@released
+*/
+inline TInt CFont::FontMaxHeight() const
+ {
+ return FontMaxAscent() + FontMaxDescent();
+ }
+
+/** Utility function to check if a display mode has Alpha channel information
+@param aDisplayMode - the display mode being queried
+@return ETrue if display mode contains Alpha information.
+@internalTechnology
+@released
+*/
+inline TBool IsAlphaChannel(TDisplayMode aDisplayMode)
+ {
+ if(aDisplayMode == EColor16MAP || aDisplayMode == EColor16MA)
+ return ETrue;
+ else
+ return EFalse;
+ }
+
+/**
+@internalTechnology
+@released
+*/
+inline TUint QuoteOrBracketPair(TUint code)
+ {
+ // given the opening/closing quote or bracket, return the corresponding closing/opening quote or bracket
+ switch(code)
+ {
+ case 0x0022: return 0x0022; // "..."
+ case 0x0027: return 0x0027; // '...'
+ case 0x0028: return 0x0029; // (...)
+ case 0x003c: return 0x003e; // <...>
+ case 0x005b: return 0x005d; // [...]
+ case 0x007b: return 0x007d; // {...}
+ case 0x2018: return 0x2019; // Single quotation marks
+ case 0x201b: return 0x2019; // Single high-reversed-9 quotation mark
+ case 0x201c: return 0x201d; // Double quotation marks
+ case 0x201f: return 0x201d; // Double high-reversed-9 quotation mark
+ case 0x2035: return 0x2032; // Single primes
+ case 0x2036: return 0x2033; // Double primes
+ case 0x2037: return 0x2034; // Triple primes
+ case 0x2039: return 0x203a; // Single left/right-pointing angle quotation marks
+ case 0x2045: return 0x2046; // Square brackets with quill
+
+ case 0x0029: return 0x0028; // (...)
+ case 0x003e: return 0x003c; // <...>
+ case 0x005d: return 0x005b; // [...]
+ case 0x007d: return 0x007b; // {...}
+ case 0x2019: return 0x2018; // Single quotation marks
+ case 0x201d: return 0x201c; // Double quotation marks
+ case 0x2032: return 0x2035; // Single primes
+ case 0x2033: return 0x2036; // Double primes
+ case 0x2034: return 0x2037; // Triple primes
+ case 0x203a: return 0x2039; // Single left/right-pointing angle quotation marks
+ case 0x2046: return 0x2045; // Square brackets with quill
+
+ default: return 0;
+ }
+ }
+
+/**
+@internalTechnology
+@released
+*/
+inline TBool IsIgnoredCharacterForLocalisedProcFunc(TChar aCode)
+ {
+ // All Devanagari characters should be ignored until DrawTextWithContext is implemented
+ // The current GDI only implementation for localised punctuation only works for some
+ // Devanagari characters. Hence this function 'blocks' all Devanagari characters, for now.
+ if (aCode >= 0x0900 && aCode <= 0x0965)
+ return ETrue;
+
+ TChar::TBdCategory cat = aCode.GetBdCategory();
+
+ if ((cat == TChar::ELeftToRight ||
+ cat == TChar::ERightToLeft ||
+ cat == TChar::ERightToLeftArabic))
+ return EFalse;
+
+ return ETrue;
+
+ }