--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/idlehomescreen/xmluirendering/uiengine/src/xnutils.cpp Thu Dec 17 08:40:49 2009 +0200
@@ -0,0 +1,1952 @@
+/*
+* Copyright (c) 2008 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: Utility functions of Xuikon.
+*
+*/
+
+
+// System includes
+#include <AknUtils.h>
+#include <AknFontAccess.h>
+#include <uri16.h>
+
+// User includes
+#include "c_xnutils.h"
+#include "xnproperty.h"
+#include "xnnodepluginif.h"
+#include "xnuienginepluginif.h"
+#include "xndomlist.h"
+#include "xnresource.h"
+#include "xnnodebreadthfirstiterator.h"
+#include "xncontroladapter.h"
+#include "xncontroladapterimpl.h"
+#include "xncomponent.h"
+#include "xncomponentnodeimpl.h"
+
+// Constants
+_LIT( KNormal, "normal" );
+_LIT( KPrimaryFont , "EAknLogicalFontPrimaryFont" );
+_LIT( KSecondaryFont , "EAknLogicalFontSecondaryFont" );
+_LIT( KTitleFont, "EAknLogicalFontTitleFont" );
+_LIT( KPrimarySmallFont , "EAknLogicalFontPrimarySmallFont" );
+_LIT( KDigitalFont , "EAknLogicalFontDigitalFont" );
+
+_LIT( KXnCommonWhiteSpaceCharacters, " \n\t\r" );
+_LIT( KXnLineFeedTabCharacters, "\n\t\r" );
+_LIT( KXnTabCharacters, "\t\r" );
+
+_LIT( KSkin, "skin(" );
+
+namespace XnColorNames
+ {
+ _LIT8( Kaliceblue, "aliceblue" );
+ _LIT8( Kantiquewhite, "antiquewhite" );
+ _LIT8( Kaqua, "aqua" );
+ _LIT8( Kaquamarine, "aquamarine" );
+ _LIT8( Kazure, "azure" );
+ _LIT8( Kbeige, "beige" );
+ _LIT8( Kbisque, "bisque" );
+ _LIT8( Kblack, "black" );
+ _LIT8( Kblanchedalmond, "blanchedalmond" );
+ _LIT8( Kblue, "blue" );
+ _LIT8( Kblueviolet, "blueviolet" );
+ _LIT8( Kbrown, "brown" );
+ _LIT8( Kburlywood, "burlywood" );
+ _LIT8( Kcadetblue, "cadetblue" );
+ _LIT8( Kchartreuse, "chartreuse" );
+ _LIT8( Kchocolate, "chocolate" );
+ _LIT8( Kcoral, "coral" );
+ _LIT8( Kcornflowerblue, "cornflowerblue" );
+ _LIT8( Kcornsilk, "cornsilk" );
+ _LIT8( Kcrimson, "crimson" );
+ _LIT8( Kcyan, "cyan" );
+ _LIT8( Kdarkblue, "darkblue" );
+ _LIT8( Kdarkcyan, "darkcyan" );
+ _LIT8( Kdarkgoldenrod, "darkgoldenrod" );
+ _LIT8( Kdarkgray, "darkgray" );
+ _LIT8( Kdarkgreen, "darkgreen" );
+ _LIT8( Kdarkgrey, "darkgrey" );
+ _LIT8( Kdarkkhaki, "darkkhaki" );
+ _LIT8( Kdarkmagenta, "darkmagenta" );
+ _LIT8( Kdarkolivegreen, "darkolivegreen" );
+ _LIT8( Kdarkorange, "darkorange" );
+ _LIT8( Kdarkorchid, "darkorchid" );
+ _LIT8( Kdarkred, "darkred" );
+ _LIT8( Kdarksalmon, "darksalmon" );
+ _LIT8( Kdarkseagreen, "darkseagreen" );
+ _LIT8( Kdarkslateblue, "darkslateblue" );
+ _LIT8( Kdarkslategray, "darkslategray" );
+ _LIT8( Kdarkslategrey, "darkslategrey" );
+ _LIT8( Kdarkturquoise, "darkturquoise" );
+ _LIT8( Kdarkviolet, "darkviolet" );
+ _LIT8( Kdeeppink, "deeppink" );
+ _LIT8( Kdeepskyblue, "deepskyblue" );
+ _LIT8( Kdimgray, "dimgray" );
+ _LIT8( Kdimgrey, "dimgrey" );
+ _LIT8( Kdodgerblue, "dodgerblue" );
+ _LIT8( Kfirebrick, "firebrick" );
+ _LIT8( Kfloralwhite, "floralwhite" );
+ _LIT8( Kforestgreen, "forestgreen" );
+ _LIT8( Kfuchsia, "fuchsia" );
+ _LIT8( Kgainsboro, "gainsboro" );
+ _LIT8( Kghostwhite, "ghostwhite" );
+ _LIT8( Kgold, "gold" );
+ _LIT8( Kgoldenrod, "goldenrod" );
+ _LIT8( Kgray, "gray" );
+ _LIT8( Kgreen, "green" );
+ _LIT8( Kgreenyellow, "greenyellow" );
+ _LIT8( Kgrey, "grey" );
+ _LIT8( Khoneydew, "honeydew" );
+ _LIT8( Khotpink, "hotpink" );
+ _LIT8( Kindianred, "indianred" );
+ _LIT8( Kindigo, "indigo" );
+ _LIT8( Kivory, "ivory" );
+ _LIT8( Kkhaki, "khaki" );
+ _LIT8( Klavender, "lavender" );
+ _LIT8( Klavenderblush, "lavenderblush" );
+ _LIT8( Klawngreen, "lawngreen" );
+ _LIT8( Klemonchiffon, "lemonchiffon" );
+ _LIT8( Klightblue, "lightblue" );
+ _LIT8( Klightcoral, "lightcoral" );
+ _LIT8( Klightcyan, "lightcyan" );
+ _LIT8( Klightgoldenrodyellow, "lightgoldenrodyellow" );
+ _LIT8( Klightgray, "lightgray" );
+ _LIT8( Klightgreen, "lightgreen" );
+ _LIT8( Klightgrey, "lightgrey" );
+ _LIT8( Klightpink, "lightpink" );
+ _LIT8( Klightsalmon, "lightsalmon" );
+ _LIT8( Klightseagreen, "lightseagreen" );
+ _LIT8( Klightskyblue, "lightskyblue" );
+ _LIT8( Klightslategray, "lightslategray" );
+ _LIT8( Klightslategrey, "lightslategrey" );
+ _LIT8( Klightsteelblue, "lightsteelblue" );
+ _LIT8( Klightyellow, "lightyellow" );
+ _LIT8( Klime, "lime" );
+ _LIT8( Klimegreen, "limegreen" );
+ _LIT8( Klinen, "linen" );
+ _LIT8( Kmagenta, "magenta" );
+ _LIT8( Kmaroon, "maroon" );
+ _LIT8( Kmediumaquamarine, "mediumaquamarine" );
+ _LIT8( Kmediumblue, "mediumblue" );
+ _LIT8( Kmediumorchid, "mediumorchid" );
+ _LIT8( Kmediumpurple, "mediumpurple" );
+ _LIT8( Kmediumseagreen, "mediumseagreen" );
+ _LIT8( Kmediumslateblue, "mediumslateblue" );
+ _LIT8( Kmediumspringgreen, "mediumspringgreen" );
+ _LIT8( Kmediumturquoise, "mediumturquoise" );
+ _LIT8( Kmediumvioletred, "mediumvioletred" );
+ _LIT8( Kmidnightblue, "midnightblue" );
+ _LIT8( Kmintcream, "mintcream" );
+ _LIT8( Kmistyrose, "mistyrose" );
+ _LIT8( Kmoccasin, "moccasin" );
+ _LIT8( Knavajowhite, "navajowhite" );
+ _LIT8( Knavy, "navy" );
+ _LIT8( Koldlace, "oldlace" );
+ _LIT8( Kolive, "olive" );
+ _LIT8( Kolivedrab, "olivedrab" );
+ _LIT8( Korange, "orange" );
+ _LIT8( Korangered, "orangered" );
+ _LIT8( Korchid, "orchid" );
+ _LIT8( Kpalegoldenrod, "palegoldenrod" );
+ _LIT8( Kpalegreen, "palegreen" );
+ _LIT8( Kpaleturquoise, "paleturquoise" );
+ _LIT8( Kpalevioletred, "palevioletred" );
+ _LIT8( Kpapayawhip, "papayawhip" );
+ _LIT8( Kpeachpuff, "peachpuff" );
+ _LIT8( Kperu, "peru" );
+ _LIT8( Kpink, "pink" );
+ _LIT8( Kplum, "plum" );
+ _LIT8( Kpowderblue, "powderblue" );
+ _LIT8( Kpurple, "purple" );
+ _LIT8( Kred, "red" );
+ _LIT8( Krosybrown, "rosybrown" );
+ _LIT8( Kroyalblue, "royalblue" );
+ _LIT8( Ksaddlebrown, "saddlebrown" );
+ _LIT8( Ksalmon, "salmon" );
+ _LIT8( Ksandybrown, "sandybrown" );
+ _LIT8( Kseagreen, "seagreen" );
+ _LIT8( Kseashell, "seashell" );
+ _LIT8( Ksienna, "sienna" );
+ _LIT8( Ksilver, "silver" );
+ _LIT8( Kskyblue, "skyblue" );
+ _LIT8( Kslateblue, "slateblue" );
+ _LIT8( Kslategray, "slategray" );
+ _LIT8( Kslategrey, "slategrey" );
+ _LIT8( Ksnow, "snow" );
+ _LIT8( Kspringgreen, "springgreen" );
+ _LIT8( Ksteelblue, "steelblue" );
+ _LIT8( Ktan, "tan" );
+ _LIT8( Kteal, "teal" );
+ _LIT8( Kthistle, "thistle" );
+ _LIT8( Ktomato, "tomato" );
+ _LIT8( Kturquoise, "turquoise" );
+ _LIT8( Kviolet, "violet" );
+ _LIT8( Kwheat, "wheat" );
+ _LIT8( Kwhite, "white" );
+ _LIT8( Kwhitesmoke, "whitesmoke" );
+ _LIT8( Kyellow, "yellow" );
+ _LIT8( Kyellowgreen, "yellowgreen" );
+ }
+
+namespace XnColorValues
+ {
+ const TInt Kaliceblue = 0xfff8f0;
+ const TInt Kantiquewhite = 0xd7ebfa;
+ const TInt Kaqua = 0xffff00;
+ const TInt Kaquamarine = 0xd4ff7f;
+ const TInt Kazure = 0xfffff0;
+ const TInt Kbeige = 0xdcf5f5;
+ const TInt Kbisque = 0xc4e4ff;
+ const TInt Kblack = 0x000000;
+ const TInt Kblanchedalmond = 0xcdebff;
+ const TInt Kblue = 0xff0000;
+ const TInt Kblueviolet = 0xe22b8a;
+ const TInt Kbrown = 0x2a2aa5;
+ const TInt Kburlywood = 0x87b8de;
+ const TInt Kcadetblue = 0xa09e5f;
+ const TInt Kchartreuse = 0x00ff7f;
+ const TInt Kchocolate = 0x1e69d2;
+ const TInt Kcoral = 0x507fff;
+ const TInt Kcornflowerblue = 0xed9564;
+ const TInt Kcornsilk = 0xdcf8ff;
+ const TInt Kcrimson = 0x3c14dc;
+ const TInt Kcyan = 0xffff00;
+ const TInt Kdarkblue = 0x8b0000;
+ const TInt Kdarkcyan = 0x8b8b00;
+ const TInt Kdarkgoldenrod = 0x0b86b8;
+ const TInt Kdarkgray = 0xa9a9a9;
+ const TInt Kdarkgreen = 0x006400;
+ const TInt Kdarkgrey = 0xa9a9a9;
+ const TInt Kdarkkhaki = 0x6bb7bd;
+ const TInt Kdarkmagenta = 0x8b008b;
+ const TInt Kdarkolivegreen = 0x2f6b55;
+ const TInt Kdarkorange = 0x008cff;
+ const TInt Kdarkorchid = 0xcc3299;
+ const TInt Kdarkred = 0x00008b;
+ const TInt Kdarksalmon = 0x7a96e9;
+ const TInt Kdarkseagreen = 0x8fbc8f;
+ const TInt Kdarkslateblue = 0x8b3d48;
+ const TInt Kdarkslategray = 0x4f4f2f;
+ const TInt Kdarkslategrey = 0x4f4f2f;
+ const TInt Kdarkturquoise = 0xd1ce00;
+ const TInt Kdarkviolet = 0xd30094;
+ const TInt Kdeeppink = 0x9314ff;
+ const TInt Kdeepskyblue = 0xffbf00;
+ const TInt Kdimgray = 0x696969;
+ const TInt Kdimgrey = 0x696969;
+ const TInt Kdodgerblue = 0xff901e;
+ const TInt Kfirebrick = 0x2222b2;
+ const TInt Kfloralwhite = 0xf0faff;
+ const TInt Kforestgreen = 0x228b22;
+ const TInt Kfuchsia = 0xff00ff;
+ const TInt Kgainsboro = 0xdcdcdc;
+ const TInt Kghostwhite = 0xfff8f8;
+ const TInt Kgold = 0x00d7ff;
+ const TInt Kgoldenrod = 0x20a5da;
+ const TInt Kgray = 0x808080;
+ const TInt Kgreen = 0x008000;
+ const TInt Kgreenyellow = 0x2fffad;
+ const TInt Kgrey = 0x808080;
+ const TInt Khoneydew = 0xf0fff0;
+ const TInt Khotpink = 0xb469ff;
+ const TInt Kindianred = 0x5c5ccd;
+ const TInt Kindigo = 0x82004b;
+ const TInt Kivory = 0xf0ffff;
+ const TInt Kkhaki = 0x8ce6f0;
+ const TInt Klavender = 0xfae6e6;
+ const TInt Klavenderblush = 0xf5f0ff;
+ const TInt Klawngreen = 0x00fc7c;
+ const TInt Klemonchiffon = 0xcdfaff;
+ const TInt Klightblue = 0xe6d8ad;
+ const TInt Klightcoral = 0x8080f0;
+ const TInt Klightcyan = 0xffffe0;
+ const TInt Klightgoldenrodyellow = 0xd2fafa;
+ const TInt Klightgray = 0xd3d3d3;
+ const TInt Klightgreen = 0x90ee90;
+ const TInt Klightgrey = 0xd3d3d3;
+ const TInt Klightpink = 0xc1b6ff;
+ const TInt Klightsalmon = 0x7aa0ff;
+ const TInt Klightseagreen = 0xaab220;
+ const TInt Klightskyblue = 0xface87;
+ const TInt Klightslategray = 0x998877;
+ const TInt Klightslategrey = 0x998877;
+ const TInt Klightsteelblue = 0xdec4b0;
+ const TInt Klightyellow = 0xe0ffff;
+ const TInt Klime = 0x00ff00;
+ const TInt Klimegreen = 0x32cd32;
+ const TInt Klinen = 0xe6f0fa;
+ const TInt Kmagenta = 0xff00ff;
+ const TInt Kmaroon = 0x000080;
+ const TInt Kmediumaquamarine = 0xaacd66;
+ const TInt Kmediumblue = 0xcd0000;
+ const TInt Kmediumorchid = 0xd355ba;
+ const TInt Kmediumpurple = 0xdb7093;
+ const TInt Kmediumseagreen = 0x71b33c;
+ const TInt Kmediumslateblue = 0xee687b;
+ const TInt Kmediumspringgreen = 0x9afa00;
+ const TInt Kmediumturquoise = 0xccd148;
+ const TInt Kmediumvioletred = 0x8515c7;
+ const TInt Kmidnightblue = 0x701919;
+ const TInt Kmintcream = 0xfafff5;
+ const TInt Kmistyrose = 0xe1e4ff;
+ const TInt Kmoccasin = 0xb5e4ff;
+ const TInt Knavajowhite = 0xaddeff;
+ const TInt Knavy = 0x800000;
+ const TInt Koldlace = 0xe6f5fd;
+ const TInt Kolive = 0x008080;
+ const TInt Kolivedrab = 0x238e6b;
+ const TInt Korange = 0x00a5ff;
+ const TInt Korangered = 0x0045ff;
+ const TInt Korchid = 0xd670da;
+ const TInt Kpalegoldenrod = 0xaae8ee;
+ const TInt Kpalegreen = 0x98fb98;
+ const TInt Kpaleturquoise = 0xeeeeaf;
+ const TInt Kpalevioletred = 0x9370db;
+ const TInt Kpapayawhip = 0xd5efff;
+ const TInt Kpeachpuff = 0xb9daff;
+ const TInt Kperu = 0x3f85cd;
+ const TInt Kpink = 0xcbc0ff;
+ const TInt Kplum = 0xdda0dd;
+ const TInt Kpowderblue = 0xe6e0b0;
+ const TInt Kpurple = 0x800080;
+ const TInt Kred = 0x0000ff;
+ const TInt Krosybrown = 0x8f8fbc;
+ const TInt Kroyalblue = 0xe16941;
+ const TInt Ksaddlebrown = 0x13458b;
+ const TInt Ksalmon = 0x7280fa;
+ const TInt Ksandybrown = 0x60a4f4;
+ const TInt Kseagreen = 0x578b2e;
+ const TInt Kseashell = 0xeef5ff;
+ const TInt Ksienna = 0x2d52a0;
+ const TInt Ksilver = 0xc0c0c0;
+ const TInt Kskyblue = 0xebce87;
+ const TInt Kslateblue = 0xcd5a6a;
+ const TInt Kslategray = 0x908070;
+ const TInt Kslategrey = 0x908070;
+ const TInt Ksnow = 0xfafaff;
+ const TInt Kspringgreen = 0x7fff00;
+ const TInt Ksteelblue = 0xb48246;
+ const TInt Ktan = 0x8cb4d2;
+ const TInt Kteal = 0x808000;
+ const TInt Kthistle = 0xd8bfd8;
+ const TInt Ktomato = 0x4763ff;
+ const TInt Kturquoise = 0xd0e040;
+ const TInt Kviolet = 0xee82ee;
+ const TInt Kwheat = 0xb3def5;
+ const TInt Kwhite = 0xffffff;
+ const TInt Kwhitesmoke = 0xf5f5f5;
+ const TInt Kyellow = 0x00ffff;
+ const TInt Kyellowgreen = 0x32cd9a;
+ }
+
+// ======== LOCAL FUNCTIONS ========
+
+// -----------------------------------------------------------------------------
+// MatchColor
+// -----------------------------------------------------------------------------
+//
+static TBool MatchColor( const TDesC8& aColorName, TRgb& aValue )
+ {
+ // Following local macro is used to generate large if-table.
+ #define E( name ) else if ( aColorName == XnColorNames::name ) \
+ { \
+ aValue = TRgb( XnColorValues::name ); \
+ return ETrue; \
+ }
+
+ if ( EFalse )
+ {
+ }
+ E( Kaliceblue )
+ E( Kantiquewhite )
+ E( Kaqua )
+ E( Kaquamarine )
+ E( Kazure )
+ E( Kbeige )
+ E( Kbisque )
+ E( Kblack )
+ E( Kblanchedalmond )
+ E( Kblue )
+ E( Kblueviolet )
+ E( Kbrown )
+ E( Kburlywood )
+ E( Kcadetblue )
+ E( Kchartreuse )
+ E( Kchocolate )
+ E( Kcoral )
+ E( Kcornflowerblue )
+ E( Kcornsilk )
+ E( Kcrimson )
+ E( Kcyan )
+ E( Kdarkblue )
+ E( Kdarkcyan )
+ E( Kdarkgoldenrod )
+ E( Kdarkgray )
+ E( Kdarkgreen )
+ E( Kdarkgrey )
+ E( Kdarkkhaki )
+ E( Kdarkmagenta )
+ E( Kdarkolivegreen )
+ E( Kdarkorange )
+ E( Kdarkorchid )
+ E( Kdarkred )
+ E( Kdarksalmon )
+ E( Kdarkseagreen )
+ E( Kdarkslateblue )
+ E( Kdarkslategray )
+ E( Kdarkslategrey )
+ E( Kdarkturquoise )
+ E( Kdarkviolet )
+ E( Kdeeppink )
+ E( Kdeepskyblue )
+ E( Kdimgray )
+ E( Kdimgrey )
+ E( Kdodgerblue )
+ E( Kfirebrick )
+ E( Kfloralwhite )
+ E( Kforestgreen )
+ E( Kfuchsia )
+ E( Kgainsboro )
+ E( Kghostwhite )
+ E( Kgold )
+ E( Kgoldenrod )
+ E( Kgray )
+ E( Kgreen )
+ E( Kgreenyellow )
+ E( Kgrey )
+ E( Khoneydew )
+ E( Khotpink )
+ E( Kindianred )
+ E( Kindigo )
+ E( Kivory )
+ E( Kkhaki )
+ E( Klavender )
+ E( Klavenderblush )
+ E( Klawngreen )
+ E( Klemonchiffon )
+ E( Klightblue )
+ E( Klightcoral )
+ E( Klightcyan )
+ E( Klightgoldenrodyellow )
+ E( Klightgray )
+ E( Klightgreen )
+ E( Klightgrey )
+ E( Klightpink )
+ E( Klightsalmon )
+ E( Klightseagreen )
+ E( Klightskyblue )
+ E( Klightslategray )
+ E( Klightslategrey )
+ E( Klightsteelblue )
+ E( Klightyellow )
+ E( Klime )
+ E( Klimegreen )
+ E( Klinen )
+ E( Kmagenta )
+ E( Kmaroon )
+ E( Kmediumaquamarine )
+ E( Kmediumblue )
+ E( Kmediumorchid )
+ E( Kmediumpurple )
+ E( Kmediumseagreen )
+ E( Kmediumslateblue )
+ E( Kmediumspringgreen )
+ E( Kmediumturquoise )
+ E( Kmediumvioletred )
+ E( Kmidnightblue )
+ E( Kmintcream )
+ E( Kmistyrose )
+ E( Kmoccasin )
+ E( Knavajowhite )
+ E( Knavy )
+ E( Koldlace )
+ E( Kolive )
+ E( Kolivedrab )
+ E( Korange )
+ E( Korangered )
+ E( Korchid )
+ E( Kpalegoldenrod )
+ E( Kpalegreen )
+ E( Kpaleturquoise )
+ E( Kpalevioletred )
+ E( Kpapayawhip )
+ E( Kpeachpuff )
+ E( Kperu )
+ E( Kpink )
+ E( Kplum )
+ E( Kpowderblue )
+ E( Kpurple )
+ E( Kred )
+ E( Krosybrown )
+ E( Kroyalblue )
+ E( Ksaddlebrown )
+ E( Ksalmon )
+ E( Ksandybrown )
+ E( Kseagreen )
+ E( Kseashell )
+ E( Ksienna )
+ E( Ksilver )
+ E( Kskyblue )
+ E( Kslateblue )
+ E( Kslategray )
+ E( Kslategrey )
+ E( Ksnow )
+ E( Kspringgreen )
+ E( Ksteelblue )
+ E( Ktan )
+ E( Kteal )
+ E( Kthistle )
+ E( Ktomato )
+ E( Kturquoise )
+ E( Kviolet )
+ E( Kwheat )
+ E( Kwhite )
+ E( Kwhitesmoke )
+ E( Kyellow )
+ E( Kyellowgreen )
+ else
+ {
+ return EFalse;
+ }
+ #undef E
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// FindResource
+// Locates a resource from the resource list
+// -----------------------------------------------------------------------------
+//
+EXPORT_C CXnResource* CXnUtils::FindResource(
+ CArrayPtrSeg< CXnResource >& aArray,
+ const TDesC& aResourceFileName,
+ TInt& aBitmapIndex )
+ {
+ if ( aResourceFileName == KNullDesC )
+ {
+ return NULL;
+ }
+
+ TUriParser parser;
+ parser.Parse( aResourceFileName );
+
+ TPtrC uriWithoutFragment;
+ parser.UriWithoutFragment( uriWithoutFragment );
+
+ const TDesC& fragment( parser.Extract( EUriFragment ) );
+
+ TLex lex( fragment );
+ lex.Val( aBitmapIndex );
+
+ for ( TInt i = aArray.Count() - 1; i >= 0; --i )
+ {
+ CXnResource* res( aArray.At( i ) );
+
+ const TDesC& resId( res->ResourceId() );
+
+ if ( resId.FindF( uriWithoutFragment ) != KErrNotFound )
+ {
+ return res;
+ }
+ }
+
+ return NULL;
+ }
+
+// -----------------------------------------------------------------------------
+// DecimalFromHexChar
+// -----------------------------------------------------------------------------
+//
+static TBool DecimalFromHexChar( TChar aChar, TInt& aValue )
+ {
+ switch ( aChar )
+ {
+ case 'a':
+ case 'A':
+ aValue = 10;
+ return ETrue;
+ case 'b':
+ case 'B':
+ aValue = 11;
+ return ETrue;
+ case 'c':
+ case 'C':
+ aValue = 12;
+ return ETrue;
+ case 'd':
+ case 'D':
+ aValue = 13;
+ return ETrue;
+ case 'e':
+ case 'E':
+ aValue = 14;
+ return ETrue;
+ case 'f':
+ case 'F':
+ aValue = 15;
+ return ETrue;
+ case '0':
+ aValue = 0;
+ return ETrue;
+ case '1':
+ aValue = 1;
+ return ETrue;
+ case '2':
+ aValue = 2;
+ return ETrue;
+ case '3':
+ aValue = 3;
+ return ETrue;
+ case '4':
+ aValue = 4;
+ return ETrue;
+ case '5':
+ aValue = 5;
+ return ETrue;
+ case '6':
+ aValue = 6;
+ return ETrue;
+ case '7':
+ aValue = 7;
+ return ETrue;
+ case '8':
+ aValue = 8;
+ return ETrue;
+ case '9':
+ aValue = 9;
+ return ETrue;
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// NumericOrHexValue
+// -----------------------------------------------------------------------------
+//
+static TInt NumericOrHexValue( TReal& aValue, TLex8& aData )
+ {
+ TBool isHex = EFalse;
+ TInt hexIndex = 0;
+ TPtrC8 data = aData.Remainder();
+ TInt separatorIndex = 0;
+ if ( ( hexIndex = data.LocateF( '#' ) ) != KErrNotFound &&
+ ( ( separatorIndex = data.LocateF( ',' ) ) != KErrNotFound ||
+ ( separatorIndex = data.LocateF( ')' ) ) != KErrNotFound ) &&
+ ( separatorIndex > hexIndex ) )
+ {
+ isHex = ETrue;
+ }
+ if ( !isHex )
+ {
+ return aData.Val( aValue );
+ }
+ else
+ {
+ TChar character = aData.Get();
+ if ( character == 0 )
+ {
+ return KErrGeneral;
+ }
+ character = aData.Get();
+ if ( character == 0 )
+ {
+ return KErrGeneral;
+ }
+ TChar secondCharacter = aData.Get();
+ if ( secondCharacter == 0 )
+ {
+ return KErrGeneral;
+ }
+ TInt val;
+ TInt secondVal;
+ if ( DecimalFromHexChar( character, val ) &&
+ DecimalFromHexChar( secondCharacter, secondVal ) )
+ {
+ aValue = 16 * val + secondVal;
+ return KErrNone;
+ }
+ }
+ return KErrGeneral;
+ }
+
+// -----------------------------------------------------------------------------
+// DecimalValueOrPercentage
+// -----------------------------------------------------------------------------
+//
+static TInt DecimalValueOrPercentage( TInt& aValue, TLex8& aData )
+ {
+ TBool isPercentage = EFalse;
+ TInt separatorIndex = 0;
+ TInt percentageIndex = 0;
+ TPtrC8 data = aData.Remainder();
+ if ( ( percentageIndex = data.LocateF( '%' ) ) != KErrNotFound &&
+ ( ( separatorIndex = data.LocateF( ',' ) ) != KErrNotFound ||
+ ( separatorIndex = data.LocateF( ')' ) ) != KErrNotFound ) &&
+ ( separatorIndex > percentageIndex ) )
+ {
+ isPercentage = ETrue;
+ }
+ TReal tmp;
+ TInt error = NumericOrHexValue( tmp, aData );
+ if ( error != KErrNone )
+ {
+ return error;
+ }
+ if ( !isPercentage )
+ {
+ aValue = static_cast< TInt >( tmp );
+ }
+ else
+ {
+ aValue = static_cast< TInt >( ( tmp / 100.0 ) * 255.0 );
+ }
+ return KErrNone;
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValueFromColorName
+// -----------------------------------------------------------------------------
+//
+static TBool GetRgbValueFromColorName( TRgb& aValue, const TDesC8& aData )
+ {
+ return MatchColor( aData, aValue );
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValueFromDecimalValues
+// -----------------------------------------------------------------------------
+//
+static TBool GetRgbValueFromDecimalValues( TRgb& aValue, const TDesC8& aData )
+ {
+ TLex8 lex( aData );
+ TInt red;
+ TInt green;
+ TInt blue;
+ lex.SkipSpace();
+ TInt error = DecimalValueOrPercentage( red, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ lex.SkipSpace();
+ while ( lex.Peek() == ',' || lex.Peek() == '%' )
+ {
+ lex.Get();
+ lex.SkipSpace();
+ }
+ error = DecimalValueOrPercentage( green, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ lex.SkipSpace();
+ while ( lex.Peek() == ',' || lex.Peek() == '%' )
+ {
+ lex.Get();
+ lex.SkipSpace();
+ }
+ error = DecimalValueOrPercentage( blue, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ aValue.SetRed( red );
+ aValue.SetGreen( green );
+ aValue.SetBlue( blue );
+ return ETrue;
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValueFromRgbFunction
+// -----------------------------------------------------------------------------
+//
+static TBool GetRgbValueFromRgbFunction( TRgb& aValue, const TDesC8& aData )
+ {
+ TInt functionNameIndex = 0;
+ TInt openingParenthesisIndex = 0;
+ TInt closingParenthesisIndex = 0;
+ if ( ( functionNameIndex = aData.FindF( _L8( "rgb" ) ) ) != KErrNotFound &&
+ ( openingParenthesisIndex = aData.FindF( _L8( "(" ) ) ) != KErrNotFound &&
+ ( openingParenthesisIndex > functionNameIndex ) &&
+ ( closingParenthesisIndex = aData.FindF( _L8( ")" ) ) ) != KErrNotFound &&
+ ( closingParenthesisIndex > openingParenthesisIndex ) )
+ {
+ TPtrC8 functionString = aData.Mid(
+ openingParenthesisIndex + 1,
+ closingParenthesisIndex - openingParenthesisIndex );
+ return GetRgbValueFromDecimalValues( aValue, functionString );
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValueFromHslFunction
+// -----------------------------------------------------------------------------
+//
+static TBool GetRgbValueFromHslFunction( TRgb& aValue, const TDesC8& aData )
+ {
+ TInt functionNameIndex = 0;
+ TInt openingParenthesisIndex = 0;
+ TInt closingParenthesisIndex = 0;
+ if ( ( functionNameIndex = aData.FindF( _L8( "hsl" ) ) ) != KErrNotFound &&
+ ( openingParenthesisIndex = aData.FindF( _L8( "(" ) ) ) != KErrNotFound &&
+ ( openingParenthesisIndex > functionNameIndex ) &&
+ ( closingParenthesisIndex = aData.FindF( _L8( ")" ) ) ) != KErrNotFound &&
+ ( closingParenthesisIndex > openingParenthesisIndex ) )
+ {
+ TPtrC8 functionString = aData.Mid(
+ openingParenthesisIndex + 1,
+ closingParenthesisIndex - openingParenthesisIndex );
+ TRgb rgb;
+ TBool success = GetRgbValueFromDecimalValues( rgb, functionString );
+
+ TLex8 lex( functionString );
+ TInt red;
+ TInt green;
+ TInt blue;
+ lex.SkipSpace();
+ TReal tmp;
+
+ TInt error = NumericOrHexValue( tmp, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ red = static_cast< TInt >( tmp );
+ lex.SkipSpace();
+ while ( lex.Peek() == ',' || lex.Peek() == '%' )
+ {
+ lex.Get();
+ lex.SkipSpace();
+ }
+ error = NumericOrHexValue( tmp, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ green = static_cast< TInt >( tmp );
+ lex.SkipSpace();
+ while ( lex.Peek() == ',' || lex.Peek() == '%' )
+ {
+ lex.Get();
+ lex.SkipSpace();
+ }
+ error = NumericOrHexValue( tmp, lex );
+ if ( error != KErrNone )
+ {
+ return EFalse;
+ }
+ blue = static_cast< TInt >( tmp );
+
+ if ( success )
+ {
+ aValue = CXnUtils::ConvertHslToRgb( red, green, blue );
+ }
+ return success;
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValueFromHexValue
+// -----------------------------------------------------------------------------
+//
+static TBool GetRgbValueFromHexValue( TRgb& aValue, const TDesC8& aData )
+ {
+ TBool isHex = EFalse;
+ if ( aData.LocateF( '#' ) != KErrNotFound )
+ {
+ isHex = ETrue;
+ }
+ if ( !isHex )
+ {
+ return EFalse;
+ }
+ else
+ {
+ TInt length = aData.Length();
+ TLex8 lex( aData );
+ lex.SkipSpace();
+ if ( lex.Get() == 0 )
+ {
+ return EFalse;
+ }
+ TInt values[3];
+ TBool flags[3] = { EFalse, EFalse, EFalse };
+ TChar chars[6] = { 0, 0, 0, 0, 0, 0 };
+ for ( TInt i = 5; i >= 0; --i )
+ {
+ TChar character = lex.Get();
+ if ( character == 0 )
+ {
+ break;
+ }
+ chars[i] = character;
+ if ( length == 4 )
+ {
+ i--;
+ chars[i] = character;
+ }
+ }
+
+ for ( TInt i = 5, j = 0; ( i >= 0 ) && ( j < 3 ); --i )
+ {
+ if ( chars[i] == 0 )
+ {
+ continue;
+ }
+ if ( i % 2 )
+ {
+ TInt secondVal = 0;
+ TInt val = 0;
+ TChar secondCharacter = chars[i];
+ --i;
+ TChar character = chars[i];
+ if ( DecimalFromHexChar( character, val ) &&
+ DecimalFromHexChar( secondCharacter, secondVal ) )
+ {
+ values[j] = val + 16 * secondVal;
+ flags[j] = ETrue;
+ ++j;
+ }
+ else
+ {
+ break;
+ }
+ }
+ else
+ {
+ TInt val = 0;
+ TChar character = chars[i];
+ if ( DecimalFromHexChar( character, val ) )
+ {
+ values[j] = val;
+ flags[j] = ETrue;
+ ++j;
+ }
+ else
+ {
+ break;
+ }
+ }
+ }
+ if ( flags[2] && flags[1] && flags[0] )
+ {
+ aValue.SetRed( values[0] );
+ aValue.SetGreen( values[1] );
+ aValue.SetBlue( values[2] );
+ return ETrue;
+ }
+ else if ( flags[1] && flags[0] )
+ {
+ aValue.SetRed( 0 );
+ aValue.SetGreen( values[0] );
+ aValue.SetBlue( values[1] );
+ return ETrue;
+ }
+ else if ( flags[0] )
+ {
+ aValue.SetRed( 0 );
+ aValue.SetGreen( 0 );
+ aValue.SetBlue( values[0] );
+ return ETrue;
+ }
+ }
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// Finds out AVKON font ID from fontname
+// -----------------------------------------------------------------------------
+//
+static TInt AvkonFontId( const TDesC& aFontName )
+ {
+ TInt fontId( KErrNotFound );
+ if ( aFontName == KPrimaryFont )
+ {
+ fontId = KAknFontCategoryPrimary;
+ }
+ else if ( aFontName == KSecondaryFont )
+ {
+ fontId = KAknFontCategorySecondary;
+ }
+ else if ( aFontName == KTitleFont )
+ {
+ fontId = KAknFontCategoryTitle;
+ }
+ else if ( aFontName == KPrimarySmallFont )
+ {
+ fontId = KAknFontCategoryPrimarySmall;
+ }
+ else if ( aFontName == KDigitalFont )
+ {
+ fontId = KAknFontCategoryDigital;
+ }
+ return fontId;
+ }
+
+// -----------------------------------------------------------------------------
+// TRgb CXnUtils::ConvertHslToRgb( TInt aHue, TInt aSaturation,
+// TInt aLightness )
+// Perform the HSL to RGB conversion according to
+// the rules defined in the CSS3 color module specification:
+// http://www.w3.org/TR/2003/CR-css3-color-20030514/#hsl-color
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TRgb CXnUtils::ConvertHslToRgb(
+ TInt aHue, TInt aSaturation, TInt aLightness )
+ {
+ TRgb rgb( 0, 0, 0 );
+ TReal h( aHue );
+ h /= 360;
+ TReal s( aSaturation );
+ s /= 100;
+ TReal l( aLightness );
+ l /= 100;
+
+ if ( 0 == aSaturation )
+ {
+ rgb.SetRed( TInt( l * 255 ) );
+ rgb.SetGreen( TInt( l * 255 ) );
+ rgb.SetBlue( TInt( l * 255 ) );
+ }
+ else
+ {
+ TReal m1( 0 );
+ TReal m2( 0 );
+
+ // l<=0.5: PUT l*(s+1) IN m2
+ if ( aLightness < 0.5 )
+ {
+ m2 = l * ( s + 1.0 );
+ }
+ // PUT l+s-l*s IN m2
+ else
+ {
+ m2 = l + s - ( l * s );
+ }
+
+ // PUT l*2-m2 IN m1
+ m1 = l * 2.0 - m2;
+
+ TReal helperH( h );
+ TReal helperM1( m1 );
+ TReal helperM2( m2 );
+
+ // calculate Red
+ helperH = h + ( 1.0 / 3.0 );
+
+ // IF h<0: PUT h+1 IN h
+ if ( helperH < 0 )
+ {
+ helperH += 1.0;
+ }
+
+ // IF h>1: PUT h-1 IN h
+ else if ( helperH > 1 )
+ {
+ helperH -= 1.0;
+ }
+ else
+ {
+ }
+
+ TReal val( 0 );
+
+ // IF h*6<1: RETURN m1+(m2-m1)*h*6
+ if ( ( helperH * 6 ) < 1 )
+ {
+ val = ( 255 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) );
+ }
+
+ // IF h*2<1: RETURN m2 )
+ else if ( ( helperH * 2.0 ) < 1.0 )
+ {
+ val = ( 255.0 * helperM2 );
+ }
+
+ // IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6
+ else if ( ( helperH * 3.0 ) < 2.0 )
+ {
+ val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) *
+ ( 2.0 / 3.0 - helperH ) * 6.0 ) );
+ }
+ else
+ {
+ val = 255.0 * helperM1;
+ }
+ TInt tmpVal = TInt( val + 0.5 );
+ rgb.SetRed( ( tmpVal >= 0 ) ? tmpVal : -tmpVal );
+
+ // calculate Green
+ // PUT hue.to.rgb(m1, m2, h ) IN g
+ helperH = h;
+ helperM1 = m1;
+ helperM2 = m2;
+
+ // IF h<0: PUT h+1 IN h
+ if ( helperH < 0 )
+ {
+ helperH += 1.0;
+ }
+
+ // IF h>1: PUT h-1 IN h
+ else if ( helperH > 1 )
+ {
+ helperH -= 1.0;
+ }
+ else
+ {
+ }
+
+ // IF h*6<1: RETURN m1+(m2-m1)*h*6
+ if ( ( helperH * 6 ) < 1 )
+ {
+ val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) );
+ }
+
+ // IF h*2<1: RETURN m2
+ else if ( ( helperH * 2 ) < 1 )
+ {
+ val = ( 255.0 * helperM2 );
+ }
+
+ // IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6
+ else if ( ( helperH * 3 ) < 2 )
+ {
+ val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) *
+ ( 2.0 / 3.0 - helperH ) * 6.0 ) );
+ }
+ else
+ {
+ val = 255.0 * helperM1;
+ }
+
+ tmpVal = TInt( val + 0.5 );
+ rgb.SetGreen( ( tmpVal >= 0 ) ? tmpVal : tmpVal );
+
+ // calculate Blue
+ // PUT hue.to.rgb(m1, m2, h-1/3) IN b
+ helperH = h - ( 1.0 / 3.0 );
+ helperM1 = m1;
+ helperM2 = m2;
+
+ // IF h<0: PUT h+1 IN h
+ if ( helperH < 0 )
+ {
+ helperH += 1.0;
+ }
+
+ // IF h>1: PUT h-1 IN h
+ else if ( helperH > 1 )
+ {
+ helperH -= 1.0;
+ }
+ else
+ {
+ }
+
+ // IF h*6<1: RETURN m1+(m2-m1)*h*6
+ if ( ( helperH * 6 ) < 1 )
+ {
+ val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) );
+ }
+
+ // IF h*2<1: RETURN m2
+ else if ( ( helperH * 2 ) < 1 )
+ {
+ val = ( 255.0 * helperM2 );
+ }
+
+ // IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6
+ else if ( ( helperH * 3 ) < 2 )
+ {
+ val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) *
+ ( 2.0 / 3.0 - helperH ) * 6.0 ) );
+ }
+ else
+ {
+ val = 255.0 * helperM1;
+ }
+
+ tmpVal = TInt( val + 0.5 );
+ rgb.SetBlue( ( tmpVal >= 0 ) ? tmpVal : -tmpVal );
+ }
+ return rgb;
+ }
+
+// -----------------------------------------------------------------------------
+// GetRgbValue
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CXnUtils::GetRgbValue( TRgb& aValue, const TDesC8& aData )
+ {
+ return GetRgbValueFromRgbFunction( aValue, aData ) ||
+ GetRgbValueFromHslFunction( aValue, aData ) ||
+ GetRgbValueFromHexValue( aValue, aData ) ||
+ GetRgbValueFromColorName( aValue, aData );
+ }
+
+// -----------------------------------------------------------------------------
+// Retrieves the string property of the node.
+// -----------------------------------------------------------------------------
+//
+const TDesC8& GetStringProperty(
+ CXnNodePluginIf& aNode,
+ const TDesC8& aProperty )
+ {
+ CXnProperty* prop( NULL );
+ TRAP_IGNORE( prop = aNode.GetPropertyL( aProperty ) );
+ if ( prop )
+ {
+ CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(
+ prop->Property()->PropertyValueList().Item( 0 ) );
+ if ( CXnDomPropertyValue::EIdent == value->PrimitiveValueType() ||
+ CXnDomPropertyValue::EString == value->PrimitiveValueType() )
+ {
+ return prop->StringValue();
+ }
+ }
+ return KNullDesC8;
+ }
+
+// ======== MEMBER FUNCTIONS ========
+
+// -----------------------------------------------------------------------------
+// Creates the font according to node information.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CXnUtils::CreateFontL(
+ CXnNodePluginIf& aNode,
+ CFont*& aFont,
+ TInt& aReleaseFont )
+ {
+ // Get the font properties from node
+ TFontSpec fontspec;
+
+ //Font name
+ const TDesC8& fontNameS = GetStringProperty(
+ aNode, XnPropertyNames::appearance::common::KFontFamily );
+ HBufC* fontName = HBufC::NewLC( fontNameS.Length() );
+ TPtr namePtr = fontName->Des();
+ namePtr.Copy( fontNameS ); // 8-bit to 16-bit
+ StripQuotes( fontName );
+ TInt fLenght = fontName->Length();
+ TInt avkonFId = AvkonFontId( *fontName );
+
+ //let's see if normal font needed
+ CCoeEnv* coeEnv = CEikonEnv::Static();
+ if ( *fontName == KNormal ||
+ !fLenght ||
+ ( KErrNotFound == avkonFId && fLenght > 24 ) )
+ {
+ aFont = const_cast< CFont* >( coeEnv->NormalFont() );
+ aReleaseFont = EFalse;
+ CleanupStack::PopAndDestroy( fontName );
+ return;
+ }
+
+ //Font size in pixels
+ CXnProperty* fontSizeProp = aNode.GetPropertyL(
+ XnPropertyNames::appearance::common::KFontSize );
+ TInt fontSizeInPixels( aNode.Rect().Height() );//default font size
+
+ if ( fontSizeProp )
+ { //font size from node if needed. If leaves uses default.
+ TRAP_IGNORE( fontSizeInPixels = aNode.UiEngineL()->VerticalPixelValueL(
+ fontSizeProp, aNode.Rect().Height()) );
+ }
+
+ //Font stroke
+ const TDesC8& fontStroke = GetStringProperty(
+ aNode, XnPropertyNames::appearance::common::KFontWeight );
+ if ( fontStroke == XnPropertyNames::appearance::common::fontweight::KBold )
+ {
+ fontspec.iFontStyle.SetStrokeWeight( EStrokeWeightBold );
+ }
+
+ //Font posture
+ const TDesC8& fontPosture = GetStringProperty(
+ aNode, XnPropertyNames::appearance::common::KFontStyle );
+ if ( fontPosture == XnPropertyNames::appearance::common::fontstyle::KItalic )
+ {
+ fontspec.iFontStyle.SetPosture( EPostureItalic );
+ }
+
+ //Font effects
+ CXnProperty* textEffectsProp = aNode.GetPropertyL(
+ XnPropertyNames::appearance::common::KTextEffects );
+ if ( textEffectsProp )
+ {
+ CBitmapDevice* dev = coeEnv->ScreenDevice();
+ fontspec.iHeight = fontSizeInPixels;
+
+ CXnDomList& propertyValueList =
+ textEffectsProp->Property()->PropertyValueList();
+ TInt valueCount = propertyValueList.Length();
+ TUint32 effectsFlag( 0 );
+
+ for ( TInt i = 0; i < valueCount; ++i )
+ {
+ CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >(
+ propertyValueList.Item( i ) );
+
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsAlgorithmicbold )
+ {
+ effectsFlag |= FontEffect::EAlgorithmicBold;
+ }
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsDropshadow )
+ {
+ effectsFlag |= FontEffect::EDropShadow;
+ }
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsOutline )
+ {
+ effectsFlag |= FontEffect::EOutline;
+ }
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsEmbossed )
+ {
+ effectsFlag |= FontEffect::EEmbossed;
+ }
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsEngraved )
+ {
+ effectsFlag |= FontEffect::EEngraved;
+ }
+ if ( value->StringValueL() ==
+ XnPropertyNames::appearance::common::fonteffects::KEffectsSoftedge )
+ {
+ effectsFlag |= FontEffect::ESoftEdge;
+ }
+ }
+ // Must be antialiased for effects to work
+ fontspec.iFontStyle.SetBitmapType( EAntiAliasedGlyphBitmap );
+ fontspec.iFontStyle.SetEffects( effectsFlag );
+ User::LeaveIfError( dev->GetNearestFontToDesignHeightInPixels(
+ aFont, fontspec ) );
+ aReleaseFont = ETrue;
+ }
+ else
+ {
+ CreateFontL( *fontName, fontSizeInPixels,
+ fontspec.iFontStyle, aFont, aReleaseFont );
+ }
+
+ CleanupStack::PopAndDestroy( fontName );
+ }
+
+// -----------------------------------------------------------------------------
+// Creates the font according to given information.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CXnUtils::CreateFontL(
+ const TDesC& aFontName,
+ TInt aFontSizeInPixels,
+ TFontStyle aFontStyle,
+ CFont*& aFont,
+ TInt& aReleaseFont )
+ {
+ CCoeEnv* coeEnv = CEikonEnv::Static();
+ if ( aFontName == KNormal || !aFontName.Length() )
+ {
+ aFont = const_cast< CFont* >( coeEnv->NormalFont() );
+ aReleaseFont = EFalse;
+ }
+ else
+ {
+ //Avkon font id used
+ TInt fontId = AvkonFontId( aFontName );
+ if ( fontId != KErrNotFound )
+ {
+ fontId += ( ( aFontSizeInPixels & 0x3ff ) << 21 ) +
+ ( ( aFontStyle.StrokeWeight() & 0x1 ) << 4 ) +
+ ( ( aFontStyle.Posture() & 0x1 ) << 5 ) + 0x80000000;
+ aFont = const_cast< CFont* >( AknLayoutUtils::FontFromId( fontId ));
+ aReleaseFont = EFalse;
+ }
+ else
+ {
+ //Get font
+ CBitmapDevice* dev = coeEnv->ScreenDevice();
+ TInt fontSizeInTwips = dev->VerticalPixelsToTwips( aFontSizeInPixels );
+ aFont = AknFontAccess::GetFont(
+ *dev, aFontStyle, fontSizeInTwips, aFontName );
+ if ( !aFont )
+ {
+ aFont = AknFontAccess::GetClosestFont( *dev, aFontStyle,
+ fontSizeInTwips, aFontName );
+ }
+ aReleaseFont = ETrue;
+ }
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Collapses white spaces from the string.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CXnUtils::CollapseWhiteSpace(
+ CXnNodePluginIf& aNode,
+ TDes &aDes )
+ {
+ const TDesC8& value = GetStringProperty( aNode,
+ XnPropertyNames::appearance::common::KWhiteSpaceCollapse );
+
+ //Collapse -default
+ if ( value == XnPropertyNames::appearance::common::whitespace::KCollapse ||
+ !value.Length() )
+ {
+ TInt src = 0;
+ TInt srclength = aDes.Length();
+ while ( src < srclength )
+ {
+ TChar c = aDes[src];
+ if ( KXnLineFeedTabCharacters().LocateF( c ) != KErrNotFound )
+ {
+ aDes[src] = KSpaceChar;
+ }
+ ++src;
+ }
+ aDes.TrimAll();
+ }
+ //Preserve breaks
+ else if ( value ==
+ XnPropertyNames::appearance::common::whitespace::KPreserveBreaks )
+ {
+ TInt src = 0;
+ TInt srclength = aDes.Length();
+ while ( src < srclength )
+ {
+ TChar c = aDes[src];
+ if ( KXnTabCharacters().LocateF( c ) != KErrNotFound )
+ {
+ aDes[src] = KSpaceChar;
+ }
+ ++src;
+ }
+ aDes.TrimAll();
+ }
+ //discard
+ else if ( value == XnPropertyNames::appearance::common::whitespace::KDiscard )
+ {
+ TInt target = 0;
+ TInt src = 0;
+ TInt srclength = aDes.Length();
+ while ( src < srclength )
+ {
+ aDes[target] = aDes[src];
+ TChar c = aDes[src];
+ if ( KXnCommonWhiteSpaceCharacters().LocateF( c ) == KErrNotFound )
+ {
+ ++target;
+ }
+ ++src;
+ }
+ aDes.SetLength( target );
+ }
+ //Preserve
+ //Do nothing.
+ }
+
+// -----------------------------------------------------------------------------
+// Resolve TextAlignment property.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TGulAlignmentValue CXnUtils::TextAlignment( CXnNodePluginIf& aNode )
+ {
+ TInt value;
+
+ const TDesC8& alignment = GetStringProperty( aNode,
+ XnPropertyNames::appearance::common::KTextAlign );
+
+ if ( alignment ==
+ XnPropertyNames::appearance::common::textalign::KAlignLeft )
+ {
+ value = EHLeft;
+ }
+ else if ( alignment ==
+ XnPropertyNames::appearance::common::textalign::KAlignRight )
+ {
+ value = EHRight;
+ }
+ else if ( alignment ==
+ XnPropertyNames::appearance::common::textalign::KAlignCenter )
+ {
+ value = EHCenter;
+ }
+ else if ( alignment ==
+ XnPropertyNames::appearance::common::textalign::KAlignJustify )
+ {
+ //We don't have EJustify
+ value = EHCenter;
+ }
+ else
+ {
+ if ( AknLayoutUtils::LayoutMirrored() )
+ {
+ value = EHRight;
+ }
+ else
+ {
+ value = EHLeft;
+ }
+ }
+
+ const TDesC8& valignment = GetStringProperty( aNode,
+ XnPropertyNames::appearance::common::KS60TextVAlign );
+
+ if ( valignment ==
+ XnPropertyNames::appearance::common::textvalign::KAlignTop )
+ {
+ value |= EVTop;
+ }
+ else if ( valignment ==
+ XnPropertyNames::appearance::common::textvalign::KAlignBottom )
+ {
+ value |= EVBottom;
+ }
+ else
+ {
+ value |= EVCenter;
+ }
+
+ return ( TGulAlignmentValue )value;
+ }
+
+// -----------------------------------------------------------------------------
+// ScaleBitmapL
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CXnUtils::ScaleBitmapL(
+ const TRect& aTrgRect,
+ CFbsBitmap* aTrgBitmap,
+ CFbsBitmap* aSrcBitmap )
+ {
+ CXnUtils::ScaleBitmapExtL( aTrgRect, aTrgBitmap, aSrcBitmap, EFalse );
+ }
+
+// -----------------------------------------------------------------------------
+// Strips the " and ' quotes from the string.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C void CXnUtils::StripQuotes( HBufC*& aString )
+ {
+ TInt pos1 = aString->Locate( '\"' );
+ TInt pos2 = aString->Locate( '\'' );
+ // check, if the first character is " or '
+ if ( pos1 == 0 || pos2 == 0 )
+ {
+ TInt len = aString->Length() - 2;
+ TPtr ptr = aString->Des();
+ TPtrC16 newString( aString->Mid( 1, len ).Ptr(), len );
+ ptr = newString;
+ }
+ }
+
+// -----------------------------------------------------------------------------
+// Resolves skin id (major+minor) and index from SKIN() declaration.
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CXnUtils::ResolveSkinItemIDL(
+ const TDesC& aSkinId,
+ TAknsItemID& aItemID,
+ TInt& aIndex )
+ {
+ HBufC* str = aSkinId.AllocL();
+ TPtr ptrSkin = str->Des();
+ ptrSkin.TrimAll();
+ TInt pos( ptrSkin.FindF( KSkin ) );
+ if ( KErrNotFound != pos )
+ {
+ TInt majorID( 0 );
+ TInt minorID( 0 );
+ pos += KSkin().Length();
+ TPtr ptr = ptrSkin.MidTPtr( pos, ( ptrSkin.Length() - pos - 1 ) );
+ ptr.TrimAll();
+ TInt offset( ptr.Locate( KSpaceChar ) );
+ if ( KErrNotFound != offset )
+ {
+ TLex lex( ptr.Left( offset ) );
+ lex.SkipSpace();
+ lex.Val( majorID ); // ok until this.
+
+ TInt offset2( ptr.LocateReverse( KSpaceChar ) );
+ if ( offset2 == 0 || offset2 == offset )
+ {
+ lex.Assign( ptr.Mid( offset ) );
+ lex.SkipSpace();
+ lex.Val( minorID );
+ }
+ else
+ {
+ TPtrC ptrDebug = ptr.Mid( offset + 1, offset2 - offset - 1 );
+ lex.Assign( ptr.Mid( offset + 1, offset2 - offset -1 ) );
+ lex.Val( minorID );
+
+ TPtrC ptrDebug2 = ptr.Mid( offset2 + 1, ptr.Length() - offset2 - 1 );
+ lex.Assign( ptr.Mid( offset2 + 1, ptr.Length() - offset2 - 1 ) );
+ lex.Val( aIndex );
+ }
+ aItemID.Set( majorID, minorID );
+ delete str;
+ return ETrue;
+ }
+ }
+ delete str;
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// Propagates powersave mode to adapters
+// -----------------------------------------------------------------------------
+//
+EXPORT_C TBool CXnUtils::HandlePowerSaveModeL(
+ CXnNode* aNode,
+ TBool aEnter,
+ TInt aEvent )
+ {
+
+ CXnNodeBreadthFirstIterator< CXnNode >* iterator =
+ CXnNodeBreadthFirstIterator< CXnNode >::NewL( *aNode );
+
+ CleanupStack::PushL( iterator );
+
+ for ( CXnNode* currentNode = iterator->Value(); currentNode; currentNode = iterator->NextL() )
+ {
+ if ( !currentNode->ComponentNodeImpl() )
+ {
+ continue;
+ }
+
+ CXnComponent* component = currentNode->ComponentNodeImpl()->Component();
+
+ if ( !component )
+ {
+ continue;
+ }
+
+ CXnControlAdapter* adapter = component->ControlAdapter();
+
+ if ( !adapter )
+ {
+ continue;
+ }
+
+ if ( aEnter )
+ {
+ adapter->EnterPowerSaveModeL(
+ ( CXnControlAdapter::TModeEvent ) aEvent );
+ }
+ else
+ {
+ adapter->ExitPowerSaveModeL(
+ ( CXnControlAdapter::TModeEvent ) aEvent );
+ }
+ }
+
+ CleanupStack::PopAndDestroy( iterator );
+
+ return aEnter;
+ }
+
+// -----------------------------------------------------------------------------
+// Resolves skin id (major+minor) from SKIN() declaration.
+// -----------------------------------------------------------------------------
+//
+TBool CXnUtils::ResolveSkinItemIDL( const TDesC& aSkinId, TAknsItemID& aItemID )
+ {
+ HBufC* str = aSkinId.AllocL();
+ TPtr ptrSkin = str->Des();
+ ptrSkin.TrimAll();
+ TInt pos( ptrSkin.FindF( KSkin ));
+ if ( KErrNotFound != pos )
+ {
+ TInt majorID( 0 );
+ TInt minorID( 0 );
+ pos += KSkin().Length();
+ TPtr ptr = ptrSkin.MidTPtr( pos, ( ptrSkin.Length() - pos - 1 ) );
+ ptr.TrimAll();
+ TInt offset( ptr.Locate( KSpaceChar ) );
+ if ( KErrNotFound != offset )
+ {
+ TLex lex( ptr.Left( offset ) );
+ lex.SkipSpace();
+ lex.Val( majorID );
+ lex.Assign( ptr.Mid( offset ) );
+ lex.SkipSpace();
+ lex.Val( minorID );
+ aItemID.Set( majorID, minorID );
+ delete str;
+ return ETrue;
+ }
+ }
+ delete str;
+ return EFalse;
+ }
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+TBool CXnUtils::DoesScaleBitmapUseFallBack( CFbsBitmap* aSrcBitmap )
+ {
+ if ( !aSrcBitmap )
+ {
+ return EFalse;
+ }
+
+ TDisplayMode displayMode = aSrcBitmap->DisplayMode();
+ TBool fallbackOnly = EFalse;
+
+ switch ( displayMode )
+ {
+ case EGray2:
+ case EGray4:
+ case EGray16:
+ case EColor16:
+ case EColor16M:
+ case ERgb:
+ case EColor16MA:
+ fallbackOnly = ETrue;
+ break;
+ case EGray256:
+ case EColor4K:
+ case EColor64K:
+ case EColor256:
+ case EColor16MU:
+ // These are the supported modes
+ break;
+ default:
+ fallbackOnly = ETrue;
+ }
+
+ return fallbackOnly;
+ }
+
+// -----------------------------------------------------------------------------
+// -----------------------------------------------------------------------------
+//
+void CXnUtils::ScaleBitmapExtL( const TRect& aTrgRect, CFbsBitmap* aTrgBitmap,
+ CFbsBitmap* aSrcBitmap, TBool aForceFallBack )
+ {
+ if ( !aSrcBitmap ) User::Leave( KErrArgument );
+ if ( !aTrgBitmap ) User::Leave( KErrArgument );
+ if ( aSrcBitmap->DisplayMode() != aTrgBitmap->DisplayMode() )
+ {
+ User::Leave( KErrArgument );
+ }
+
+ TSize trgBitmapSize = aTrgBitmap->SizeInPixels();
+
+ // calculate the valid drawing area
+ TRect drawRect = aTrgRect;
+ drawRect.Intersection( TRect( TPoint( 0, 0 ), trgBitmapSize ) );
+
+ if( drawRect.IsEmpty() || aSrcBitmap->SizeInPixels().iHeight <= 0 ||
+ aSrcBitmap->SizeInPixels().iWidth <= 0 )
+ {
+ return;
+ }
+
+ TSize srcSize = aSrcBitmap->SizeInPixels();
+
+ TBool srcTemporary = EFalse;
+ if ( aSrcBitmap->IsRomBitmap() )
+ {
+ srcTemporary = ETrue;
+ }
+
+ TDisplayMode displayMode = aSrcBitmap->DisplayMode();
+ TBool fallbackOnly =
+ aForceFallBack ||
+ DoesScaleBitmapUseFallBack( aSrcBitmap );
+
+ if ( fallbackOnly )
+ {
+ CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( aTrgBitmap );
+ CleanupStack::PushL( dev );
+ CFbsBitGc* gc = NULL;
+ User::LeaveIfError( dev->CreateContext( gc ) );
+ CleanupStack::PushL( gc );
+
+ // write alpha information if it exists
+ if ( aSrcBitmap->DisplayMode() == EColor16MA )
+ {
+ gc->SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );
+ }
+
+ // aTrgRect is used because DrawBitmap handles clipping automatically
+ gc->DrawBitmap( aTrgRect, aSrcBitmap );
+ CleanupStack::PopAndDestroy( 2 ); // dev, gc
+ return;
+ }
+
+ // Heap lock for FBServ large chunk to prevent background
+ // compression of aSrcBitmap after if IsCompressedInRAM returns EFalse
+ aSrcBitmap->LockHeapLC( ETrue ); // fbsheaplock
+ TBool fbsHeapLock = ETrue;
+ if ( aSrcBitmap->IsCompressedInRAM() )
+ {
+ srcTemporary = ETrue;
+ }
+
+ CFbsBitmap* realSource = aSrcBitmap;
+ if ( srcTemporary )
+ {
+ CleanupStack::PopAndDestroy(); // fbsheaplock
+ fbsHeapLock = EFalse;
+
+ realSource = new ( ELeave ) CFbsBitmap();
+ CleanupStack::PushL( realSource );
+ User::LeaveIfError(
+ realSource->Create( srcSize, aSrcBitmap->DisplayMode() ) );
+ CFbsBitmapDevice* dev = CFbsBitmapDevice::NewL( realSource );
+ CleanupStack::PushL( dev );
+ CFbsBitGc* gc = NULL;
+ User::LeaveIfError( dev->CreateContext( gc ) );
+ CleanupStack::PushL( gc );
+ gc->BitBlt( TPoint( 0, 0 ), aSrcBitmap );
+ CleanupStack::PopAndDestroy( 2 ); // dev, gc
+ }
+
+ if ( !fbsHeapLock )
+ {
+ // Heap lock for FBServ large chunk is only needed with large bitmaps.
+ if ( realSource->IsLargeBitmap() || aTrgBitmap->IsLargeBitmap() )
+ {
+ aTrgBitmap->LockHeapLC( ETrue ); // fbsheaplock
+ }
+ else
+ {
+ CleanupStack::PushL( ( TAny* )NULL );
+ }
+ }
+
+ TUint32* srcAddress = realSource->DataAddress();
+ TUint32* trgAddress = aTrgBitmap->DataAddress();
+
+ const TInt xSkip = ( srcSize.iWidth << 8 ) / aTrgRect.Width();
+ const TInt ySkip = ( srcSize.iHeight << 8 ) / aTrgRect.Height();
+
+ const TInt drawWidth = drawRect.Width();
+ const TInt drawHeight = drawRect.Height();
+
+ TRect offsetRect( aTrgRect.iTl, drawRect.iTl );
+ const TInt yPosOffset = ySkip * offsetRect.Height();
+ const TInt xPosOffset = xSkip * offsetRect.Width();
+
+ if ( ( displayMode == EGray256 ) || ( displayMode == EColor256 ) )
+ {
+ TInt srcScanLen8 = CFbsBitmap::ScanLineLength(
+ srcSize.iWidth, displayMode );
+ TInt trgScanLen8 = CFbsBitmap::ScanLineLength(
+ trgBitmapSize.iWidth, displayMode );
+
+ TUint8* trgAddress8 = reinterpret_cast< TUint8* >( trgAddress );
+
+ TInt yPos = yPosOffset;
+ // skip left and top margins in the beginning
+ trgAddress8 += trgScanLen8 * drawRect.iTl.iY + drawRect.iTl.iX;
+
+ for ( TInt y = 0; y < drawHeight; y++ )
+ {
+ TUint8* srcAddress8 = reinterpret_cast< TUint8* >( srcAddress ) +
+ ( srcScanLen8 * ( yPos >> 8 ) );
+
+ TInt xPos = xPosOffset;
+ for ( TInt x = 0; x < drawWidth; x++ )
+ {
+ *( trgAddress8++ ) = srcAddress8[xPos >> 8];
+ xPos += xSkip;
+ }
+
+ yPos += ySkip;
+
+ trgAddress8 += trgScanLen8 - drawWidth;
+ }
+ }
+ else if ( displayMode == EColor4K || displayMode == EColor64K )
+ {
+ TInt srcScanLen16 = CFbsBitmap::ScanLineLength(
+ srcSize.iWidth, displayMode ) /2;
+ TInt trgScanLen16 = CFbsBitmap::ScanLineLength(
+ trgBitmapSize.iWidth, displayMode ) /2;
+
+ TUint16* trgAddress16 = reinterpret_cast< TUint16* >( trgAddress );
+
+ TInt yPos = yPosOffset;
+ // skip left and top margins in the beginning
+ trgAddress16 += trgScanLen16 * drawRect.iTl.iY + drawRect.iTl.iX;
+
+ for ( TInt y = 0; y < drawHeight; y++ )
+ {
+ TUint16* srcAddress16 = reinterpret_cast< TUint16* >( srcAddress ) +
+ ( srcScanLen16 * ( yPos >> 8 ) );
+
+ TInt xPos = xPosOffset;
+ for ( TInt x = 0; x < drawWidth; x++ )
+ {
+ *( trgAddress16++ ) = srcAddress16[xPos >> 8];
+ xPos += xSkip;
+ }
+
+ yPos += ySkip;
+
+ trgAddress16 += trgScanLen16 - drawWidth;
+ }
+ }
+ else if ( displayMode == EColor16MU )
+ {
+ TInt srcScanLen32 = CFbsBitmap::ScanLineLength(
+ srcSize.iWidth, displayMode ) /4;
+ TInt trgScanLen32 = CFbsBitmap::ScanLineLength(
+ trgBitmapSize.iWidth, displayMode ) /4;
+
+ TUint32* trgAddress32 = reinterpret_cast< TUint32* >( trgAddress );
+
+ TInt yPos = yPosOffset;
+ // skip left and top margins in the beginning
+ trgAddress32 += trgScanLen32 * drawRect.iTl.iY + drawRect.iTl.iX;
+
+ for ( TInt y = 0; y < drawHeight; y++ )
+ {
+ TUint32* srcAddress32 = reinterpret_cast< TUint32* >( srcAddress ) +
+ ( srcScanLen32 * ( yPos >> 8 ) );
+
+ TInt xPos = xPosOffset;
+ for ( TInt x = 0; x < drawWidth; x++ )
+ {
+ *( trgAddress32++ ) = srcAddress32[xPos >> 8];
+ xPos += xSkip;
+ }
+
+ yPos += ySkip;
+
+ trgAddress32 += trgScanLen32 - drawWidth;
+ }
+ }
+ else
+ {
+ User::Leave( KErrUnknown );
+ }
+
+ CleanupStack::PopAndDestroy(); // fbsheaplock
+
+ if ( srcTemporary )
+ {
+ CleanupStack::PopAndDestroy(); // realSource
+ }
+ }