idlehomescreen/xmluirendering/uiengine/src/xnutils.cpp
changeset 0 f72a12da539e
--- /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
+        }
+    }