diff -r 000000000000 -r f72a12da539e idlehomescreen/xmluirendering/uiengine/src/xnutils.cpp --- /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 +#include +#include + +// 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 + } + }