author | Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com> |
Tue, 14 Sep 2010 20:58:58 +0300 | |
branch | RCL_3 |
changeset 35 | 3321d3e205b6 |
parent 34 | 5456b4e8b3a8 |
permissions | -rw-r--r-- |
34 | 1 |
/* |
2 |
* Copyright (c) 2002-2004 Nokia Corporation and/or its subsidiary(-ies). |
|
3 |
* All rights reserved. |
|
4 |
* This component and the accompanying materials are made available |
|
5 |
* under the terms of "Eclipse Public License v1.0" |
|
6 |
* which accompanies this distribution, and is available |
|
7 |
* at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 |
* |
|
9 |
* Initial Contributors: |
|
10 |
* Nokia Corporation - initial contribution. |
|
11 |
* |
|
12 |
* Contributors: |
|
13 |
* |
|
14 |
* Description: Xuikon control adapter source file |
|
15 |
* |
|
16 |
*/ |
|
17 |
||
18 |
||
19 |
// System includes |
|
20 |
#include <utf.h> |
|
21 |
#include <SVGEngineInterfaceImpl.h> |
|
22 |
#include <s32file.h> |
|
23 |
#include <mifconvdefs.h> |
|
24 |
//skinning support |
|
25 |
#include <AknsFrameBackgroundControlContext.h> |
|
26 |
#include <AknsDrawUtils.h> |
|
27 |
#include <aknconsts.h> |
|
28 |
#include <AknUtils.h> |
|
29 |
#include <AknsListBoxBackgroundControlContext.h> |
|
30 |
#include <gulicon.h> |
|
31 |
#include <aknpointereventsuppressor.h> |
|
32 |
#ifdef RD_TACTILE_FEEDBACK |
|
33 |
#include <touchfeedback.h> |
|
34 |
#endif // RD_TACTILE_FEEDBACK |
|
35 |
||
36 |
// User includes |
|
37 |
#include "xnappuiadapter.h" |
|
38 |
#include "xnviewadapter.h" |
|
39 |
#include "xnviewmanager.h" |
|
40 |
#include "xncontroladapterimpl.h" |
|
41 |
#include "xncontroladapter.h" |
|
42 |
#include "xnmenuadapter.h" |
|
43 |
#include "xnviewcontroladapter.h" |
|
44 |
#include "xncomponentnodeimpl.h" |
|
45 |
#include "xntype.h" |
|
46 |
#include "xnnodepluginif.h" |
|
47 |
#include "xnuiengine.h" |
|
48 |
#include "xnviewnodeimpl.h" |
|
49 |
#include "c_xnutils.h" |
|
50 |
#include "xndomdocument.h" |
|
51 |
#include "xndomattribute.h" |
|
52 |
#include "xndomnode.h" |
|
53 |
#include "xnproperty.h" |
|
54 |
#include "xndomlist.h" |
|
55 |
#include "xnodt.h" |
|
56 |
#include "xnresource.h" |
|
57 |
#include "xnplugindata.h" |
|
58 |
#include "xnnode.h" |
|
59 |
#include "xnpanic.h" |
|
60 |
#include "xnviewdata.h" |
|
61 |
#include "xnscrollablecontroladapter.h" |
|
62 |
#include "xnfocuscontrol.h" |
|
63 |
#include "xneditmode.h" |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
64 |
#include "xnviewswitcher.h" |
34 | 65 |
|
66 |
_LIT8(KScrollableBoxNodeName, "scrollablebox"); |
|
67 |
_LIT8( KView, "view" ); |
|
68 |
||
69 |
// Constants |
|
70 |
const TInt KSkinGfxInnerRectShrink = 5; |
|
71 |
const TInt KFocusGrowValue = 3; |
|
72 |
||
73 |
const TInt KLongTapStartShortDelay( 150000 ); // 0.15s for Sk |
|
74 |
const TInt KLongTapStartLongDelay( 500000 ); // 0.5s |
|
75 |
const TInt KLongTapTimeShortDelay( 600000 ); // 0.6s for SK |
|
76 |
const TInt KLongTapTimeLongDelay( 1500000 ); // 1.5s |
|
77 |
||
78 |
const TInt KDragThreshold = 100; // pixels |
|
79 |
const TInt KMaxTapMove = 100; //100x100 pixels |
|
80 |
||
81 |
const TReal KEps( 3e-16 ); // proximite EPS value for double FP numbers |
|
82 |
||
83 |
// LOCAL FUNCTION PROTOTYPES |
|
84 |
static TRgb ConvertHslToRgb( TInt aHue, TInt aSaturation, TInt aLightness ); |
|
85 |
static void ConvertRgbToHsl( TRgb aRGB, TUint& aHue, TUint& aSaturation, |
|
86 |
TUint& aLightness ); |
|
87 |
static void LoadFbsBitmapL( |
|
88 |
CXnResource& aResource, CFbsBitmap*& aTarget, RFs& aFsSession ); |
|
89 |
static void LoadMbmBitmapL( CXnResource& aResource, |
|
90 |
TInt aBitmapIndex, CFbsBitmap*& aTarget, RFs& aFsSession ); |
|
91 |
static void LoadSVGBitmapL( CXnResource& aResource, |
|
92 |
CFbsBitmap*& aBitmap, CFbsBitmap*& aBitmapMask, |
|
93 |
TRect aRect, RFs& aFsSession ); |
|
94 |
static TBool GetBitmapL( CXnUiEngine& aEngine, CXnNode& aNode, |
|
95 |
const TDesC& aResourceFileName, TInt& aBitmapIndex, |
|
96 |
CFbsBitmap*& aTarget, CFbsBitmap*& aBitmapMask, |
|
97 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, |
|
98 |
TRect aRect, RFs& aFsSession ); |
|
99 |
||
100 |
static void LimitRectToPaddingRect( CXnNode& aNode, TRect& aRect ); |
|
101 |
static void DrawSpaceBackgroundY( CWindowGc& aGc, TInt aYRepeatCount, |
|
102 |
CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect, |
|
103 |
TRect aImageRect, TInt& aYOffset ); |
|
104 |
static void DrawRepeatBackgroundY( CWindowGc& aGc, TInt aYRepeatCount, |
|
105 |
CXnNode& aNode, TRect& aRect, CFbsBitmap* aBitmap, TRect aBitmapRect, |
|
106 |
TRect aImageRect, TInt& aYOffset ); |
|
107 |
static void StripQuotes( HBufC*& aString ); |
|
108 |
static void DrawBackgroundColorL( |
|
109 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc ); |
|
110 |
static void GetBackroundRepeatValuesL( CXnNode& aNode, TBool& aRepeatX, |
|
111 |
TBool& aRepeatY, TBool& aSpaceX, TBool& aSpaceY ); |
|
112 |
static void DrawRepeatedBackgroundImage( CWindowGc& aGc, CXnNode& aNode, |
|
113 |
TRect& aRect, TRect aImageRect, TRect aBitmapRect, |
|
114 |
CFbsBitmap* aBitmap, TBool aRepeatX, TBool aRepeatY, TBool aSpaceX, |
|
115 |
TBool aSpaceY, TInt aXRepeatCount, TInt aYRepeatCount ); |
|
116 |
static TBool GetBackgroundPositionFromPropertyL( |
|
117 |
CXnNode& aNode, TBool aScaleImage, TRect& aRect, |
|
118 |
TRect aImageRect, CFbsBitmap* aBitmap, TBool& aHeightSet ); |
|
119 |
static TBool GetBackgroundSizeFromPropertyL( TRect& aRect, CXnNode& aNode, |
|
120 |
CFbsBitmap* aBitmap, TBool& aScaleImage ); |
|
121 |
static TRgb LighterColor( const TRgb& aRgb ); |
|
122 |
static TRgb DarkerColor( const TRgb& aRgb ); |
|
123 |
static void DrawSolidTopBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ); |
|
124 |
static void SplitTopBorderPolygonL( CArrayFix< TPoint >* aArray, |
|
125 |
CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart ); |
|
126 |
static void DrawRidgeTopBorderL( |
|
127 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
128 |
static void DrawGrooveTopBorderL( |
|
129 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
130 |
static void DrawInsetTopBorder( |
|
131 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
132 |
static void DrawOutsetTopBorder( |
|
133 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
134 |
static TBool GetBorderColorL( |
|
135 |
const TDesC8& aPropertyName, CXnNode& aNode, CWindowGc& aGc, TRgb& aRgb ); |
|
136 |
static void DrawTopBorderL( |
|
137 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc ); |
|
138 |
static void DrawBottomBorderL( |
|
139 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc ); |
|
140 |
static void DrawSolidBottomBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ); |
|
141 |
static void SplitBottomBorderPolygonL( CArrayFix< TPoint >* aArray, |
|
142 |
CArrayFix< TPoint >*& aUpperPart, CArrayFix< TPoint >*& aLowerPart ); |
|
143 |
static void DrawRidgeBottomBorderL( |
|
144 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
145 |
static void DrawGrooveBottomBorderL( |
|
146 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
147 |
static void DrawInsetBottomBorder( |
|
148 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
149 |
static void DrawOutsetBottomBorder( |
|
150 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
151 |
static void DrawSolidLeftBorder( |
|
152 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc ); |
|
153 |
static void SplitLeftBorderPolygonL( CArrayFix< TPoint >* aArray, |
|
154 |
CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart ); |
|
155 |
static void DrawRidgeLeftBorderL( |
|
156 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
157 |
static void DrawGrooveLeftBorderL( |
|
158 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
159 |
static void DrawInsetLeftBorder( |
|
160 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
161 |
static void DrawOutsetLeftBorder( |
|
162 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
163 |
static void DrawLeftBorderL( |
|
164 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc ); |
|
165 |
static void DrawRightBorderL( |
|
166 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc ); |
|
167 |
static void DrawSolidRightBorder( |
|
168 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc ); |
|
169 |
static void SplitRightBorderPolygonL( CArrayFix< TPoint >* aArray, |
|
170 |
CArrayFix< TPoint >*& aLeftPart, CArrayFix< TPoint >*& aRightPart ); |
|
171 |
static void DrawRidgeRightBorderL( |
|
172 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
173 |
static void DrawGrooveRightBorderL( |
|
174 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
175 |
static void DrawInsetRightBorder( |
|
176 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
177 |
static void DrawOutsetRightBorder( |
|
178 |
CArrayFix< TPoint >* aArray, CWindowGc& aGc, TRgb& aRgb ); |
|
179 |
static void DrawBorderImagesL( |
|
180 |
const TRect& /*aRect*/, CXnNode& aNode, CWindowGc& aGc, |
|
181 |
CFbsBitmap* aBitmap, TInt aBorderBitmapDividerTop, |
|
182 |
TInt aBorderBitmapDividerRight, |
|
183 |
TInt aBorderBitmapDividerBottom, TInt aBorderBitmapDividerLeft ); |
|
184 |
static TBool IsPropertyNone( CXnProperty& aProperty ); |
|
185 |
static void DrawBordersL( const TRect& aRect, CXnNode& aNode, CWindowGc& aGc ); |
|
186 |
static void SwapChildArrays( RPointerArray< CXnControlAdapter >& originalArray, |
|
187 |
RPointerArray< CXnControlAdapter >& sortedArray ); |
|
188 |
static CXnProperty* GetZIndexL( CXnControlAdapter* aAdapter ); |
|
189 |
static void InsertChildToSortedArrayL( |
|
190 |
RPointerArray< CXnControlAdapter >& aTargetArray, |
|
191 |
CXnControlAdapter* aChild ); |
|
192 |
static void InitializeBackgroundBitmapL( CXnUiEngine& aEngine, CXnNode& aNode, |
|
193 |
TInt& aBitmapIndex, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
194 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession ); |
|
195 |
static HBufC* GetBackgroundImagePathLC( CXnNode& aNode ); |
|
196 |
static CFbsBitmap* InitializeBorderBitmapL( |
|
197 |
CXnUiEngine& aEngine, CXnNode& aNode, |
|
198 |
TInt& aBitmapIndex, TInt& aBorderBitmapDividerTop, |
|
199 |
TInt& aBorderBitmapDividerRight, TInt& aBorderBitmapDividerBottom, |
|
200 |
TInt& aBorderBitmapDividerLeft, |
|
201 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession ); |
|
202 |
static void DrawDottedBorder( |
|
203 |
TRect aBorderRect, CWindowGc& aGc, TRgb& aRgb, TBool aHorizontal ); |
|
204 |
static HBufC* GetBackgroundImageMaskPathLC( CXnNode& aNode ); |
|
205 |
static CFbsBitmap* CreateBitmapFromColorL( TSize aSize, TRgb aColor ); |
|
206 |
static TBool CreateGestureHelperL( CXnNode& aNode ); |
|
207 |
static TInt AccessResourceFileL( |
|
208 |
CXnResource& aResource, RFile& aFile, RFs& aFsSession ); |
|
209 |
static void DrawFocusAppearance( CXnNode& aNode, CWindowGc& aGc ); |
|
210 |
static CXnDomNode* HasHoldTrigger( CXnDomNode* aNode ); |
|
211 |
||
212 |
// ============================= LOCAL FUNCTIONS =============================== |
|
213 |
// ----------------------------------------------------------------------------- |
|
214 |
// ----------------------------------------------------------------------------- |
|
215 |
// |
|
216 |
static CXnScrollableControlAdapter* IsChildOfScrollableControl( CXnNode& aNode ) |
|
217 |
{ |
|
218 |
CXnNode* parent = aNode.Parent(); |
|
219 |
while( parent ) |
|
220 |
{ |
|
221 |
if( parent->Type()->Type() == KScrollableBoxNodeName ) |
|
222 |
{ |
|
223 |
CXnScrollableControlAdapter* ret = static_cast<CXnScrollableControlAdapter*>(parent->Control()); |
|
224 |
return ret; |
|
225 |
} |
|
226 |
parent = parent->Parent(); |
|
227 |
} |
|
228 |
return NULL; |
|
229 |
} |
|
230 |
||
231 |
// ----------------------------------------------------------------------------- |
|
232 |
// SetControlContext |
|
233 |
// |
|
234 |
// ----------------------------------------------------------------------------- |
|
235 |
// |
|
236 |
static void SetControlContext(CXnControlAdapter& aChild, CXnNode& aNode) |
|
237 |
{ |
|
238 |
CXnScrollableControlAdapter* scrollableControl = IsChildOfScrollableControl( aNode ); |
|
239 |
if(scrollableControl) |
|
240 |
{ |
|
241 |
aNode.SetScrollableControl(scrollableControl); |
|
242 |
aChild.CopyControlContextFrom(scrollableControl); |
|
243 |
} |
|
244 |
} |
|
245 |
||
246 |
// ----------------------------------------------------------------------------- |
|
247 |
// AccessResourceFileL |
|
248 |
// Opens a resource file for accessing. The caller must close the file. |
|
249 |
// ----------------------------------------------------------------------------- |
|
250 |
// |
|
251 |
static TInt AccessResourceFileL( |
|
252 |
CXnResource& aResource, |
|
253 |
RFile& aFile, |
|
254 |
RFs& aFsSession ) |
|
255 |
{ |
|
256 |
TInt err = KErrNone; |
|
257 |
||
258 |
// parse file name and extension |
|
259 |
const TDesC& fileName = aResource.FileName(); |
|
260 |
TParsePtrC fileParser( fileName ); |
|
261 |
TPtrC filepath = fileParser.DriveAndPath(); |
|
262 |
||
263 |
// open resource file |
|
264 |
aFsSession.SetSessionPath( filepath ); |
|
265 |
aFsSession.ShareProtected(); |
|
266 |
err = aFile.Open( aFsSession, fileName, EFileShareReadersOnly ); |
|
267 |
if ( err != KErrNone ) |
|
268 |
{ |
|
269 |
aFile.Close(); |
|
270 |
} |
|
271 |
||
272 |
return err; |
|
273 |
} |
|
274 |
||
275 |
// ----------------------------------------------------------------------------- |
|
276 |
// LoadFbsBitmapL |
|
277 |
// Loads a bitmap file from the theme server and creates a CFbsBitmap |
|
278 |
// ----------------------------------------------------------------------------- |
|
279 |
// |
|
280 |
static void LoadFbsBitmapL( |
|
281 |
CXnResource& aResource, |
|
282 |
CFbsBitmap*& aTarget, |
|
283 |
RFs& aFsSession ) |
|
284 |
{ |
|
285 |
RFile file; |
|
286 |
||
287 |
TInt ret = AccessResourceFileL( aResource, file, aFsSession ); |
|
288 |
if ( ret == KErrNone ) |
|
289 |
{ |
|
290 |
CleanupClosePushL( file ); |
|
291 |
aTarget = new ( ELeave ) CFbsBitmap; |
|
292 |
if ( !aTarget ) |
|
293 |
{ |
|
294 |
CleanupStack::PopAndDestroy(); |
|
295 |
return; |
|
296 |
} |
|
297 |
RFileReadStream readStream( file ); |
|
298 |
CleanupClosePushL( readStream ); |
|
299 |
aTarget->InternalizeL( readStream ); |
|
300 |
CleanupStack::PopAndDestroy( &readStream ); |
|
301 |
CleanupStack::PopAndDestroy( &file ); |
|
302 |
} |
|
303 |
} |
|
304 |
||
305 |
// ----------------------------------------------------------------------------- |
|
306 |
// LoadMifBitmapL |
|
307 |
// Loads a bitmap file from the theme server and creates a CFbsBitmap |
|
308 |
// ----------------------------------------------------------------------------- |
|
309 |
// |
|
310 |
static void LoadMifBitmapL( |
|
311 |
CXnResource& aResource, |
|
312 |
TInt aBitmapIndex, |
|
313 |
CFbsBitmap*& aBitmap, |
|
314 |
CFbsBitmap*& aMask, |
|
315 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, |
|
316 |
RFs& aFsSession, |
|
317 |
const TRect& aRect ) |
|
318 |
{ |
|
319 |
RFile file; |
|
320 |
||
321 |
TInt ret = AccessResourceFileL( aResource, file, aFsSession ); |
|
322 |
if ( ret == KErrNone ) |
|
323 |
{ |
|
324 |
aIconProvider = new ( ELeave ) CXnControlAdapterImpl::TIconProvider( file ); |
|
325 |
} |
|
326 |
||
327 |
if ( ret == KErrNone ) |
|
328 |
{ |
|
329 |
// Mask is next after bitmap |
|
330 |
AknIconUtils::CreateIconL( aBitmap, aMask, *aIconProvider, |
|
331 |
aBitmapIndex + KMifIdFirst, aBitmapIndex + KMifIdFirst + 1 ); |
|
332 |
AknIconUtils::SetSize( aBitmap, aRect.Size(), EAspectRatioNotPreserved ); |
|
333 |
} |
|
334 |
} |
|
335 |
||
336 |
// ----------------------------------------------------------------------------- |
|
337 |
// LoadMbmBitmapL |
|
338 |
// Loads a bitmap file from the theme server and creates a CFbsBitmap |
|
339 |
// ----------------------------------------------------------------------------- |
|
340 |
// |
|
341 |
static void LoadMbmBitmapL( |
|
342 |
CXnResource& aResource, |
|
343 |
TInt aBitmapIndex, |
|
344 |
CFbsBitmap*& aTarget, |
|
345 |
RFs& aFsSession ) |
|
346 |
{ |
|
347 |
RFile file; |
|
348 |
||
349 |
TInt ret = AccessResourceFileL( aResource, file, aFsSession ); |
|
350 |
if ( ret == KErrNone ) |
|
351 |
{ |
|
352 |
CleanupClosePushL( file ); |
|
353 |
aTarget = new ( ELeave ) CFbsBitmap; |
|
354 |
aTarget->Load( file, aBitmapIndex ); |
|
355 |
CleanupStack::PopAndDestroy(); |
|
356 |
} |
|
357 |
} |
|
358 |
||
359 |
// ----------------------------------------------------------------------------- |
|
360 |
// LoadSVGBitmapL |
|
361 |
// Loads an SVG file from the theme server and creates a CFbsBitmap. |
|
362 |
// ----------------------------------------------------------------------------- |
|
363 |
// |
|
364 |
static void LoadSVGBitmapL( |
|
365 |
CXnResource& aResource, |
|
366 |
CFbsBitmap*& aBitmap, |
|
367 |
CFbsBitmap*& aBitmapMask, |
|
368 |
TRect aRect, |
|
369 |
RFs& aFsSession ) |
|
370 |
{ |
|
371 |
RFile file; |
|
372 |
||
373 |
TInt ret = AccessResourceFileL( aResource, file, aFsSession ); |
|
374 |
if ( ret == KErrNone ) |
|
375 |
{ |
|
376 |
CleanupClosePushL( file ); |
|
377 |
||
378 |
CFbsBitmap* frameBuffer = new ( ELeave ) CFbsBitmap; |
|
379 |
CleanupStack::PushL( frameBuffer ); |
|
380 |
||
381 |
TSize contentSize( aRect.Size() ); |
|
382 |
||
383 |
frameBuffer->Create( contentSize, EColor16M ); |
|
384 |
||
385 |
TFontSpec fontSpec; |
|
386 |
CSvgEngineInterfaceImpl* svgEngine = |
|
387 |
CSvgEngineInterfaceImpl::NewL( frameBuffer, NULL, fontSpec ); |
|
388 |
||
389 |
CleanupStack::PushL( svgEngine ); |
|
390 |
||
391 |
svgEngine->Load( file ); |
|
392 |
||
393 |
TInt domHandle; |
|
394 |
svgEngine->PrepareDom( file, domHandle ); |
|
395 |
||
396 |
CFbsBitmap* target = new ( ELeave ) CFbsBitmap; |
|
397 |
target->Create( contentSize, EColor16M ); |
|
398 |
svgEngine->RenderDom( domHandle, target ); |
|
399 |
||
400 |
aBitmap = target; |
|
401 |
||
402 |
CFbsBitmap* mask = new ( ELeave ) CFbsBitmap; |
|
403 |
mask->Create( contentSize, EGray256 ); |
|
404 |
svgEngine->GenerateMask( mask ); |
|
405 |
||
406 |
aBitmapMask = mask; |
|
407 |
||
408 |
CleanupStack::PopAndDestroy( 3, &file ); // frameBuffer, svgEngine, file |
|
409 |
} |
|
410 |
} |
|
411 |
||
412 |
||
413 |
// ----------------------------------------------------------------------------- |
|
414 |
// ResolveMifIDL |
|
415 |
// Resolves a mif id from a given string. |
|
416 |
// ----------------------------------------------------------------------------- |
|
417 |
// |
|
418 |
static TBool ResolveMifIDL( |
|
419 |
const TDesC& aMifId, |
|
420 |
TInt& aMifID ) |
|
421 |
{ |
|
422 |
HBufC* str = aMifId.AllocL(); |
|
423 |
TPtr ptrMif = str->Des(); |
|
424 |
ptrMif.TrimAll(); |
|
425 |
TInt pos( ptrMif.FindF( KMif ) ); |
|
426 |
if ( KErrNotFound != pos ) |
|
427 |
{ |
|
428 |
pos += KMif().Length(); |
|
429 |
TPtr ptr = ptrMif.MidTPtr( pos, ( ptrMif.Length() - pos ) ); |
|
430 |
ptr.TrimAll(); |
|
431 |
TInt offset( ptr.Locate( KRightParenthesis ) ); |
|
432 |
if ( KErrNotFound != offset ) |
|
433 |
{ |
|
434 |
TLex lex( ptr.Left( offset ) ); |
|
435 |
lex.SkipSpace(); |
|
436 |
lex.Val( aMifID ); |
|
437 |
delete str; |
|
438 |
return ETrue; |
|
439 |
} |
|
440 |
} |
|
441 |
delete str; |
|
442 |
return EFalse; |
|
443 |
} |
|
444 |
||
445 |
// ----------------------------------------------------------------------------- |
|
446 |
// LoadSkinBitmapL |
|
447 |
// Loads a skin bitmap and creates a CFbsBitmap from it. |
|
448 |
// ----------------------------------------------------------------------------- |
|
449 |
// |
|
450 |
static TBool LoadSkinBitmapL( |
|
451 |
const TDesC& aSkinId, |
|
452 |
CFbsBitmap*& aBitmap, |
|
453 |
CFbsBitmap*& aBitmapMask, |
|
454 |
TRect aRect ) |
|
455 |
{ |
|
456 |
TAknsItemID itemID; |
|
457 |
||
458 |
MAknsSkinInstance* skin( AknsUtils::SkinInstance() ); |
|
459 |
||
460 |
TInt mifId( 0 ); |
|
461 |
||
462 |
TInt mifFound( ResolveMifIDL( aSkinId, mifId ) ); |
|
463 |
||
464 |
TInt colorIndex( KErrNotFound ); |
|
465 |
||
466 |
if ( skin && CXnUtils::ResolveSkinItemIDL( aSkinId, itemID, colorIndex ) ) |
|
467 |
{ |
|
468 |
if ( itemID.iMajor == EAknsMajorAppIcon ) // Check if appl. icon request |
|
469 |
{ |
|
470 |
TUid applUid; |
|
471 |
applUid = TUid::Uid( itemID.iMinor ); |
|
472 |
||
473 |
AknsUtils::CreateAppIconLC( |
|
474 |
skin, applUid, EAknsAppIconTypeList, aBitmap, aBitmapMask ); |
|
475 |
AknIconUtils::SetSize( |
|
476 |
aBitmap, aRect.Size(), EAspectRatioNotPreserved ); |
|
477 |
CleanupStack::Pop( 2 ); //aBitmap, aBitmapMask |
|
478 |
||
479 |
return ETrue; |
|
480 |
} |
|
481 |
else |
|
482 |
{ |
|
483 |
TInt error( KErrNone ); |
|
484 |
||
485 |
// if we have a color index, then we create a colored icon |
|
486 |
if ( colorIndex != KErrNotFound ) |
|
487 |
{ |
|
488 |
TRgb defaultColor( 0, 0, 0 ); |
|
489 |
||
490 |
TRAP( error, AknsUtils::CreateColorIconL( |
|
491 |
skin, itemID, KAknsIIDQsnTextColors, |
|
492 |
colorIndex, aBitmap, aBitmapMask, |
|
493 |
KNullDesC, mifId, mifId + 1, defaultColor ) ); |
|
494 |
} |
|
495 |
else |
|
496 |
{ |
|
497 |
TRAP( error, AknsUtils::CreateIconL( |
|
498 |
skin, itemID, aBitmap, aBitmapMask, KNullDesC, |
|
499 |
mifId, mifId + 1 ) ); |
|
500 |
} |
|
501 |
||
502 |
if ( error != KErrNone ) |
|
503 |
{ |
|
504 |
error = KErrNone; |
|
505 |
TRAP( error, AknsUtils::CreateIconL( |
|
506 |
skin, itemID, aBitmap, KNullDesC, mifId ) ); |
|
507 |
} |
|
508 |
||
509 |
if ( error == KErrNone ) |
|
510 |
{ |
|
511 |
AknIconUtils::SetSize( |
|
512 |
aBitmap, aRect.Size(), EAspectRatioNotPreserved ); |
|
513 |
||
514 |
return ETrue; |
|
515 |
} |
|
516 |
} |
|
517 |
} |
|
518 |
||
519 |
if ( mifFound ) |
|
520 |
{ |
|
521 |
AknIconUtils::CreateIconL( |
|
522 |
aBitmap, aBitmapMask, KAvkonBitmapFile, mifId, mifId + 1 ); |
|
523 |
AknIconUtils::SetSize( |
|
524 |
aBitmap, aRect.Size(), EAspectRatioNotPreserved ); |
|
525 |
||
526 |
return ETrue; |
|
527 |
} |
|
528 |
||
529 |
return EFalse; |
|
530 |
} |
|
531 |
||
532 |
// ----------------------------------------------------------------------------- |
|
533 |
// GetBitmap |
|
534 |
// Fetches a bitmap |
|
535 |
// ----------------------------------------------------------------------------- |
|
536 |
// |
|
537 |
static TBool GetBitmapL( |
|
538 |
CXnUiEngine& aEngine, |
|
539 |
CXnNode& /*aNode*/, |
|
540 |
const TDesC& aResourceFileName, |
|
541 |
TInt& aBitmapIndex, |
|
542 |
CFbsBitmap*& aBitmap, |
|
543 |
CFbsBitmap*& aBitmapMask, |
|
544 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, |
|
545 |
TRect aRect, |
|
546 |
RFs& aFsSession ) |
|
547 |
{ |
|
548 |
if ( LoadSkinBitmapL( aResourceFileName, aBitmap, aBitmapMask, aRect ) ) |
|
549 |
{ |
|
550 |
return ETrue; |
|
551 |
} |
|
552 |
||
553 |
CXnResource* resource( CXnUtils::FindResource( |
|
554 |
aEngine.Resources(), aResourceFileName, aBitmapIndex ) ); |
|
555 |
||
556 |
if ( resource ) |
|
557 |
{ |
|
558 |
if ( resource->ResourceType() == EResourceSVG ) |
|
559 |
{ |
|
560 |
LoadSVGBitmapL( *resource, aBitmap, aBitmapMask, aRect, aFsSession ); |
|
561 |
||
562 |
return ETrue; |
|
563 |
} |
|
564 |
else if ( resource->ResourceType() == EResourceMIF ) |
|
565 |
{ |
|
566 |
LoadMifBitmapL( *resource, aBitmapIndex, aBitmap, |
|
567 |
aBitmapMask, aIconProvider, aFsSession, aRect ); |
|
568 |
||
569 |
return ETrue; |
|
570 |
} |
|
571 |
else if ( resource->ResourceType() == EResourceMBM ) |
|
572 |
{ |
|
573 |
LoadMbmBitmapL( *resource, aBitmapIndex, aBitmap, aFsSession ); |
|
574 |
||
575 |
return ETrue; |
|
576 |
} |
|
577 |
else if ( resource->ResourceType() == EResourceFBS ) |
|
578 |
{ |
|
579 |
LoadFbsBitmapL( *resource, aBitmap, aFsSession ); |
|
580 |
||
581 |
return ETrue; |
|
582 |
} |
|
583 |
} |
|
584 |
||
585 |
return EFalse; |
|
586 |
} |
|
587 |
||
588 |
// ----------------------------------------------------------------------------- |
|
589 |
// DrawBackgroundColorL |
|
590 |
// Draws background color to the padding rect |
|
591 |
// ----------------------------------------------------------------------------- |
|
592 |
// |
|
593 |
static void DrawBackgroundColorL( |
|
594 |
const TRect& /*aRect*/, |
|
595 |
CXnNode& aNode, |
|
596 |
CWindowGc& aGc ) |
|
597 |
{ |
|
598 |
CXnProperty* colorProperty( aNode.BackgroundColorL() ); |
|
599 |
||
600 |
if ( colorProperty ) |
|
601 |
{ |
|
602 |
TRect paddingRect = aNode.PaddingRect(); |
|
603 |
||
604 |
CXnDomPropertyValue* value = |
|
605 |
static_cast< CXnDomPropertyValue* >( |
|
606 |
colorProperty->Property()->PropertyValueList().Item( 0 ) ); |
|
607 |
||
608 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::ERgbColor ) |
|
609 |
{ |
|
610 |
TRgb rgb( value->RgbColorValueL() ); |
|
611 |
||
612 |
aGc.SetPenColor( rgb ); |
|
613 |
||
614 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
615 |
aGc.SetBrushColor( rgb ); |
|
616 |
||
617 |
aGc.DrawRect( paddingRect ); |
|
618 |
} |
|
619 |
} |
|
620 |
} |
|
621 |
||
622 |
// ----------------------------------------------------------------------------- |
|
623 |
// StripQuotes |
|
624 |
// Strips enclosing quotes from a string |
|
625 |
// ----------------------------------------------------------------------------- |
|
626 |
// |
|
627 |
static void StripQuotes( HBufC*& aString ) |
|
628 |
{ |
|
629 |
TInt pos1 = aString->Locate( '\"' ); |
|
630 |
TInt pos2 = aString->Locate( '\'' ); |
|
631 |
// check, if the first character is " or ' |
|
632 |
if ( pos1 == 0 || pos2 == 0 ) |
|
633 |
{ |
|
634 |
TInt len = aString->Length() - 2; |
|
635 |
TPtr ptr = aString->Des(); |
|
636 |
TPtrC16 newString( aString->Mid( 1, len ).Ptr(), len ); |
|
637 |
ptr = newString; |
|
638 |
} |
|
639 |
} |
|
640 |
||
641 |
// ----------------------------------------------------------------------------- |
|
642 |
// DrawRepeatBackgroundY |
|
643 |
// Draws repeated background in the vertical direction |
|
644 |
// ----------------------------------------------------------------------------- |
|
645 |
// |
|
646 |
static void DrawRepeatBackgroundY( |
|
647 |
CWindowGc& aGc, TInt aYRepeatCount, CXnNode& aNode, TRect& aRect, |
|
648 |
CFbsBitmap* aBitmap, TRect aBitmapRect, |
|
649 |
TRect aImageRect, TInt& aYOffset ) |
|
650 |
{ |
|
651 |
for (TInt i = 0; i <= aYRepeatCount && aRect.iTl.iY < aNode.PaddingRect().iBr.iY;) |
|
652 |
{ |
|
653 |
TRect newRect; |
|
654 |
newRect = TRect( |
|
655 |
aRect.iTl, |
|
656 |
TPoint( |
|
657 |
aRect.iTl.iX + aImageRect.Width(), |
|
658 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
659 |
aGc.DrawBitmap( newRect, aBitmap, aBitmapRect ); |
|
660 |
aRect.Move( 0, newRect.Height() ); |
|
661 |
aYOffset += newRect.Height(); |
|
662 |
if ( ++i == aYRepeatCount || aYRepeatCount == 0 ) |
|
663 |
{ |
|
664 |
break; |
|
665 |
} |
|
666 |
} |
|
667 |
} |
|
668 |
||
669 |
// ----------------------------------------------------------------------------- |
|
670 |
// DrawSpaceBackgroundY |
|
671 |
// Draws spaced background in the vertical direction |
|
672 |
// ----------------------------------------------------------------------------- |
|
673 |
// |
|
674 |
static void DrawSpaceBackgroundY( |
|
675 |
CWindowGc& aGc, TInt aYRepeatCount, CXnNode& aNode, TRect& aRect, |
|
676 |
CFbsBitmap* aBitmap, TRect aBitmapRect, |
|
677 |
TRect aImageRect, TInt& aYOffset ) |
|
678 |
{ |
|
679 |
for (TInt j = 0; j <= aYRepeatCount && aRect.iTl.iY < aNode.PaddingRect().iBr.iY;) |
|
680 |
{ |
|
681 |
TRect newRect = aRect; |
|
682 |
newRect = TRect( |
|
683 |
aRect.iTl, |
|
684 |
TPoint( |
|
685 |
aRect.iTl.iX + aImageRect.Width(), |
|
686 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
687 |
aGc.DrawBitmap( newRect, aBitmap, aBitmapRect ); |
|
688 |
aRect.Move( 0, newRect.Height() ); |
|
689 |
aYOffset += newRect.Height(); |
|
690 |
if ( ++j == aYRepeatCount || aYRepeatCount == 0 ) |
|
691 |
{ |
|
692 |
break; |
|
693 |
} |
|
694 |
} |
|
695 |
} |
|
696 |
||
697 |
// ----------------------------------------------------------------------------- |
|
698 |
// LimitRectToPaddingRect |
|
699 |
// Limits a rect so that it does not exceed padding rect |
|
700 |
// ----------------------------------------------------------------------------- |
|
701 |
// |
|
702 |
static void LimitRectToPaddingRect( CXnNode& aNode, TRect& aRect ) |
|
703 |
{ |
|
704 |
TRect tmpRect = aNode.PaddingRect(); |
|
705 |
if ( aRect.iTl.iX < tmpRect.iTl.iX ) |
|
706 |
{ |
|
707 |
aRect.SetRect( tmpRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY ); |
|
708 |
} |
|
709 |
if ( aRect.iTl.iY < tmpRect.iTl.iY ) |
|
710 |
{ |
|
711 |
aRect.SetRect( aRect.iTl.iX, tmpRect.iTl.iY, aRect.iBr.iX, aRect.iBr.iY ); |
|
712 |
} |
|
713 |
if ( aRect.iBr.iX > tmpRect.iBr.iX ) |
|
714 |
{ |
|
715 |
aRect.SetRect( aRect.iTl.iX, aRect.iTl.iY, tmpRect.iBr.iX, aRect.iBr.iY ); |
|
716 |
} |
|
717 |
if ( aRect.iBr.iY > tmpRect.iBr.iY ) |
|
718 |
{ |
|
719 |
aRect.SetRect( aRect.iTl.iX, aRect.iTl.iY, aRect.iBr.iX, tmpRect.iBr.iY ); |
|
720 |
} |
|
721 |
} |
|
722 |
||
723 |
// ----------------------------------------------------------------------------- |
|
724 |
// GetBackroundRepeatValuesL |
|
725 |
// Gets background repeat information from node properties |
|
726 |
// ----------------------------------------------------------------------------- |
|
727 |
// |
|
728 |
static void GetBackroundRepeatValuesL( |
|
729 |
CXnNode& aNode, |
|
730 |
TBool& aRepeatX, |
|
731 |
TBool& aRepeatY, |
|
732 |
TBool& aSpaceX, |
|
733 |
TBool& aSpaceY ) |
|
734 |
{ |
|
735 |
CXnProperty* backgroundRepeatProperty = aNode.GetPropertyL( |
|
736 |
XnPropertyNames::appearance::common::KBackGroundRepeat ); |
|
737 |
if ( backgroundRepeatProperty ) |
|
738 |
{ |
|
739 |
CXnDomList& propertyValueList = |
|
740 |
backgroundRepeatProperty->Property()->PropertyValueList(); |
|
741 |
TInt valueCount = propertyValueList.Length(); |
|
742 |
for ( TInt i = 0; i < valueCount; ++i ) |
|
743 |
{ |
|
744 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
745 |
propertyValueList.Item( i ) ); |
|
746 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString || |
|
747 |
value->PrimitiveValueType() == CXnDomPropertyValue::EIdent ) |
|
748 |
{ |
|
749 |
switch ( i ) |
|
750 |
{ |
|
751 |
case 0: |
|
752 |
{ |
|
753 |
if ( value->StringValueL() == |
|
754 |
XnPropertyNames::appearance::common::backgroundrepeat::KRepeat ) |
|
755 |
{ |
|
756 |
aRepeatX = ETrue; |
|
757 |
aRepeatY = ETrue; |
|
758 |
} |
|
759 |
else if ( value->StringValueL() == |
|
760 |
XnPropertyNames::appearance::common::backgroundrepeat::KSpace ) |
|
761 |
{ |
|
762 |
aSpaceX = ETrue; |
|
763 |
aSpaceY = ETrue; |
|
764 |
} |
|
765 |
else if ( value->StringValueL() == |
|
766 |
XnPropertyNames::appearance::common::backgroundrepeat::KRepeatX ) |
|
767 |
{ |
|
768 |
aRepeatX = ETrue; |
|
769 |
aRepeatY = EFalse; |
|
770 |
} |
|
771 |
else if ( value->StringValueL() == |
|
772 |
XnPropertyNames::appearance::common::backgroundrepeat::KRepeatY ) |
|
773 |
{ |
|
774 |
aRepeatX = EFalse; |
|
775 |
aRepeatY = ETrue; |
|
776 |
} |
|
777 |
break; |
|
778 |
} |
|
779 |
case 1: |
|
780 |
{ |
|
781 |
if ( value->StringValueL() == |
|
782 |
XnPropertyNames::appearance::common::backgroundrepeat::KRepeat ) |
|
783 |
{ |
|
784 |
aRepeatY = ETrue; |
|
785 |
aSpaceY = EFalse; |
|
786 |
} |
|
787 |
else if ( value->StringValueL() == |
|
788 |
XnPropertyNames::appearance::common::backgroundrepeat::KSpace ) |
|
789 |
{ |
|
790 |
aRepeatY = EFalse; |
|
791 |
aSpaceY = ETrue; |
|
792 |
} |
|
793 |
else if ( value->StringValueL() == |
|
794 |
XnPropertyNames::appearance::common::backgroundrepeat::KNoRepeat ) |
|
795 |
{ |
|
796 |
aRepeatY = EFalse; |
|
797 |
aSpaceY = EFalse; |
|
798 |
} |
|
799 |
break; |
|
800 |
} |
|
801 |
} |
|
802 |
} |
|
803 |
} |
|
804 |
} |
|
805 |
} |
|
806 |
||
807 |
// ----------------------------------------------------------------------------- |
|
808 |
// DrawRepeatedBackgroundImage |
|
809 |
// Draws a repeated background image |
|
810 |
// ----------------------------------------------------------------------------- |
|
811 |
// |
|
812 |
static void DrawRepeatedBackgroundImage( |
|
813 |
CWindowGc& aGc, |
|
814 |
CXnNode& aNode, |
|
815 |
TRect& aRect, |
|
816 |
TRect aImageRect, |
|
817 |
TRect aBitmapRect, |
|
818 |
CFbsBitmap* aBitmap, |
|
819 |
TBool aRepeatX, |
|
820 |
TBool aRepeatY, |
|
821 |
TBool aSpaceX, |
|
822 |
TBool aSpaceY, |
|
823 |
TInt aXRepeatCount, |
|
824 |
TInt aYRepeatCount ) |
|
825 |
{ |
|
826 |
TRect paddingRect = aNode.PaddingRect(); |
|
827 |
if ( aRepeatX && !aRepeatY && !aSpaceX && !aSpaceY ) |
|
828 |
{ |
|
829 |
aRect.SetRect( TPoint( paddingRect.iTl.iX, aRect.iTl.iY ), aRect.Size() ); |
|
830 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
831 |
{ |
|
832 |
TRect newRect = TRect( |
|
833 |
aRect.iTl, |
|
834 |
TPoint( |
|
835 |
aRect.iTl.iX + aImageRect.Width(), |
|
836 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
837 |
aGc.DrawBitmap( newRect, aBitmap, aBitmapRect ); |
|
838 |
aRect.Move( newRect.Width(), 0 ); |
|
839 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
840 |
{ |
|
841 |
break; |
|
842 |
} |
|
843 |
} |
|
844 |
} |
|
845 |
else if ( !aRepeatX && !aRepeatY && aSpaceX && !aSpaceY ) |
|
846 |
{ |
|
847 |
aRect.SetRect( TPoint( paddingRect.iTl.iX, aRect.iTl.iY ), aRect.Size() ); |
|
848 |
if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 ) |
|
849 |
{ |
|
850 |
aRect.Move( |
|
851 |
( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2, |
|
852 |
0 ); |
|
853 |
} |
|
854 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
855 |
{ |
|
856 |
TRect newRect = TRect( |
|
857 |
aRect.iTl, |
|
858 |
TPoint( |
|
859 |
aRect.iTl.iX + aImageRect.Width(), |
|
860 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
861 |
aGc.DrawBitmap( newRect, aBitmap, aBitmapRect ); |
|
862 |
aRect.Move( newRect.Width(), 0 ); |
|
863 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
864 |
{ |
|
865 |
break; |
|
866 |
} |
|
867 |
} |
|
868 |
} |
|
869 |
else if ( !aRepeatX && aRepeatY && !aSpaceX && !aSpaceY ) |
|
870 |
{ |
|
871 |
aRect.SetRect( TPoint( aRect.iTl.iX, paddingRect.iTl.iY ), aRect.Size() ); |
|
872 |
TInt yOffset = 0; |
|
873 |
DrawRepeatBackgroundY( |
|
874 |
aGc, aYRepeatCount, aNode, aRect, |
|
875 |
aBitmap, aBitmapRect, |
|
876 |
aImageRect, yOffset ); |
|
877 |
} |
|
878 |
else if ( !aRepeatX && !aRepeatY && !aSpaceX && aSpaceY ) |
|
879 |
{ |
|
880 |
aRect.SetRect( TPoint( aRect.iTl.iX, paddingRect.iTl.iY ), aRect.Size() ); |
|
881 |
if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 ) |
|
882 |
{ |
|
883 |
aRect.Move( |
|
884 |
0, |
|
885 |
( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 ); |
|
886 |
} |
|
887 |
TInt yOffset = 0; |
|
888 |
DrawSpaceBackgroundY( |
|
889 |
aGc, aYRepeatCount, aNode, aRect, |
|
890 |
aBitmap, aBitmapRect, |
|
891 |
aImageRect, yOffset ); |
|
892 |
} |
|
893 |
else if ( aRepeatX && aRepeatY && !aSpaceX && !aSpaceY ) |
|
894 |
{ |
|
895 |
aRect.SetRect( paddingRect.iTl, aRect.Size() ); |
|
896 |
TInt yOffset = 0; |
|
897 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
898 |
{ |
|
899 |
aRect.Move( 0, -yOffset ); |
|
900 |
yOffset = 0; |
|
901 |
TRect newRect = TRect( |
|
902 |
aRect.iTl, |
|
903 |
TPoint( |
|
904 |
aRect.iTl.iX + aImageRect.Width(), |
|
905 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
906 |
aRect = newRect; |
|
907 |
DrawRepeatBackgroundY( |
|
908 |
aGc, aYRepeatCount, aNode, aRect, |
|
909 |
aBitmap, aBitmapRect, |
|
910 |
aImageRect, yOffset ); |
|
911 |
aRect.Move( newRect.Width(), 0 ); |
|
912 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
913 |
{ |
|
914 |
break; |
|
915 |
} |
|
916 |
} |
|
917 |
} |
|
918 |
else if ( !aRepeatX && !aRepeatY && aSpaceX && aSpaceY ) |
|
919 |
{ |
|
920 |
aRect.SetRect( paddingRect.iTl, aRect.Size() ); |
|
921 |
if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 ) |
|
922 |
{ |
|
923 |
aRect.Move( |
|
924 |
( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2, |
|
925 |
0 ); |
|
926 |
} |
|
927 |
if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 ) |
|
928 |
{ |
|
929 |
aRect.Move( |
|
930 |
0, |
|
931 |
( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 ); |
|
932 |
} |
|
933 |
TInt yOffset = 0; |
|
934 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
935 |
{ |
|
936 |
aRect.Move( 0, -yOffset ); |
|
937 |
yOffset = 0; |
|
938 |
TRect newRect = TRect( |
|
939 |
aRect.iTl, |
|
940 |
TPoint( |
|
941 |
aRect.iTl.iX + aImageRect.Width(), |
|
942 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
943 |
aRect = newRect; |
|
944 |
DrawSpaceBackgroundY( |
|
945 |
aGc, aYRepeatCount, aNode, aRect, |
|
946 |
aBitmap, aBitmapRect, |
|
947 |
aImageRect, yOffset ); |
|
948 |
aRect.Move( newRect.Width(), 0 ); |
|
949 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
950 |
{ |
|
951 |
break; |
|
952 |
} |
|
953 |
} |
|
954 |
} |
|
955 |
else if ( aRepeatX && !aRepeatY && !aSpaceX && aSpaceY ) |
|
956 |
{ |
|
957 |
aRect.SetRect( paddingRect.iTl, aRect.Size() ); |
|
958 |
if ( aImageRect.Height() < paddingRect.Height() && aYRepeatCount > 0 ) |
|
959 |
{ |
|
960 |
aRect.Move( |
|
961 |
0, |
|
962 |
( paddingRect.Height() - aImageRect.Height() * aYRepeatCount ) / 2 ); |
|
963 |
} |
|
964 |
TInt yOffset = 0; |
|
965 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
966 |
{ |
|
967 |
aRect.Move( 0, -yOffset ); |
|
968 |
yOffset = 0; |
|
969 |
TRect newRect = TRect( |
|
970 |
aRect.iTl, |
|
971 |
TPoint( |
|
972 |
aRect.iTl.iX + aImageRect.Width(), |
|
973 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
974 |
aRect = newRect; |
|
975 |
DrawSpaceBackgroundY( |
|
976 |
aGc, aYRepeatCount, aNode, aRect, |
|
977 |
aBitmap, aBitmapRect, |
|
978 |
aImageRect, yOffset ); |
|
979 |
aRect.Move( newRect.Width(), 0 ); |
|
980 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
981 |
{ |
|
982 |
break; |
|
983 |
} |
|
984 |
} |
|
985 |
} |
|
986 |
else if ( !aRepeatX && aRepeatY && aSpaceX && !aSpaceY ) |
|
987 |
{ |
|
988 |
aRect.SetRect( paddingRect.iTl, aRect.Size() ); |
|
989 |
TInt yOffset = 0; |
|
990 |
if ( aImageRect.Width() < paddingRect.Width() && aXRepeatCount > 0 ) |
|
991 |
{ |
|
992 |
aRect.Move( |
|
993 |
( paddingRect.Width() - aImageRect.Width() * aXRepeatCount ) / 2, |
|
994 |
-yOffset ); |
|
995 |
} |
|
996 |
for ( TInt i = 0; i <= aXRepeatCount && aRect.iTl.iX < paddingRect.iBr.iX; ) |
|
997 |
{ |
|
998 |
aRect.Move( 0, -yOffset ); |
|
999 |
yOffset = 0; |
|
1000 |
TRect newRect = TRect( |
|
1001 |
aRect.iTl, |
|
1002 |
TPoint( |
|
1003 |
aRect.iTl.iX + aImageRect.Width(), |
|
1004 |
aRect.iTl.iY + aImageRect.Height() ) ); |
|
1005 |
aRect = newRect; |
|
1006 |
DrawRepeatBackgroundY( |
|
1007 |
aGc, aYRepeatCount, aNode, aRect, |
|
1008 |
aBitmap, aBitmapRect, |
|
1009 |
aImageRect, yOffset ); |
|
1010 |
aRect.Move( newRect.Width(), 0 ); |
|
1011 |
if ( ++i == aXRepeatCount || aXRepeatCount == 0 ) |
|
1012 |
{ |
|
1013 |
break; |
|
1014 |
} |
|
1015 |
} |
|
1016 |
} |
|
1017 |
} |
|
1018 |
||
1019 |
// ----------------------------------------------------------------------------- |
|
1020 |
// GetBackgroundPositionFromPropertyL |
|
1021 |
// Gets background position information from node properties |
|
1022 |
// ----------------------------------------------------------------------------- |
|
1023 |
// |
|
1024 |
static TBool GetBackgroundPositionFromPropertyL( |
|
1025 |
CXnNode& aNode, |
|
1026 |
TBool aScaleImage, |
|
1027 |
TRect& aRect, |
|
1028 |
TRect aImageRect, |
|
1029 |
CFbsBitmap* aBitmap, |
|
1030 |
TBool& aHeightSet ) |
|
1031 |
{ |
|
1032 |
CXnProperty* backgroundPositionProperty = aNode.GetPropertyL( |
|
1033 |
XnPropertyNames::appearance::common::KBackGroundPosition ); |
|
1034 |
TBool centerHorizontal = ETrue; |
|
1035 |
if ( backgroundPositionProperty ) |
|
1036 |
{ |
|
1037 |
CXnDomList& propertyValueList = |
|
1038 |
backgroundPositionProperty->Property()->PropertyValueList(); |
|
1039 |
TSize size; |
|
1040 |
for ( TInt i = propertyValueList.Length() - 1; i >= 0; --i ) |
|
1041 |
{ |
|
1042 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
1043 |
propertyValueList.Item( i ) ); |
|
1044 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString || |
|
1045 |
value->PrimitiveValueType() == CXnDomPropertyValue::EIdent ) |
|
1046 |
{ |
|
1047 |
if ( aScaleImage ) |
|
1048 |
{ |
|
1049 |
size = aImageRect.Size(); |
|
1050 |
} |
|
1051 |
else |
|
1052 |
{ |
|
1053 |
size = aBitmap->SizeInPixels(); |
|
1054 |
} |
|
1055 |
switch ( i ) |
|
1056 |
{ |
|
1057 |
case 0: |
|
1058 |
{ |
|
1059 |
// StringValueL will not leave, we check the type first |
|
1060 |
if ( value->StringValueL() == |
|
1061 |
XnPropertyNames::appearance::common::backgroundposition::KRight ) |
|
1062 |
{ |
|
1063 |
centerHorizontal = EFalse; |
|
1064 |
aRect.Move( aRect.Width(), 0 ); |
|
1065 |
aRect.Move( -size.iWidth, 0 ); |
|
1066 |
} |
|
1067 |
else if ( value->StringValueL() == |
|
1068 |
XnPropertyNames::appearance::common::backgroundposition::KLeft ) |
|
1069 |
{ |
|
1070 |
centerHorizontal = EFalse; |
|
1071 |
} |
|
1072 |
else if ( value->StringValueL() == |
|
1073 |
XnPropertyNames::appearance::common::backgroundposition::KBottom ) |
|
1074 |
{ |
|
1075 |
aHeightSet = ETrue; |
|
1076 |
aRect.Move( 0, aRect.Height() ); |
|
1077 |
aRect.Move( 0, -size.iHeight ); |
|
1078 |
} |
|
1079 |
else if ( value->StringValueL() == |
|
1080 |
XnPropertyNames::appearance::common::backgroundposition::KTop ) |
|
1081 |
{ |
|
1082 |
aHeightSet = ETrue; |
|
1083 |
} |
|
1084 |
break; |
|
1085 |
} |
|
1086 |
case 1: |
|
1087 |
{ |
|
1088 |
// StringValueL will not leave, we check the type first |
|
1089 |
if ( value->StringValueL() == |
|
1090 |
XnPropertyNames::appearance::common::backgroundposition::KRight ) |
|
1091 |
{ |
|
1092 |
aRect.Move( aRect.Width(), 0 ); |
|
1093 |
aRect.Move( -size.iWidth, 0 ); |
|
1094 |
centerHorizontal = EFalse; |
|
1095 |
} |
|
1096 |
else if ( value->StringValueL() == |
|
1097 |
XnPropertyNames::appearance::common::backgroundposition::KLeft ) |
|
1098 |
{ |
|
1099 |
centerHorizontal = EFalse; |
|
1100 |
} |
|
1101 |
else if ( value->StringValueL() == |
|
1102 |
XnPropertyNames::appearance::common::backgroundposition::KBottom ) |
|
1103 |
{ |
|
1104 |
aHeightSet = ETrue; |
|
1105 |
aRect.Move( 0, aRect.Height() ); |
|
1106 |
aRect.Move( 0, -size.iHeight ); |
|
1107 |
} |
|
1108 |
else if ( value->StringValueL() == |
|
1109 |
XnPropertyNames::appearance::common::backgroundposition::KTop ) |
|
1110 |
{ |
|
1111 |
aHeightSet = ETrue; |
|
1112 |
} |
|
1113 |
break; |
|
1114 |
} |
|
1115 |
} |
|
1116 |
} |
|
1117 |
else if ( value->PrimitiveValueType() == CXnDomPropertyValue::EPercentage ) |
|
1118 |
{ |
|
1119 |
// FloatValueL will not leave, we check the type first |
|
1120 |
TReal percentage = value->FloatValueL(); |
|
1121 |
if ( percentage > 100 ) |
|
1122 |
{ |
|
1123 |
percentage = 100; |
|
1124 |
} |
|
1125 |
TSize size = aImageRect.Size(); |
|
1126 |
switch ( i ) |
|
1127 |
{ |
|
1128 |
case 0: |
|
1129 |
{ |
|
1130 |
TInt rectOffset = ( percentage / 100.0 ) * aRect.Width(); |
|
1131 |
TInt bitmapOffset = ( percentage / 100.0 ) * size.iWidth; |
|
1132 |
aRect.Move( rectOffset, 0 ); |
|
1133 |
aRect.Move( -bitmapOffset, 0 ); |
|
1134 |
centerHorizontal = EFalse; |
|
1135 |
break; |
|
1136 |
} |
|
1137 |
case 1: |
|
1138 |
{ |
|
1139 |
aHeightSet = ETrue; |
|
1140 |
TInt rectOffset = ( percentage / 100.0 ) * aRect.Height(); |
|
1141 |
TInt bitmapOffset = ( percentage / 100.0 ) * size.iHeight; |
|
1142 |
aRect.Move( 0, rectOffset ); |
|
1143 |
aRect.Move( 0, -bitmapOffset ); |
|
1144 |
break; |
|
1145 |
} |
|
1146 |
} |
|
1147 |
} |
|
1148 |
else |
|
1149 |
{ |
|
1150 |
CXnDomPropertyValue* tmpValue = NULL; |
|
1151 |
TRAPD( error, tmpValue = value->CloneL(); ); |
|
1152 |
if ( error != KErrNone ) |
|
1153 |
{ |
|
1154 |
return EFalse; |
|
1155 |
} |
|
1156 |
CXnProperty* tmpProperty = NULL; |
|
1157 |
TRAP( error, tmpProperty = CXnProperty::NewL( |
|
1158 |
KNullDesC8, |
|
1159 |
tmpValue, |
|
1160 |
*aNode.UiEngine()->ODT()->DomDocument().StringPool() ); ); |
|
1161 |
if ( error != KErrNone ) |
|
1162 |
{ |
|
1163 |
delete tmpValue; |
|
1164 |
return EFalse; |
|
1165 |
} |
|
1166 |
switch ( i ) |
|
1167 |
{ |
|
1168 |
case 0: |
|
1169 |
{ |
|
1170 |
TInt intValue = 0; |
|
1171 |
TRAP( error, |
|
1172 |
intValue = aNode.UiEngine()->HorizontalPixelValueL( |
|
1173 |
tmpProperty, 0 ); ); |
|
1174 |
if ( error != KErrNone ) |
|
1175 |
{ |
|
1176 |
delete tmpProperty; |
|
1177 |
return EFalse; |
|
1178 |
} |
|
1179 |
aRect.Move( intValue, 0 ); |
|
1180 |
centerHorizontal = EFalse; |
|
1181 |
break; |
|
1182 |
} |
|
1183 |
case 1: |
|
1184 |
{ |
|
1185 |
aHeightSet = ETrue; |
|
1186 |
TInt intValue = 0; |
|
1187 |
TRAP( error, |
|
1188 |
intValue = aNode.UiEngine()->VerticalPixelValueL( |
|
1189 |
tmpProperty, 0 ); ); |
|
1190 |
if ( error != KErrNone ) |
|
1191 |
{ |
|
1192 |
delete tmpProperty; |
|
1193 |
return EFalse; |
|
1194 |
} |
|
1195 |
aRect.Move( 0, intValue ); |
|
1196 |
break; |
|
1197 |
} |
|
1198 |
} |
|
1199 |
delete tmpProperty; |
|
1200 |
} |
|
1201 |
} |
|
1202 |
if ( centerHorizontal ) |
|
1203 |
{ |
|
1204 |
aRect.Move( aRect.Width() / 2, 0 ); |
|
1205 |
aRect.Move( -size.iWidth / 2, 0 ); |
|
1206 |
} |
|
1207 |
} |
|
1208 |
else |
|
1209 |
{ |
|
1210 |
aHeightSet = ETrue; |
|
1211 |
} |
|
1212 |
return ETrue; |
|
1213 |
} |
|
1214 |
||
1215 |
// ----------------------------------------------------------------------------- |
|
1216 |
// GetBackgroundSizeFromPropertyL |
|
1217 |
// Gets background size information from node properties |
|
1218 |
// ----------------------------------------------------------------------------- |
|
1219 |
// |
|
1220 |
static TBool GetBackgroundSizeFromPropertyL( |
|
1221 |
TRect& aRect, |
|
1222 |
CXnNode& aNode, |
|
1223 |
CFbsBitmap* aBitmap, |
|
1224 |
TBool& aScaleImage ) |
|
1225 |
{ |
|
1226 |
CXnProperty* backgroundSizeProperty = aNode.GetPropertyL( |
|
1227 |
XnPropertyNames::appearance::common::KBackGroundSize ); |
|
1228 |
TBool widthAuto = ETrue; |
|
1229 |
TBool heightAuto = ETrue; |
|
1230 |
TBool heightSet = EFalse; |
|
1231 |
TSize size = aBitmap->SizeInPixels(); |
|
1232 |
if ( backgroundSizeProperty ) |
|
1233 |
{ |
|
1234 |
widthAuto = EFalse; |
|
1235 |
heightAuto = EFalse; |
|
1236 |
CXnDomList& propertyValueList = |
|
1237 |
backgroundSizeProperty->Property()->PropertyValueList(); |
|
1238 |
for ( TInt i = propertyValueList.Length() - 1; i >= 0; --i ) |
|
1239 |
{ |
|
1240 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
1241 |
propertyValueList.Item( i ) ); |
|
1242 |
if ( value->IsAutoIdent() ) |
|
1243 |
{ |
|
1244 |
switch ( i ) |
|
1245 |
{ |
|
1246 |
case 0: |
|
1247 |
{ |
|
1248 |
widthAuto = ETrue; |
|
1249 |
break; |
|
1250 |
} |
|
1251 |
case 1: |
|
1252 |
{ |
|
1253 |
heightAuto = ETrue; |
|
1254 |
break; |
|
1255 |
} |
|
1256 |
} |
|
1257 |
} |
|
1258 |
} |
|
1259 |
for ( TInt i = propertyValueList.Length() - 1; i >= 0; --i ) |
|
1260 |
{ |
|
1261 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
1262 |
propertyValueList.Item( i ) ); |
|
1263 |
if ( value->IsAutoIdent() ) |
|
1264 |
{ |
|
1265 |
continue; |
|
1266 |
} |
|
1267 |
else if ( value->PrimitiveValueType() == CXnDomPropertyValue::EPercentage ) |
|
1268 |
{ |
|
1269 |
// FloatValueL will not leave, we check the type first |
|
1270 |
TReal percentage = 100; |
|
1271 |
TRAP_IGNORE( percentage = value->FloatValueL() ); |
|
1272 |
if ( percentage > 100 ) |
|
1273 |
{ |
|
1274 |
percentage = 100; |
|
1275 |
} |
|
1276 |
switch ( i ) |
|
1277 |
{ |
|
1278 |
case 0: |
|
1279 |
{ |
|
1280 |
TInt widthOffset = ( 1 - ( percentage / 100.0 ) ) * aRect.Width(); |
|
1281 |
if ( heightAuto ) |
|
1282 |
{ |
|
1283 |
TReal aspectRatio = |
|
1284 |
static_cast< TReal >( size.iHeight ) / |
|
1285 |
static_cast< TReal >( size.iWidth ); |
|
1286 |
aRect.Resize( -widthOffset, 0 ); |
|
1287 |
aRect.SetHeight( |
|
1288 |
static_cast< TInt >( |
|
1289 |
static_cast< TReal >( |
|
1290 |
aRect.Width() ) * aspectRatio + 0.5 ) ); |
|
1291 |
aScaleImage = ETrue; |
|
1292 |
heightSet = ETrue; |
|
1293 |
} |
|
1294 |
else |
|
1295 |
{ |
|
1296 |
aRect.Resize( -widthOffset, 0 ); |
|
1297 |
aScaleImage = ETrue; |
|
1298 |
} |
|
1299 |
if ( !heightSet ) |
|
1300 |
{ |
|
1301 |
TInt heightOffset = ( 1 - ( percentage / 100.0 ) ) * aRect.Height(); |
|
1302 |
aRect.Resize( 0, -heightOffset ); |
|
1303 |
} |
|
1304 |
break; |
|
1305 |
} |
|
1306 |
case 1: |
|
1307 |
{ |
|
1308 |
TInt heightOffset = ( 1 - ( percentage / 100.0 ) ) * aRect.Height(); |
|
1309 |
if ( widthAuto ) |
|
1310 |
{ |
|
1311 |
TReal aspectRatio = |
|
1312 |
static_cast< TReal >( size.iHeight ) / |
|
1313 |
static_cast< TReal >( size.iWidth ); |
|
1314 |
aRect.Resize( 0, -heightOffset ); |
|
1315 |
aRect.SetWidth( |
|
1316 |
static_cast< TInt >( |
|
1317 |
static_cast< TReal >( |
|
1318 |
aRect.Height() ) / aspectRatio + 0.5 ) ); |
|
1319 |
aScaleImage = ETrue; |
|
1320 |
heightSet = ETrue; |
|
1321 |
} |
|
1322 |
else |
|
1323 |
{ |
|
1324 |
aRect.Resize( 0, -heightOffset ); |
|
1325 |
aScaleImage = ETrue; |
|
1326 |
heightSet = ETrue; |
|
1327 |
} |
|
1328 |
break; |
|
1329 |
} |
|
1330 |
} |
|
1331 |
} |
|
1332 |
else |
|
1333 |
{ |
|
1334 |
CXnDomPropertyValue* tmpValue = NULL; |
|
1335 |
TRAPD( error, tmpValue = value->CloneL(); ); |
|
1336 |
if ( error != KErrNone ) |
|
1337 |
{ |
|
1338 |
return EFalse; |
|
1339 |
} |
|
1340 |
CXnProperty* tmpProperty = NULL; |
|
1341 |
TRAP( error, tmpProperty = CXnProperty::NewL( |
|
1342 |
KNullDesC8, tmpValue, |
|
1343 |
*aNode.UiEngine()->ODT()->DomDocument().StringPool() ); ); |
|
1344 |
if ( error != KErrNone ) |
|
1345 |
{ |
|
1346 |
delete tmpValue; |
|
1347 |
return EFalse; |
|
1348 |
} |
|
1349 |
switch ( i ) |
|
1350 |
{ |
|
1351 |
case 0: |
|
1352 |
{ |
|
1353 |
TInt intValue = 0; |
|
1354 |
TRAP( error, |
|
1355 |
intValue = aNode.UiEngine()->HorizontalPixelValueL( |
|
1356 |
tmpProperty, 0 ); ); |
|
1357 |
TInt widthOffset = aRect.Width() - intValue; |
|
1358 |
if ( heightAuto ) |
|
1359 |
{ |
|
1360 |
TReal aspectRatio = |
|
1361 |
static_cast< TReal >( size.iHeight ) / |
|
1362 |
static_cast< TReal >( size.iWidth ); |
|
1363 |
aRect.Resize( -widthOffset, 0 ); |
|
1364 |
aRect.SetHeight( |
|
1365 |
static_cast< TInt >( |
|
1366 |
static_cast< TReal >( |
|
1367 |
aRect.Width() ) * aspectRatio + 0.5 ) ); |
|
1368 |
aScaleImage = ETrue; |
|
1369 |
heightSet = ETrue; |
|
1370 |
} |
|
1371 |
else |
|
1372 |
{ |
|
1373 |
aRect.Resize( -widthOffset, 0 ); |
|
1374 |
aScaleImage = ETrue; |
|
1375 |
} |
|
1376 |
if ( !heightSet ) |
|
1377 |
{ |
|
1378 |
TInt heightOffset = aRect.Height() - intValue; |
|
1379 |
aRect.Resize( 0, -heightOffset ); |
|
1380 |
} |
|
1381 |
break; |
|
1382 |
} |
|
1383 |
case 1: |
|
1384 |
{ |
|
1385 |
TInt intValue = 0; |
|
1386 |
TRAP( error, |
|
1387 |
intValue = aNode.UiEngine()->VerticalPixelValueL( |
|
1388 |
tmpProperty, 0 ); ); |
|
1389 |
TInt heightOffset = aRect.Height() - intValue; |
|
1390 |
if ( widthAuto ) |
|
1391 |
{ |
|
1392 |
TReal aspectRatio = |
|
1393 |
static_cast< TReal >( size.iHeight ) / |
|
1394 |
static_cast< TReal >( size.iWidth ); |
|
1395 |
aRect.Resize( 0, -heightOffset ); |
|
1396 |
aRect.SetWidth( |
|
1397 |
static_cast< TInt >( |
|
1398 |
static_cast< TReal >( |
|
1399 |
aRect.Height() ) / aspectRatio + 0.5 ) ); |
|
1400 |
aScaleImage = ETrue; |
|
1401 |
heightSet = ETrue; |
|
1402 |
} |
|
1403 |
else |
|
1404 |
{ |
|
1405 |
aRect.Resize( 0, -heightOffset ); |
|
1406 |
aScaleImage = ETrue; |
|
1407 |
heightSet = ETrue; |
|
1408 |
} |
|
1409 |
break; |
|
1410 |
} |
|
1411 |
} |
|
1412 |
delete tmpProperty; |
|
1413 |
} |
|
1414 |
} |
|
1415 |
} |
|
1416 |
if ( widthAuto && heightAuto ) |
|
1417 |
{ |
|
1418 |
if ( size.iHeight < aRect.Height() ) |
|
1419 |
{ |
|
1420 |
aRect.SetHeight( size.iHeight ); |
|
1421 |
} |
|
1422 |
if ( size.iWidth < aRect.Width() ) |
|
1423 |
{ |
|
1424 |
aRect.SetWidth( size.iWidth ); |
|
1425 |
} |
|
1426 |
aScaleImage = EFalse; |
|
1427 |
} |
|
1428 |
return ETrue; |
|
1429 |
} |
|
1430 |
||
1431 |
// ----------------------------------------------------------------------------- |
|
1432 |
// LighterColor |
|
1433 |
// Gets a color that has more HSL lightness (used for border effects) |
|
1434 |
// ----------------------------------------------------------------------------- |
|
1435 |
// |
|
1436 |
static TRgb LighterColor( const TRgb& aRgb ) |
|
1437 |
{ |
|
1438 |
TUint hue; |
|
1439 |
TUint saturation; |
|
1440 |
TUint lightness; |
|
1441 |
ConvertRgbToHsl( aRgb, hue, saturation, lightness ); |
|
1442 |
if ( ( static_cast< TInt >( lightness ) + 10 ) <= 100 ) |
|
1443 |
{ |
|
1444 |
lightness += 10; |
|
1445 |
} |
|
1446 |
else |
|
1447 |
{ |
|
1448 |
lightness = 100; |
|
1449 |
} |
|
1450 |
return ConvertHslToRgb( hue, saturation, lightness ); |
|
1451 |
} |
|
1452 |
||
1453 |
// ----------------------------------------------------------------------------- |
|
1454 |
// DarkerColor |
|
1455 |
// Gets a color that has less HSL lightness (used for border effects) |
|
1456 |
// ----------------------------------------------------------------------------- |
|
1457 |
// |
|
1458 |
static TRgb DarkerColor( const TRgb& aRgb ) |
|
1459 |
{ |
|
1460 |
TUint hue; |
|
1461 |
TUint saturation; |
|
1462 |
TUint lightness; |
|
1463 |
ConvertRgbToHsl( aRgb, hue, saturation, lightness ); |
|
1464 |
if ( ( static_cast< TInt >( lightness ) - 10 ) >= 0 ) |
|
1465 |
{ |
|
1466 |
lightness -= 10; |
|
1467 |
} |
|
1468 |
else |
|
1469 |
{ |
|
1470 |
lightness = 0; |
|
1471 |
} |
|
1472 |
return ConvertHslToRgb( hue, saturation, lightness ); |
|
1473 |
} |
|
1474 |
||
1475 |
// ----------------------------------------------------------------------------- |
|
1476 |
// DrawSolidTopBorder |
|
1477 |
// Draw a top border with solid style |
|
1478 |
// ----------------------------------------------------------------------------- |
|
1479 |
// |
|
1480 |
static void DrawSolidTopBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ) |
|
1481 |
{ |
|
1482 |
aGc.DrawPolygon( aArray ); |
|
1483 |
} |
|
1484 |
||
1485 |
// ----------------------------------------------------------------------------- |
|
1486 |
// SplitTopBorderPolygonL |
|
1487 |
// Split top border to two parts for border effect drawing |
|
1488 |
// ----------------------------------------------------------------------------- |
|
1489 |
// |
|
1490 |
static void SplitTopBorderPolygonL( |
|
1491 |
CArrayFix< TPoint >* aArray, |
|
1492 |
CArrayFix< TPoint >*& aUpperPart, |
|
1493 |
CArrayFix< TPoint >*& aLowerPart ) |
|
1494 |
{ |
|
1495 |
TPoint leftHalf = |
|
1496 |
TPoint( |
|
1497 |
( *aArray )[0].iX + ( ( *aArray )[3].iX - ( *aArray )[0].iX ) / 2, |
|
1498 |
( *aArray )[0].iY + ( ( *aArray )[3].iY - ( *aArray )[0].iY ) / 2); |
|
1499 |
TPoint rightHalf = |
|
1500 |
TPoint( |
|
1501 |
( *aArray )[2].iX + ( ( *aArray )[1].iX - ( *aArray )[2].iX ) / 2, |
|
1502 |
( *aArray )[1].iY + ( ( *aArray )[2].iY - ( *aArray )[1].iY ) / 2); |
|
1503 |
aUpperPart->AppendL( ( *aArray )[0] ); |
|
1504 |
aUpperPart->AppendL( ( *aArray )[1] ); |
|
1505 |
aUpperPart->AppendL( rightHalf ); |
|
1506 |
aUpperPart->AppendL( leftHalf ); |
|
1507 |
aLowerPart->AppendL( leftHalf ); |
|
1508 |
aLowerPart->AppendL( rightHalf ); |
|
1509 |
aLowerPart->AppendL( ( *aArray )[2] ); |
|
1510 |
aLowerPart->AppendL( ( *aArray )[3] ); |
|
1511 |
} |
|
1512 |
||
1513 |
// ----------------------------------------------------------------------------- |
|
1514 |
// DrawRidgeTopBorderL |
|
1515 |
// Draw top border with ridge style |
|
1516 |
// ----------------------------------------------------------------------------- |
|
1517 |
// |
|
1518 |
static void DrawRidgeTopBorderL( |
|
1519 |
CArrayFix< TPoint >* aArray, |
|
1520 |
CWindowGc& aGc, TRgb& aRgb ) |
|
1521 |
{ |
|
1522 |
CArrayFix< TPoint >* upperPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1523 |
CleanupStack::PushL( upperPart ); |
|
1524 |
CArrayFix< TPoint >* lowerPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1525 |
CleanupStack::PushL( lowerPart ); |
|
1526 |
SplitTopBorderPolygonL( aArray, upperPart, lowerPart ); |
|
1527 |
TRgb rgb = LighterColor( aRgb ); |
|
1528 |
aGc.SetPenColor( rgb ); |
|
1529 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1530 |
aGc.SetBrushColor( rgb ); |
|
1531 |
aGc.DrawPolygon( upperPart ); |
|
1532 |
rgb = DarkerColor( aRgb ); |
|
1533 |
aGc.SetPenColor( rgb ); |
|
1534 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1535 |
aGc.SetBrushColor( rgb ); |
|
1536 |
aGc.DrawPolygon( lowerPart ); |
|
1537 |
CleanupStack::PopAndDestroy( lowerPart ); |
|
1538 |
CleanupStack::PopAndDestroy( upperPart ); |
|
1539 |
} |
|
1540 |
||
1541 |
// ----------------------------------------------------------------------------- |
|
1542 |
// DrawGrooveTopBorderL |
|
1543 |
// Draw top border with groove style |
|
1544 |
// ----------------------------------------------------------------------------- |
|
1545 |
// |
|
1546 |
static void DrawGrooveTopBorderL( |
|
1547 |
CArrayFix< TPoint >* aArray, |
|
1548 |
CWindowGc& aGc, TRgb& aRgb ) |
|
1549 |
{ |
|
1550 |
CArrayFix< TPoint >* upperPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1551 |
CleanupStack::PushL( upperPart ); |
|
1552 |
CArrayFix< TPoint >* lowerPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1553 |
CleanupStack::PushL( lowerPart ); |
|
1554 |
SplitTopBorderPolygonL( aArray, upperPart, lowerPart ); |
|
1555 |
TRgb rgb = DarkerColor( aRgb ); |
|
1556 |
aGc.SetPenColor( rgb ); |
|
1557 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1558 |
aGc.SetBrushColor( rgb ); |
|
1559 |
aGc.DrawPolygon( upperPart ); |
|
1560 |
rgb = LighterColor( aRgb ); |
|
1561 |
aGc.SetPenColor( rgb ); |
|
1562 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1563 |
aGc.SetBrushColor( rgb ); |
|
1564 |
aGc.DrawPolygon( lowerPart ); |
|
1565 |
CleanupStack::PopAndDestroy( lowerPart ); |
|
1566 |
CleanupStack::PopAndDestroy( upperPart ); |
|
1567 |
} |
|
1568 |
||
1569 |
// ----------------------------------------------------------------------------- |
|
1570 |
// DrawInsetTopBorder |
|
1571 |
// Draw top border with inset style |
|
1572 |
// ----------------------------------------------------------------------------- |
|
1573 |
// |
|
1574 |
static void DrawInsetTopBorder( |
|
1575 |
CArrayFix< TPoint >* aArray, |
|
1576 |
CWindowGc& aGc, TRgb& aRgb ) |
|
1577 |
{ |
|
1578 |
TRgb rgb = DarkerColor( aRgb ); |
|
1579 |
aGc.SetPenColor( rgb ); |
|
1580 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1581 |
aGc.SetBrushColor( rgb ); |
|
1582 |
aGc.DrawPolygon( aArray ); |
|
1583 |
} |
|
1584 |
||
1585 |
// ----------------------------------------------------------------------------- |
|
1586 |
// DrawOutsetTopBorder |
|
1587 |
// Draw top border with outset style |
|
1588 |
// ----------------------------------------------------------------------------- |
|
1589 |
// |
|
1590 |
static void DrawOutsetTopBorder( |
|
1591 |
CArrayFix< TPoint >* aArray, |
|
1592 |
CWindowGc& aGc, TRgb& aRgb ) |
|
1593 |
{ |
|
1594 |
TRgb rgb = LighterColor( aRgb ); |
|
1595 |
aGc.SetPenColor( rgb ); |
|
1596 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1597 |
aGc.SetBrushColor( rgb ); |
|
1598 |
aGc.DrawPolygon( aArray ); |
|
1599 |
} |
|
1600 |
||
1601 |
// ----------------------------------------------------------------------------- |
|
1602 |
// GetBorderColorL |
|
1603 |
// Get border color from properties |
|
1604 |
// ----------------------------------------------------------------------------- |
|
1605 |
// |
|
1606 |
static TBool GetBorderColorL( |
|
1607 |
const TDesC8& aPropertyName, |
|
1608 |
CXnNode& aNode, |
|
1609 |
CWindowGc& aGc, |
|
1610 |
TRgb& aRgb ) |
|
1611 |
{ |
|
1612 |
CXnProperty* colorProperty = aNode.GetPropertyL( aPropertyName ); |
|
1613 |
CXnProperty* currentColorProperty = aNode.GetPropertyL( |
|
1614 |
XnPropertyNames::appearance::common::KColor ); |
|
1615 |
CXnProperty* borderColorProperty = aNode.GetPropertyL( |
|
1616 |
XnPropertyNames::appearance::common::KBorderColor ); |
|
1617 |
if ( colorProperty ) |
|
1618 |
{ |
|
1619 |
CXnDomProperty* domProperty = colorProperty->Property(); |
|
1620 |
CXnDomPropertyValue* propertyValue = NULL; |
|
1621 |
propertyValue = static_cast< CXnDomPropertyValue* >( |
|
1622 |
domProperty->PropertyValueList().Item( 0 ) ); |
|
1623 |
if ( propertyValue->IsAutoIdent() ) |
|
1624 |
{ |
|
1625 |
MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
|
1626 |
TInt error = AknsUtils::GetCachedColor( |
|
1627 |
skinInstance, |
|
1628 |
aRgb, |
|
1629 |
KAknsIIDQsnLineColors, |
|
1630 |
EAknsCIQsnLineColorsCG4 ); |
|
1631 |
if ( error != KErrNone ) |
|
1632 |
{ |
|
1633 |
return EFalse; |
|
1634 |
} |
|
1635 |
} |
|
1636 |
else |
|
1637 |
{ |
|
1638 |
TRAPD( error, aRgb = propertyValue->RgbColorValueL(); ); |
|
1639 |
if ( error != KErrNone ) |
|
1640 |
{ |
|
1641 |
return EFalse; |
|
1642 |
} |
|
1643 |
} |
|
1644 |
aGc.SetPenColor( aRgb ); |
|
1645 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1646 |
aGc.SetBrushColor( aRgb ); |
|
1647 |
} |
|
1648 |
else if ( borderColorProperty ) |
|
1649 |
{ |
|
1650 |
CXnDomProperty* domProperty = borderColorProperty->Property(); |
|
1651 |
CXnDomPropertyValue* propertyValue = NULL; |
|
1652 |
propertyValue = static_cast< CXnDomPropertyValue* >( |
|
1653 |
domProperty->PropertyValueList().Item( 0 ) ); |
|
1654 |
if ( propertyValue->IsAutoIdent() ) |
|
1655 |
{ |
|
1656 |
MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
|
1657 |
TInt error = AknsUtils::GetCachedColor( |
|
1658 |
skinInstance, |
|
1659 |
aRgb, |
|
1660 |
KAknsIIDQsnLineColors, |
|
1661 |
EAknsCIQsnLineColorsCG4 ); |
|
1662 |
if ( error != KErrNone ) |
|
1663 |
{ |
|
1664 |
return EFalse; |
|
1665 |
} |
|
1666 |
} |
|
1667 |
else |
|
1668 |
{ |
|
1669 |
TRAPD( error, aRgb = propertyValue->RgbColorValueL(); ); |
|
1670 |
if ( error != KErrNone ) |
|
1671 |
{ |
|
1672 |
return EFalse; |
|
1673 |
} |
|
1674 |
} |
|
1675 |
aGc.SetPenColor( aRgb ); |
|
1676 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1677 |
aGc.SetBrushColor( aRgb ); |
|
1678 |
} |
|
1679 |
else if ( currentColorProperty ) |
|
1680 |
{ |
|
1681 |
CXnDomProperty* domProperty = currentColorProperty->Property(); |
|
1682 |
CXnDomPropertyValue* propertyValue = NULL; |
|
1683 |
propertyValue = static_cast< CXnDomPropertyValue* >( |
|
1684 |
domProperty->PropertyValueList().Item( 0 ) ); |
|
1685 |
if ( propertyValue->IsAutoIdent() ) |
|
1686 |
{ |
|
1687 |
MAknsSkinInstance* skinInstance = AknsUtils::SkinInstance(); |
|
1688 |
TInt error = AknsUtils::GetCachedColor( |
|
1689 |
skinInstance, |
|
1690 |
aRgb, |
|
1691 |
KAknsIIDQsnLineColors, |
|
1692 |
EAknsCIQsnLineColorsCG4 ); |
|
1693 |
if ( error != KErrNone ) |
|
1694 |
{ |
|
1695 |
return EFalse; |
|
1696 |
} |
|
1697 |
} |
|
1698 |
else |
|
1699 |
{ |
|
1700 |
TRAPD( error, aRgb = propertyValue->RgbColorValueL(); ); |
|
1701 |
if ( error != KErrNone ) |
|
1702 |
{ |
|
1703 |
return EFalse; |
|
1704 |
} |
|
1705 |
} |
|
1706 |
aGc.SetPenColor( aRgb ); |
|
1707 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1708 |
aGc.SetBrushColor( aRgb ); |
|
1709 |
} |
|
1710 |
else |
|
1711 |
{ |
|
1712 |
return EFalse; |
|
1713 |
} |
|
1714 |
return ETrue; |
|
1715 |
} |
|
1716 |
||
1717 |
// ----------------------------------------------------------------------------- |
|
1718 |
// DrawTopBorderL |
|
1719 |
// Draw top border |
|
1720 |
// ----------------------------------------------------------------------------- |
|
1721 |
// |
|
1722 |
static void DrawTopBorderL( |
|
1723 |
const TRect& /*aRect*/, |
|
1724 |
CXnNode& aNode, |
|
1725 |
CWindowGc& aGc ) |
|
1726 |
{ |
|
1727 |
TRect borderRect = aNode.BorderRect(); |
|
1728 |
TRect paddingRect = aNode.PaddingRect(); |
|
1729 |
TRgb rgb; |
|
1730 |
if ( !GetBorderColorL( XnPropertyNames::appearance::common::KBorderTopColor, aNode, aGc, rgb ) ) |
|
1731 |
{ |
|
1732 |
return; |
|
1733 |
} |
|
1734 |
TPoint tl = borderRect.iTl; |
|
1735 |
TPoint bl = paddingRect.iTl; |
|
1736 |
bl.iY -= 1; |
|
1737 |
bl.iX -= 1; |
|
1738 |
TPoint tr = borderRect.iTl; |
|
1739 |
tr.iX += borderRect.Width()-1; |
|
1740 |
TPoint br = paddingRect.iTl; |
|
1741 |
br.iX += paddingRect.Width(); |
|
1742 |
br.iY -= 1; |
|
1743 |
CArrayFix< TPoint >* array = NULL; |
|
1744 |
array = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1745 |
TRAPD( error, |
|
1746 |
array->AppendL( tl ); |
|
1747 |
array->AppendL( tr ); |
|
1748 |
array->AppendL( br ); |
|
1749 |
array->AppendL( bl ) ); |
|
1750 |
if ( error != KErrNone ) |
|
1751 |
{ |
|
1752 |
delete array; |
|
1753 |
return; |
|
1754 |
} |
|
1755 |
CXnProperty* borderTopStyle = aNode.BorderTopStyleL(); |
|
1756 |
CXnProperty* borderStyle = aNode.BorderStyleL(); |
|
1757 |
const TDesC8& borderStyleString = ( borderTopStyle ) ? |
|
1758 |
borderTopStyle->StringValue() : |
|
1759 |
( borderStyle ) ? borderStyle->StringValue() : KNullDesC8; |
|
1760 |
if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KSolid ) |
|
1761 |
{ |
|
1762 |
DrawSolidTopBorder( array, aGc ); |
|
1763 |
} |
|
1764 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KInset ) |
|
1765 |
{ |
|
1766 |
DrawInsetTopBorder( array, aGc, rgb ); |
|
1767 |
} |
|
1768 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KOutset ) |
|
1769 |
{ |
|
1770 |
DrawOutsetTopBorder( array, aGc, rgb ); |
|
1771 |
} |
|
1772 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KRidge ) |
|
1773 |
{ |
|
1774 |
TRAP_IGNORE( DrawRidgeTopBorderL( array, aGc, rgb ) ); |
|
1775 |
} |
|
1776 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KGroove ) |
|
1777 |
{ |
|
1778 |
TRAP_IGNORE( DrawGrooveTopBorderL( array, aGc, rgb ) ); |
|
1779 |
} |
|
1780 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KDotted ) |
|
1781 |
{ |
|
1782 |
TPoint end( borderRect.iBr.iX, paddingRect.iTl.iY ); |
|
1783 |
TRect rect( borderRect.iTl, end ); |
|
1784 |
DrawDottedBorder( rect, aGc, rgb, ETrue ); |
|
1785 |
} |
|
1786 |
delete array; |
|
1787 |
} |
|
1788 |
||
1789 |
// ----------------------------------------------------------------------------- |
|
1790 |
// DrawSolidBottomBorder |
|
1791 |
// Draw bottom border with solid style |
|
1792 |
// ----------------------------------------------------------------------------- |
|
1793 |
// |
|
1794 |
static void DrawSolidBottomBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ) |
|
1795 |
{ |
|
1796 |
aGc.DrawPolygon( aArray ); |
|
1797 |
} |
|
1798 |
||
1799 |
// ----------------------------------------------------------------------------- |
|
1800 |
// SplitBottomBorderPolygonL |
|
1801 |
// Split bottom border to two parts for border effect drawing |
|
1802 |
// ----------------------------------------------------------------------------- |
|
1803 |
// |
|
1804 |
static void SplitBottomBorderPolygonL( |
|
1805 |
CArrayFix< TPoint >* aArray, |
|
1806 |
CArrayFix< TPoint >*& aUpperPart, |
|
1807 |
CArrayFix< TPoint >*& aLowerPart ) |
|
1808 |
{ |
|
1809 |
TPoint leftHalf = |
|
1810 |
TPoint( |
|
1811 |
( *aArray )[3].iX + ( ( *aArray )[0].iX - ( *aArray )[3].iX ) / 2, |
|
1812 |
( *aArray )[3].iY + ( ( *aArray )[0].iY - ( *aArray )[3].iY ) / 2); |
|
1813 |
TPoint rightHalf = |
|
1814 |
TPoint( |
|
1815 |
( *aArray )[1].iX + ( ( *aArray )[2].iX - ( *aArray )[1].iX ) / 2, |
|
1816 |
( *aArray )[2].iY + ( ( *aArray )[1].iY - ( *aArray )[2].iY ) / 2); |
|
1817 |
aUpperPart->AppendL( ( *aArray )[0] ); |
|
1818 |
aUpperPart->AppendL( ( *aArray )[1] ); |
|
1819 |
aUpperPart->AppendL( rightHalf ); |
|
1820 |
aUpperPart->AppendL( leftHalf ); |
|
1821 |
aLowerPart->AppendL( leftHalf ); |
|
1822 |
aLowerPart->AppendL( rightHalf ); |
|
1823 |
aLowerPart->AppendL( ( *aArray )[2] ); |
|
1824 |
aLowerPart->AppendL( ( *aArray )[3] ); |
|
1825 |
} |
|
1826 |
||
1827 |
// ----------------------------------------------------------------------------- |
|
1828 |
// DrawRidgeBottomBorderL |
|
1829 |
// Draw bottom border with ridge style |
|
1830 |
// ----------------------------------------------------------------------------- |
|
1831 |
// |
|
1832 |
static void DrawRidgeBottomBorderL( |
|
1833 |
CArrayFix< TPoint >* aArray, |
|
1834 |
CWindowGc& aGc, |
|
1835 |
TRgb& aRgb ) |
|
1836 |
{ |
|
1837 |
CArrayFix< TPoint >* upperPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1838 |
CleanupStack::PushL( upperPart ); |
|
1839 |
CArrayFix< TPoint >* lowerPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1840 |
CleanupStack::PushL( lowerPart ); |
|
1841 |
SplitBottomBorderPolygonL( aArray, upperPart, lowerPart ); |
|
1842 |
TRgb rgb = LighterColor( aRgb ); |
|
1843 |
aGc.SetPenColor( rgb ); |
|
1844 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1845 |
aGc.SetBrushColor( rgb ); |
|
1846 |
aGc.DrawPolygon( upperPart ); |
|
1847 |
rgb = DarkerColor( aRgb ); |
|
1848 |
aGc.SetPenColor( rgb ); |
|
1849 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1850 |
aGc.SetBrushColor( rgb ); |
|
1851 |
aGc.DrawPolygon( lowerPart ); |
|
1852 |
CleanupStack::PopAndDestroy( lowerPart ); |
|
1853 |
CleanupStack::PopAndDestroy( upperPart ); |
|
1854 |
} |
|
1855 |
||
1856 |
// ----------------------------------------------------------------------------- |
|
1857 |
// DrawGrooveBottomBorderL |
|
1858 |
// Draw bottom border with groove style |
|
1859 |
// ----------------------------------------------------------------------------- |
|
1860 |
// |
|
1861 |
static void DrawGrooveBottomBorderL( |
|
1862 |
CArrayFix< TPoint >* aArray, |
|
1863 |
CWindowGc& aGc, |
|
1864 |
TRgb& aRgb ) |
|
1865 |
{ |
|
1866 |
CArrayFix< TPoint >* upperPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1867 |
CleanupStack::PushL( upperPart ); |
|
1868 |
CArrayFix< TPoint >* lowerPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
1869 |
CleanupStack::PushL( lowerPart ); |
|
1870 |
SplitBottomBorderPolygonL( aArray, upperPart, lowerPart ); |
|
1871 |
TRgb rgb = DarkerColor( aRgb ); |
|
1872 |
aGc.SetPenColor( rgb ); |
|
1873 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1874 |
aGc.SetBrushColor( rgb ); |
|
1875 |
aGc.DrawPolygon( upperPart ); |
|
1876 |
rgb = LighterColor( aRgb ); |
|
1877 |
aGc.SetPenColor( rgb ); |
|
1878 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1879 |
aGc.SetBrushColor( rgb ); |
|
1880 |
aGc.DrawPolygon( lowerPart ); |
|
1881 |
CleanupStack::PopAndDestroy( lowerPart ); |
|
1882 |
CleanupStack::PopAndDestroy( upperPart ); |
|
1883 |
} |
|
1884 |
||
1885 |
// ----------------------------------------------------------------------------- |
|
1886 |
// DrawInsetBottomBorder |
|
1887 |
// Draw bottom border with inset style |
|
1888 |
// ----------------------------------------------------------------------------- |
|
1889 |
// |
|
1890 |
static void DrawInsetBottomBorder( |
|
1891 |
CArrayFix< TPoint >* aArray, |
|
1892 |
CWindowGc& aGc, |
|
1893 |
TRgb& aRgb ) |
|
1894 |
{ |
|
1895 |
TRgb rgb = LighterColor( aRgb ); |
|
1896 |
aGc.SetPenColor( rgb ); |
|
1897 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1898 |
aGc.SetBrushColor( rgb ); |
|
1899 |
aGc.DrawPolygon( aArray ); |
|
1900 |
} |
|
1901 |
||
1902 |
// ----------------------------------------------------------------------------- |
|
1903 |
// DrawOutsetBottomBorder |
|
1904 |
// Draw bottom border with outset style |
|
1905 |
// ----------------------------------------------------------------------------- |
|
1906 |
// |
|
1907 |
static void DrawOutsetBottomBorder( |
|
1908 |
CArrayFix< TPoint >* aArray, |
|
1909 |
CWindowGc& aGc, |
|
1910 |
TRgb& aRgb ) |
|
1911 |
{ |
|
1912 |
TRgb rgb = DarkerColor( aRgb ); |
|
1913 |
aGc.SetPenColor( rgb ); |
|
1914 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1915 |
aGc.SetBrushColor( rgb ); |
|
1916 |
aGc.DrawPolygon( aArray ); |
|
1917 |
} |
|
1918 |
||
1919 |
// ----------------------------------------------------------------------------- |
|
1920 |
// DrawDottedBorder |
|
1921 |
// Draw dotted border |
|
1922 |
// ----------------------------------------------------------------------------- |
|
1923 |
// |
|
1924 |
static void DrawDottedBorder( |
|
1925 |
TRect aBorderRect, |
|
1926 |
CWindowGc& aGc, |
|
1927 |
TRgb& aRgb, |
|
1928 |
TBool aHorizontal ) |
|
1929 |
{ |
|
1930 |
TInt height( aBorderRect.Height() ); |
|
1931 |
TInt width( aBorderRect.Width() ); |
|
1932 |
||
1933 |
TInt squareSide( Min( height, width ) ); |
|
1934 |
||
1935 |
if ( !squareSide ) |
|
1936 |
{ |
|
1937 |
return; |
|
1938 |
} |
|
1939 |
||
1940 |
// Square size 1, 2 and 3 can be drawn with pen patterns |
|
1941 |
if ( squareSide < 4 ) |
|
1942 |
{ |
|
1943 |
aGc.SetBrushStyle( CGraphicsContext::ENullBrush ); |
|
1944 |
||
1945 |
aGc.SetPenColor( aRgb ); |
|
1946 |
||
1947 |
for ( TInt i = 0; i < squareSide; i++ ) |
|
1948 |
{ |
|
1949 |
TPoint start; |
|
1950 |
TPoint end; |
|
1951 |
||
1952 |
if ( aHorizontal ) |
|
1953 |
{ |
|
1954 |
start = TPoint( aBorderRect.iTl.iX, aBorderRect.iTl.iY + i ); |
|
1955 |
end = TPoint( |
|
1956 |
aBorderRect.iTl.iX + aBorderRect.Width(), |
|
1957 |
aBorderRect.iTl.iY + i ); |
|
1958 |
} |
|
1959 |
else |
|
1960 |
{ |
|
1961 |
start = TPoint( aBorderRect.iTl.iX + i, aBorderRect.iTl.iY ); |
|
1962 |
end = TPoint( |
|
1963 |
aBorderRect.iTl.iX + i, |
|
1964 |
aBorderRect.iTl.iY + aBorderRect.Height() ); |
|
1965 |
} |
|
1966 |
||
1967 |
if ( squareSide == 3 ) |
|
1968 |
{ |
|
1969 |
// dashed pen pattern 111000... |
|
1970 |
aGc.SetPenStyle( CGraphicsContext::EDashedPen ); |
|
1971 |
aGc.DrawLine( start, end ); |
|
1972 |
} |
|
1973 |
else |
|
1974 |
{ |
|
1975 |
// dotted pen pattern 1000... |
|
1976 |
aGc.SetPenStyle( CGraphicsContext::EDottedPen ); |
|
1977 |
aGc.DrawLine( start, end ); |
|
1978 |
||
1979 |
if ( aHorizontal ) |
|
1980 |
{ |
|
1981 |
start.iX += ( squareSide == 1 ) ? 2 : 1; |
|
1982 |
} |
|
1983 |
else |
|
1984 |
{ |
|
1985 |
start.iY += ( squareSide == 1 ) ? 2 : 1; |
|
1986 |
} |
|
1987 |
||
1988 |
aGc.SetPenStyle( CGraphicsContext::EDottedPen ); |
|
1989 |
aGc.DrawLine( start, end ); |
|
1990 |
} |
|
1991 |
} |
|
1992 |
} |
|
1993 |
else |
|
1994 |
{ |
|
1995 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
1996 |
aGc.SetPenStyle( CGraphicsContext::ENullPen ); |
|
1997 |
||
1998 |
aGc.SetBrushColor( aRgb ); |
|
1999 |
||
2000 |
TInt divideCount( 0 ); |
|
2001 |
||
2002 |
if ( aHorizontal ) |
|
2003 |
{ |
|
2004 |
divideCount = width / squareSide; |
|
2005 |
} |
|
2006 |
else |
|
2007 |
{ |
|
2008 |
divideCount = height / squareSide; |
|
2009 |
} |
|
2010 |
||
2011 |
TRect drawingRect( aBorderRect.iTl, TSize( squareSide, squareSide ) ); |
|
2012 |
||
2013 |
// every other is drawn |
|
2014 |
TInt count( divideCount / 2 ); |
|
2015 |
||
2016 |
for ( TInt i = 0; i <= count; i++ ) |
|
2017 |
{ |
|
2018 |
aGc.DrawRect( drawingRect ); |
|
2019 |
||
2020 |
if ( aHorizontal ) |
|
2021 |
{ |
|
2022 |
drawingRect.Move( squareSide * 2, 0 ); |
|
2023 |
} |
|
2024 |
else |
|
2025 |
{ |
|
2026 |
drawingRect.Move( 0, squareSide * 2 ); |
|
2027 |
} |
|
2028 |
} |
|
2029 |
} |
|
2030 |
} |
|
2031 |
||
2032 |
// ----------------------------------------------------------------------------- |
|
2033 |
// DrawBottomBorder |
|
2034 |
// Draw bottom border |
|
2035 |
// ----------------------------------------------------------------------------- |
|
2036 |
// |
|
2037 |
static void DrawBottomBorderL( |
|
2038 |
const TRect& /*aRect*/, |
|
2039 |
CXnNode& aNode, |
|
2040 |
CWindowGc& aGc ) |
|
2041 |
{ |
|
2042 |
TRect borderRect = aNode.BorderRect(); |
|
2043 |
TRect paddingRect = aNode.PaddingRect(); |
|
2044 |
TRgb rgb; |
|
2045 |
if ( !GetBorderColorL( XnPropertyNames::appearance::common::KBorderBottomColor, aNode, aGc, rgb ) ) |
|
2046 |
{ |
|
2047 |
return; |
|
2048 |
} |
|
2049 |
TPoint tl = paddingRect.iBr; |
|
2050 |
tl.iX -= paddingRect.Width() + 1; |
|
2051 |
TPoint bl = borderRect.iBr; |
|
2052 |
bl.iX -= borderRect.Width(); |
|
2053 |
bl.iY-= 1; |
|
2054 |
TPoint tr = paddingRect.iBr; |
|
2055 |
TPoint br = borderRect.iBr; |
|
2056 |
br.iY -= 1; |
|
2057 |
br.iX -= 1; |
|
2058 |
CArrayFix< TPoint >* array = NULL; |
|
2059 |
array = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2060 |
TRAPD( error, |
|
2061 |
array->AppendL( tl ); |
|
2062 |
array->AppendL( tr ); |
|
2063 |
array->AppendL( br ); |
|
2064 |
array->AppendL( bl ); ); |
|
2065 |
if ( error != KErrNone ) |
|
2066 |
{ |
|
2067 |
delete array; |
|
2068 |
return; |
|
2069 |
} |
|
2070 |
CXnProperty* borderBottomStyle = aNode.BorderBottomStyleL(); |
|
2071 |
CXnProperty* borderStyle = aNode.BorderStyleL(); |
|
2072 |
const TDesC8& borderStyleString = ( borderBottomStyle ) ? |
|
2073 |
borderBottomStyle->StringValue() : |
|
2074 |
( borderStyle ) ? borderStyle->StringValue() : KNullDesC8; |
|
2075 |
if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KSolid ) |
|
2076 |
{ |
|
2077 |
DrawSolidBottomBorder( array, aGc ); |
|
2078 |
} |
|
2079 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KInset ) |
|
2080 |
{ |
|
2081 |
DrawInsetBottomBorder( array, aGc, rgb ); |
|
2082 |
} |
|
2083 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KOutset ) |
|
2084 |
{ |
|
2085 |
DrawOutsetBottomBorder( array, aGc, rgb ); |
|
2086 |
} |
|
2087 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KRidge ) |
|
2088 |
{ |
|
2089 |
TRAP_IGNORE( DrawRidgeBottomBorderL( array, aGc, rgb ) ); |
|
2090 |
} |
|
2091 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KGroove ) |
|
2092 |
{ |
|
2093 |
TRAP_IGNORE( DrawGrooveBottomBorderL( array, aGc, rgb ) ); |
|
2094 |
} |
|
2095 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KDotted ) |
|
2096 |
{ |
|
2097 |
TPoint origo( borderRect.iTl.iX, paddingRect.iBr.iY ); |
|
2098 |
TRect rect( origo, borderRect.iBr ); |
|
2099 |
DrawDottedBorder( rect, aGc, rgb, ETrue ); |
|
2100 |
} |
|
2101 |
delete array; |
|
2102 |
} |
|
2103 |
||
2104 |
// ----------------------------------------------------------------------------- |
|
2105 |
// DrawSolidLeftBorder |
|
2106 |
// ----------------------------------------------------------------------------- |
|
2107 |
// |
|
2108 |
static void DrawSolidLeftBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ) |
|
2109 |
{ |
|
2110 |
aGc.DrawPolygon( aArray ); |
|
2111 |
} |
|
2112 |
||
2113 |
// ----------------------------------------------------------------------------- |
|
2114 |
// SplitLeftBorderPolygonL |
|
2115 |
// ----------------------------------------------------------------------------- |
|
2116 |
// |
|
2117 |
static void SplitLeftBorderPolygonL( |
|
2118 |
CArrayFix< TPoint >* aArray, |
|
2119 |
CArrayFix< TPoint >*& aLeftPart, |
|
2120 |
CArrayFix< TPoint >*& aRightPart ) |
|
2121 |
{ |
|
2122 |
TPoint upHalf = |
|
2123 |
TPoint( |
|
2124 |
( *aArray )[0].iX + ( ( *aArray )[1].iX - ( *aArray )[0].iX ) / 2, |
|
2125 |
( *aArray )[0].iY + ( ( *aArray )[1].iY - ( *aArray )[0].iY ) / 2); |
|
2126 |
TPoint downHalf = |
|
2127 |
TPoint( |
|
2128 |
( *aArray )[3].iX + ( ( *aArray )[2].iX - ( *aArray )[3].iX ) / 2, |
|
2129 |
( *aArray )[2].iY + ( ( *aArray )[3].iY - ( *aArray )[2].iY ) / 2); |
|
2130 |
aLeftPart->AppendL( ( *aArray )[0] ); |
|
2131 |
aLeftPart->AppendL( upHalf ); |
|
2132 |
aLeftPart->AppendL( downHalf ); |
|
2133 |
aLeftPart->AppendL( ( *aArray )[3] ); |
|
2134 |
||
2135 |
aRightPart->AppendL( upHalf ); |
|
2136 |
aRightPart->AppendL( ( *aArray )[1] ); |
|
2137 |
aRightPart->AppendL( ( *aArray )[2]) ; |
|
2138 |
aRightPart->AppendL( downHalf ); |
|
2139 |
} |
|
2140 |
||
2141 |
// ----------------------------------------------------------------------------- |
|
2142 |
// DrawRidgeLeftBorderL |
|
2143 |
// ----------------------------------------------------------------------------- |
|
2144 |
// |
|
2145 |
static void DrawRidgeLeftBorderL( |
|
2146 |
CArrayFix< TPoint >* aArray, |
|
2147 |
CWindowGc& aGc, |
|
2148 |
TRgb& aRgb ) |
|
2149 |
{ |
|
2150 |
CArrayFix< TPoint >* leftPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2151 |
CleanupStack::PushL( leftPart ); |
|
2152 |
CArrayFix< TPoint >* rightPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2153 |
CleanupStack::PushL( rightPart ); |
|
2154 |
SplitLeftBorderPolygonL( aArray, leftPart, rightPart ); |
|
2155 |
TRgb rgb = LighterColor( aRgb ); |
|
2156 |
aGc.SetPenColor( rgb ); |
|
2157 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2158 |
aGc.SetBrushColor( rgb ); |
|
2159 |
aGc.DrawPolygon( leftPart ); |
|
2160 |
rgb = DarkerColor( aRgb ); |
|
2161 |
aGc.SetPenColor( rgb ); |
|
2162 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2163 |
aGc.SetBrushColor( rgb ); |
|
2164 |
aGc.DrawPolygon( rightPart ); |
|
2165 |
CleanupStack::PopAndDestroy( rightPart ); |
|
2166 |
CleanupStack::PopAndDestroy( leftPart ); |
|
2167 |
} |
|
2168 |
||
2169 |
// ----------------------------------------------------------------------------- |
|
2170 |
// DrawGrooveLeftBorderL |
|
2171 |
// ----------------------------------------------------------------------------- |
|
2172 |
// |
|
2173 |
static void DrawGrooveLeftBorderL( |
|
2174 |
CArrayFix< TPoint >* aArray, |
|
2175 |
CWindowGc& aGc, |
|
2176 |
TRgb& aRgb ) |
|
2177 |
{ |
|
2178 |
CArrayFix< TPoint >* leftPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2179 |
CleanupStack::PushL( leftPart ); |
|
2180 |
CArrayFix< TPoint >* rightPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2181 |
CleanupStack::PushL( rightPart ); |
|
2182 |
SplitLeftBorderPolygonL( aArray, leftPart, rightPart ); |
|
2183 |
TRgb rgb = DarkerColor( aRgb ); |
|
2184 |
aGc.SetPenColor( rgb ); |
|
2185 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2186 |
aGc.SetBrushColor( rgb ); |
|
2187 |
aGc.DrawPolygon( leftPart ); |
|
2188 |
rgb = LighterColor( aRgb ); |
|
2189 |
aGc.SetPenColor( rgb ); |
|
2190 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2191 |
aGc.SetBrushColor( rgb ); |
|
2192 |
aGc.DrawPolygon( rightPart ); |
|
2193 |
CleanupStack::PopAndDestroy( rightPart ); |
|
2194 |
CleanupStack::PopAndDestroy( leftPart ); |
|
2195 |
} |
|
2196 |
||
2197 |
// ----------------------------------------------------------------------------- |
|
2198 |
// DrawInsetLeftBorder |
|
2199 |
// ----------------------------------------------------------------------------- |
|
2200 |
// |
|
2201 |
static void DrawInsetLeftBorder( |
|
2202 |
CArrayFix< TPoint >* aArray, |
|
2203 |
CWindowGc& aGc, |
|
2204 |
TRgb& aRgb ) |
|
2205 |
{ |
|
2206 |
TRgb rgb = DarkerColor( aRgb ); |
|
2207 |
aGc.SetPenColor( rgb ); |
|
2208 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2209 |
aGc.SetBrushColor( rgb ); |
|
2210 |
aGc.DrawPolygon( aArray ); |
|
2211 |
} |
|
2212 |
||
2213 |
// ----------------------------------------------------------------------------- |
|
2214 |
// DrawOutsetLeftBorder |
|
2215 |
// ----------------------------------------------------------------------------- |
|
2216 |
// |
|
2217 |
static void DrawOutsetLeftBorder( |
|
2218 |
CArrayFix< TPoint >* aArray, |
|
2219 |
CWindowGc& aGc, |
|
2220 |
TRgb& aRgb ) |
|
2221 |
{ |
|
2222 |
TRgb rgb = LighterColor( aRgb ); |
|
2223 |
aGc.SetPenColor( rgb ); |
|
2224 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2225 |
aGc.SetBrushColor( rgb ); |
|
2226 |
aGc.DrawPolygon( aArray ); |
|
2227 |
} |
|
2228 |
||
2229 |
// ----------------------------------------------------------------------------- |
|
2230 |
// DrawLeftBorderL |
|
2231 |
// ----------------------------------------------------------------------------- |
|
2232 |
// |
|
2233 |
static void DrawLeftBorderL( |
|
2234 |
const TRect& /*aRect*/, |
|
2235 |
CXnNode& aNode, |
|
2236 |
CWindowGc& aGc ) |
|
2237 |
{ |
|
2238 |
TRect borderRect = aNode.BorderRect(); |
|
2239 |
TRect paddingRect = aNode.PaddingRect(); |
|
2240 |
TRgb rgb; |
|
2241 |
if ( !GetBorderColorL( XnPropertyNames::appearance::common::KBorderLeftColor, aNode, aGc, rgb ) ) |
|
2242 |
{ |
|
2243 |
return; |
|
2244 |
} |
|
2245 |
TPoint tl = borderRect.iTl; |
|
2246 |
TPoint bl = borderRect.iBr; |
|
2247 |
bl.iX -= borderRect.Width(); |
|
2248 |
TPoint tr = paddingRect.iTl; |
|
2249 |
tr.iX -= 1; |
|
2250 |
tr.iY -= 1; |
|
2251 |
TPoint br = paddingRect.iBr; |
|
2252 |
br.iX -= paddingRect.Width() + 1; |
|
2253 |
CArrayFix< TPoint >* array = NULL; |
|
2254 |
array = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2255 |
TRAPD( error, |
|
2256 |
array->AppendL( tl ); |
|
2257 |
array->AppendL( tr ); |
|
2258 |
array->AppendL( br ); |
|
2259 |
array->AppendL( bl ); ); |
|
2260 |
if ( error != KErrNone ) |
|
2261 |
{ |
|
2262 |
delete array; |
|
2263 |
return; |
|
2264 |
} |
|
2265 |
CXnProperty* borderLeftStyle = aNode.BorderLeftStyleL(); |
|
2266 |
CXnProperty* borderStyle = aNode.BorderStyleL(); |
|
2267 |
const TDesC8& borderStyleString = ( borderLeftStyle ) ? |
|
2268 |
borderLeftStyle->StringValue() : |
|
2269 |
( borderStyle ) ? borderStyle->StringValue() : KNullDesC8; |
|
2270 |
if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KSolid ) |
|
2271 |
{ |
|
2272 |
DrawSolidLeftBorder( array, aGc ); |
|
2273 |
} |
|
2274 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KInset ) |
|
2275 |
{ |
|
2276 |
DrawInsetLeftBorder( array, aGc, rgb ); |
|
2277 |
} |
|
2278 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KOutset ) |
|
2279 |
{ |
|
2280 |
DrawOutsetLeftBorder( array, aGc, rgb ); |
|
2281 |
} |
|
2282 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KRidge ) |
|
2283 |
{ |
|
2284 |
TRAP_IGNORE( DrawRidgeLeftBorderL( array, aGc, rgb ) ); |
|
2285 |
} |
|
2286 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KGroove ) |
|
2287 |
{ |
|
2288 |
TRAP_IGNORE( DrawGrooveLeftBorderL( array, aGc, rgb ) ); |
|
2289 |
} |
|
2290 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KDotted ) |
|
2291 |
{ |
|
2292 |
TPoint origo( borderRect.iTl.iX, paddingRect.iTl.iY ); |
|
2293 |
TPoint end( paddingRect.iTl.iX, paddingRect.iBr.iY ); |
|
2294 |
TRect rect( origo, end ); |
|
2295 |
DrawDottedBorder( rect, aGc, rgb, EFalse ); |
|
2296 |
} |
|
2297 |
delete array; |
|
2298 |
} |
|
2299 |
||
2300 |
// ----------------------------------------------------------------------------- |
|
2301 |
// DrawSolidRightBorder |
|
2302 |
// ----------------------------------------------------------------------------- |
|
2303 |
// |
|
2304 |
static void DrawSolidRightBorder( CArrayFix< TPoint >* aArray, CWindowGc& aGc ) |
|
2305 |
{ |
|
2306 |
aGc.DrawPolygon( aArray ); |
|
2307 |
} |
|
2308 |
||
2309 |
// ----------------------------------------------------------------------------- |
|
2310 |
// SplitRightBorderPolygonL |
|
2311 |
// ----------------------------------------------------------------------------- |
|
2312 |
// |
|
2313 |
static void SplitRightBorderPolygonL( |
|
2314 |
CArrayFix< TPoint >* aArray, |
|
2315 |
CArrayFix< TPoint >*& aLeftPart, |
|
2316 |
CArrayFix< TPoint >*& aRightPart ) |
|
2317 |
{ |
|
2318 |
TPoint upHalf = |
|
2319 |
TPoint( |
|
2320 |
( *aArray )[0].iX + ( ( *aArray )[1].iX - ( *aArray )[0].iX ) / 2, |
|
2321 |
( *aArray )[1].iY + ( ( *aArray )[0].iY - ( *aArray )[1].iY ) / 2); |
|
2322 |
TPoint downHalf = |
|
2323 |
TPoint( |
|
2324 |
( *aArray )[3].iX + ( ( *aArray )[2].iX - ( *aArray )[3].iX ) / 2, |
|
2325 |
( *aArray )[3].iY + ( ( *aArray )[2].iY - ( *aArray )[3].iY ) / 2); |
|
2326 |
aLeftPart->AppendL( ( *aArray )[0] ); |
|
2327 |
aLeftPart->AppendL( upHalf ); |
|
2328 |
aLeftPart->AppendL( downHalf ); |
|
2329 |
aLeftPart->AppendL( ( *aArray )[3] ); |
|
2330 |
||
2331 |
aRightPart->AppendL( upHalf ); |
|
2332 |
aRightPart->AppendL( ( *aArray )[1] ); |
|
2333 |
aRightPart->AppendL( ( *aArray )[2]) ; |
|
2334 |
aRightPart->AppendL( downHalf ); |
|
2335 |
} |
|
2336 |
||
2337 |
// ----------------------------------------------------------------------------- |
|
2338 |
// DrawRidgeRightBorderL |
|
2339 |
// ----------------------------------------------------------------------------- |
|
2340 |
// |
|
2341 |
static void DrawRidgeRightBorderL( |
|
2342 |
CArrayFix< TPoint >* aArray, |
|
2343 |
CWindowGc& aGc, |
|
2344 |
TRgb& aRgb ) |
|
2345 |
{ |
|
2346 |
CArrayFix< TPoint >* leftPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2347 |
CleanupStack::PushL( leftPart ); |
|
2348 |
CArrayFix< TPoint >* rightPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2349 |
CleanupStack::PushL( rightPart ); |
|
2350 |
SplitRightBorderPolygonL( aArray, leftPart, rightPart ); |
|
2351 |
TRgb rgb = LighterColor( aRgb ); |
|
2352 |
aGc.SetPenColor( rgb ); |
|
2353 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2354 |
aGc.SetBrushColor( rgb ); |
|
2355 |
aGc.DrawPolygon( leftPart ); |
|
2356 |
rgb = DarkerColor( aRgb ); |
|
2357 |
aGc.SetPenColor( rgb ); |
|
2358 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2359 |
aGc.SetBrushColor( rgb ); |
|
2360 |
aGc.DrawPolygon( rightPart ); |
|
2361 |
CleanupStack::PopAndDestroy( rightPart ); |
|
2362 |
CleanupStack::PopAndDestroy( leftPart ); |
|
2363 |
} |
|
2364 |
||
2365 |
// ----------------------------------------------------------------------------- |
|
2366 |
// DrawGrooveRightBorderL |
|
2367 |
// ----------------------------------------------------------------------------- |
|
2368 |
// |
|
2369 |
static void DrawGrooveRightBorderL( |
|
2370 |
CArrayFix< TPoint >* aArray, |
|
2371 |
CWindowGc& aGc, |
|
2372 |
TRgb& aRgb ) |
|
2373 |
{ |
|
2374 |
CArrayFix< TPoint >* leftPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2375 |
CleanupStack::PushL( leftPart ); |
|
2376 |
CArrayFix< TPoint >* rightPart = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2377 |
CleanupStack::PushL( rightPart ); |
|
2378 |
SplitRightBorderPolygonL( aArray, leftPart, rightPart ); |
|
2379 |
TRgb rgb = DarkerColor( aRgb ); |
|
2380 |
aGc.SetPenColor( rgb ); |
|
2381 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2382 |
aGc.SetBrushColor( rgb ); |
|
2383 |
aGc.DrawPolygon( leftPart ); |
|
2384 |
rgb = LighterColor( aRgb ); |
|
2385 |
aGc.SetPenColor( rgb ); |
|
2386 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2387 |
aGc.SetBrushColor( rgb ); |
|
2388 |
aGc.DrawPolygon( rightPart ); |
|
2389 |
CleanupStack::PopAndDestroy( rightPart ); |
|
2390 |
CleanupStack::PopAndDestroy( leftPart ); |
|
2391 |
} |
|
2392 |
||
2393 |
// ----------------------------------------------------------------------------- |
|
2394 |
// DrawInsetRightBorder |
|
2395 |
// ----------------------------------------------------------------------------- |
|
2396 |
// |
|
2397 |
static void DrawInsetRightBorder( |
|
2398 |
CArrayFix< TPoint >* aArray, |
|
2399 |
CWindowGc& aGc, |
|
2400 |
TRgb& aRgb ) |
|
2401 |
{ |
|
2402 |
TRgb rgb = LighterColor( aRgb ); |
|
2403 |
aGc.SetPenColor( rgb ); |
|
2404 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2405 |
aGc.SetBrushColor( rgb ); |
|
2406 |
aGc.DrawPolygon( aArray ); |
|
2407 |
} |
|
2408 |
||
2409 |
// ----------------------------------------------------------------------------- |
|
2410 |
// DrawOutsetRightBorder |
|
2411 |
// ----------------------------------------------------------------------------- |
|
2412 |
// |
|
2413 |
static void DrawOutsetRightBorder( |
|
2414 |
CArrayFix< TPoint >* aArray, |
|
2415 |
CWindowGc& aGc, |
|
2416 |
TRgb& aRgb ) |
|
2417 |
{ |
|
2418 |
TRgb rgb = DarkerColor( aRgb ); |
|
2419 |
aGc.SetPenColor( rgb ); |
|
2420 |
aGc.SetBrushStyle( CGraphicsContext::ESolidBrush ); |
|
2421 |
aGc.SetBrushColor( rgb ); |
|
2422 |
aGc.DrawPolygon( aArray ); |
|
2423 |
} |
|
2424 |
||
2425 |
// ----------------------------------------------------------------------------- |
|
2426 |
// DrawRightBorderL |
|
2427 |
// ----------------------------------------------------------------------------- |
|
2428 |
// |
|
2429 |
static void DrawRightBorderL( |
|
2430 |
const TRect& /*aRect*/, |
|
2431 |
CXnNode& aNode, |
|
2432 |
CWindowGc& aGc ) |
|
2433 |
{ |
|
2434 |
TRect borderRect = aNode.BorderRect(); |
|
2435 |
TRect paddingRect = aNode.PaddingRect(); |
|
2436 |
TRgb rgb; |
|
2437 |
if ( !GetBorderColorL( XnPropertyNames::appearance::common::KBorderRightColor, aNode, aGc, rgb ) ) |
|
2438 |
{ |
|
2439 |
return; |
|
2440 |
} |
|
2441 |
TPoint tl = paddingRect.iTl; |
|
2442 |
tl.iX += paddingRect.Width(); |
|
2443 |
TPoint bl = paddingRect.iBr; |
|
2444 |
TPoint tr = borderRect.iTl; |
|
2445 |
tr.iX += borderRect.Width()-1; |
|
2446 |
TPoint br = borderRect.iBr; |
|
2447 |
br.iX -= 1; |
|
2448 |
br.iY -= 1; |
|
2449 |
CArrayFix< TPoint >* array = NULL; |
|
2450 |
array = new ( ELeave ) CArrayFixFlat< TPoint >( 3 ); |
|
2451 |
TRAPD( error, |
|
2452 |
array->AppendL( tl ); |
|
2453 |
array->AppendL( tr ); |
|
2454 |
array->AppendL( br ); |
|
2455 |
array->AppendL( bl ); ); |
|
2456 |
if ( error != KErrNone ) |
|
2457 |
{ |
|
2458 |
delete array; |
|
2459 |
return; |
|
2460 |
} |
|
2461 |
CXnProperty* borderRightStyle = aNode.BorderRightStyleL(); |
|
2462 |
CXnProperty* borderStyle = aNode.BorderStyleL(); |
|
2463 |
const TDesC8& borderStyleString = ( borderRightStyle ) ? |
|
2464 |
borderRightStyle->StringValue() : |
|
2465 |
( borderStyle ) ? borderStyle->StringValue() : KNullDesC8; |
|
2466 |
if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KSolid ) |
|
2467 |
{ |
|
2468 |
DrawSolidRightBorder( array, aGc ); |
|
2469 |
} |
|
2470 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KInset ) |
|
2471 |
{ |
|
2472 |
DrawInsetRightBorder( array, aGc, rgb ); |
|
2473 |
} |
|
2474 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KOutset ) |
|
2475 |
{ |
|
2476 |
DrawOutsetRightBorder( array, aGc, rgb ); |
|
2477 |
} |
|
2478 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KRidge ) |
|
2479 |
{ |
|
2480 |
TRAP_IGNORE( DrawRidgeRightBorderL( array, aGc, rgb ) ); |
|
2481 |
} |
|
2482 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KGroove ) |
|
2483 |
{ |
|
2484 |
TRAP_IGNORE( DrawGrooveRightBorderL( array, aGc, rgb ) ); |
|
2485 |
} |
|
2486 |
else if ( borderStyleString == XnPropertyNames::appearance::common::borderstyle::KDotted ) |
|
2487 |
{ |
|
2488 |
TPoint origo( paddingRect.iBr.iX, paddingRect.iTl.iY ); |
|
2489 |
TPoint end( borderRect.iBr.iX, paddingRect.iBr.iY ); |
|
2490 |
TRect rect( origo, end ); |
|
2491 |
DrawDottedBorder( rect, aGc, rgb, EFalse ); |
|
2492 |
} |
|
2493 |
delete array; |
|
2494 |
} |
|
2495 |
||
2496 |
// ----------------------------------------------------------------------------- |
|
2497 |
// DrawBorderImagesL |
|
2498 |
// ----------------------------------------------------------------------------- |
|
2499 |
// |
|
2500 |
static void DrawBorderImagesL( |
|
2501 |
const TRect& /*aRect*/, |
|
2502 |
CXnNode& aNode, |
|
2503 |
CWindowGc& aGc, |
|
2504 |
CFbsBitmap* aBitmap, |
|
2505 |
TInt aBorderBitmapDividerTop, |
|
2506 |
TInt aBorderBitmapDividerRight, |
|
2507 |
TInt aBorderBitmapDividerBottom, |
|
2508 |
TInt aBorderBitmapDividerLeft ) |
|
2509 |
{ |
|
2510 |
CXnProperty* pathProperty = aNode.BorderImageL(); |
|
2511 |
if ( !pathProperty ) |
|
2512 |
{ |
|
2513 |
return; |
|
2514 |
} |
|
2515 |
TRect borderRect = aNode.BorderRect(); |
|
2516 |
TRect paddingRect = aNode.PaddingRect(); |
|
2517 |
TRect topLeft = TRect( borderRect.iTl, paddingRect.iTl ); |
|
2518 |
TRect topLeftSource = TRect( |
|
2519 |
TPoint( 0, 0 ), |
|
2520 |
TPoint( aBorderBitmapDividerLeft, aBorderBitmapDividerTop ) ); |
|
2521 |
aGc.DrawBitmap( topLeft, aBitmap, topLeftSource ); |
|
2522 |
TRect bottomLeft = TRect( |
|
2523 |
TPoint( borderRect.iTl.iX, paddingRect.iTl.iY + paddingRect.Height() ), |
|
2524 |
TPoint( paddingRect.iTl.iX, borderRect.iTl.iY + borderRect.Height() ) ); |
|
2525 |
TSize imageSize = aBitmap->SizeInPixels(); |
|
2526 |
TRect bottomLeftSource = TRect( |
|
2527 |
TPoint( 0, imageSize.iHeight - aBorderBitmapDividerBottom ), |
|
2528 |
TPoint( aBorderBitmapDividerLeft, imageSize.iHeight ) ); |
|
2529 |
aGc.DrawBitmap( bottomLeft, aBitmap, bottomLeftSource ); |
|
2530 |
TRect topRight = TRect( |
|
2531 |
TPoint( paddingRect.iBr.iX, borderRect.iTl.iY ), |
|
2532 |
TPoint( borderRect.iBr.iX, paddingRect.iTl.iY ) ); |
|
2533 |
TRect topRightSource = TRect( |
|
2534 |
TPoint( imageSize.iWidth - aBorderBitmapDividerRight, 0 ), |
|
2535 |
TPoint( imageSize.iWidth, aBorderBitmapDividerTop ) ); |
|
2536 |
aGc.DrawBitmap( topRight, aBitmap, topRightSource ); |
|
2537 |
TRect bottomRight = TRect( paddingRect.iBr, borderRect.iBr ); |
|
2538 |
TRect bottomRightSource = TRect( |
|
2539 |
TPoint( |
|
2540 |
imageSize.iWidth - aBorderBitmapDividerRight, |
|
2541 |
imageSize.iHeight - aBorderBitmapDividerBottom ), |
|
2542 |
TPoint( |
|
2543 |
imageSize.iWidth, |
|
2544 |
imageSize.iHeight ) ); |
|
2545 |
aGc.DrawBitmap( bottomRight, aBitmap, bottomRightSource ); |
|
2546 |
TBool xStretch = ETrue; |
|
2547 |
TBool xRepeat = EFalse; |
|
2548 |
TBool xRound = EFalse; |
|
2549 |
TBool yStretch = ETrue; |
|
2550 |
TBool yRepeat = EFalse; |
|
2551 |
TBool yRound = EFalse; |
|
2552 |
if ( pathProperty ) |
|
2553 |
{ |
|
2554 |
CXnDomList& propertyValueList = pathProperty->Property()->PropertyValueList(); |
|
2555 |
TBool xHandled = EFalse; |
|
2556 |
TInt count = propertyValueList.Length(); |
|
2557 |
for ( TInt i = 0; i < count; ++i ) |
|
2558 |
{ |
|
2559 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
2560 |
propertyValueList.Item( i ) ); |
|
2561 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString || |
|
2562 |
value->PrimitiveValueType() == CXnDomPropertyValue::EIdent ) |
|
2563 |
{ |
|
2564 |
const TDesC8& stringValue = value->StringValueL(); |
|
2565 |
if ( !xHandled ) |
|
2566 |
{ |
|
2567 |
xHandled = ETrue; |
|
2568 |
if ( stringValue == XnPropertyNames::appearance::common::borderimage::KStretch ) |
|
2569 |
{ |
|
2570 |
xStretch = ETrue; |
|
2571 |
yStretch = ETrue; |
|
2572 |
} |
|
2573 |
else if ( stringValue == XnPropertyNames::appearance::common::borderimage::KRepeat ) |
|
2574 |
{ |
|
2575 |
xStretch = EFalse; |
|
2576 |
yStretch = EFalse; |
|
2577 |
xRepeat = ETrue; |
|
2578 |
yRepeat = ETrue; |
|
2579 |
} |
|
2580 |
else if ( stringValue == XnPropertyNames::appearance::common::borderimage::KRound ) |
|
2581 |
{ |
|
2582 |
xStretch = EFalse; |
|
2583 |
yStretch = EFalse; |
|
2584 |
xRound = ETrue; |
|
2585 |
yRound = ETrue; |
|
2586 |
} |
|
2587 |
} |
|
2588 |
else |
|
2589 |
{ |
|
2590 |
if ( stringValue == XnPropertyNames::appearance::common::borderimage::KStretch ) |
|
2591 |
{ |
|
2592 |
yStretch = ETrue; |
|
2593 |
yRepeat = EFalse; |
|
2594 |
yRound = EFalse; |
|
2595 |
} |
|
2596 |
else if ( stringValue == XnPropertyNames::appearance::common::borderimage::KRepeat ) |
|
2597 |
{ |
|
2598 |
yStretch = EFalse; |
|
2599 |
yRepeat = ETrue; |
|
2600 |
yRound = EFalse; |
|
2601 |
} |
|
2602 |
else if ( stringValue == XnPropertyNames::appearance::common::borderimage::KRound ) |
|
2603 |
{ |
|
2604 |
yStretch = EFalse; |
|
2605 |
yRepeat = EFalse; |
|
2606 |
yRound = ETrue; |
|
2607 |
} |
|
2608 |
} |
|
2609 |
} |
|
2610 |
} |
|
2611 |
} |
|
2612 |
TRect top = TRect( |
|
2613 |
TPoint( paddingRect.iTl.iX, borderRect.iTl.iY ), |
|
2614 |
TPoint( paddingRect.iBr.iX, paddingRect.iTl.iY ) ); |
|
2615 |
TRect topSource = TRect( |
|
2616 |
TPoint( aBorderBitmapDividerLeft, 0 ), |
|
2617 |
TPoint( imageSize.iWidth - aBorderBitmapDividerRight, aBorderBitmapDividerTop ) ); |
|
2618 |
if ( xStretch ) |
|
2619 |
{ |
|
2620 |
aGc.DrawBitmap( top, aBitmap, topSource ); |
|
2621 |
} |
|
2622 |
else if ( xRepeat && topSource.Width() ) |
|
2623 |
{ |
|
2624 |
TInt count = top.Width() / topSource.Width(); |
|
2625 |
TInt topWidth = top.Width(); |
|
2626 |
top.SetWidth( topSource.Width() ); |
|
2627 |
for ( TInt i = 0; i < count; ++i ) |
|
2628 |
{ |
|
2629 |
aGc.DrawBitmap( top, aBitmap, topSource ); |
|
2630 |
top.Move( topSource.Width(), 0 ); |
|
2631 |
} |
|
2632 |
top.SetWidth( topWidth - count * topSource.Width() ); |
|
2633 |
aGc.DrawBitmap( top, aBitmap, topSource ); |
|
2634 |
} |
|
2635 |
else if ( xRound && topSource.Width() ) |
|
2636 |
{ |
|
2637 |
TInt count = top.Width() / topSource.Width(); |
|
2638 |
TInt topWidth = top.Width(); |
|
2639 |
//top.Move((topWidth - count * topSource.Width()) / 2, 0); |
|
2640 |
if ( ( count * topSource.Width() ) < topWidth ) |
|
2641 |
{ |
|
2642 |
++count; |
|
2643 |
top.SetWidth( topWidth / count ); |
|
2644 |
} |
|
2645 |
else |
|
2646 |
{ |
|
2647 |
top.SetWidth( topSource.Width() ); |
|
2648 |
} |
|
2649 |
for ( TInt i = 0; i < count; ++i ) |
|
2650 |
{ |
|
2651 |
aGc.DrawBitmap( top, aBitmap, topSource ); |
|
2652 |
top.Move( top.Width(), 0 ); |
|
2653 |
} |
|
2654 |
} |
|
2655 |
TRect right = TRect( |
|
2656 |
TPoint( paddingRect.iBr.iX, paddingRect.iTl.iY ), |
|
2657 |
TPoint( borderRect.iBr.iX, paddingRect.iBr.iY ) ); |
|
2658 |
TRect rightSource = TRect( |
|
2659 |
TPoint( imageSize.iWidth - aBorderBitmapDividerRight, aBorderBitmapDividerTop ), |
|
2660 |
TPoint( imageSize.iWidth, imageSize.iHeight - aBorderBitmapDividerBottom ) ); |
|
2661 |
if ( yStretch ) |
|
2662 |
{ |
|
2663 |
aGc.DrawBitmap( right, aBitmap, rightSource ); |
|
2664 |
} |
|
2665 |
else if ( yRepeat && rightSource.Height() ) |
|
2666 |
{ |
|
2667 |
TInt count = right.Height() / rightSource.Height(); |
|
2668 |
TInt rightHeight = right.Height(); |
|
2669 |
right.SetHeight( rightSource.Height() ); |
|
2670 |
for ( TInt i = 0; i < count; ++i ) |
|
2671 |
{ |
|
2672 |
aGc.DrawBitmap( right, aBitmap, rightSource ); |
|
2673 |
right.Move( 0, rightSource.Height() ); |
|
2674 |
} |
|
2675 |
right.SetHeight( rightHeight - count * rightSource.Height() ); |
|
2676 |
aGc.DrawBitmap( right, aBitmap, rightSource ); |
|
2677 |
} |
|
2678 |
else if ( yRound && rightSource.Height() ) |
|
2679 |
{ |
|
2680 |
TInt count = right.Height() / rightSource.Height(); |
|
2681 |
TInt rightHeight = right.Height(); |
|
2682 |
if ( ( count * rightSource.Height() ) < rightHeight ) |
|
2683 |
{ |
|
2684 |
++count; |
|
2685 |
right.SetHeight( rightHeight / count ); |
|
2686 |
} |
|
2687 |
else |
|
2688 |
{ |
|
2689 |
right.SetHeight( rightSource.Width() ); |
|
2690 |
} |
|
2691 |
for ( TInt i = 0; i < count; ++i ) |
|
2692 |
{ |
|
2693 |
aGc.DrawBitmap( right, aBitmap, rightSource ); |
|
2694 |
right.Move( 0, right.Height() ); |
|
2695 |
} |
|
2696 |
} |
|
2697 |
TRect bottom = TRect( |
|
2698 |
TPoint( paddingRect.iTl.iX, paddingRect.iBr.iY ), |
|
2699 |
TPoint( paddingRect.iBr.iX, borderRect.iBr.iY ) ); |
|
2700 |
TRect bottomSource = TRect( |
|
2701 |
TPoint( aBorderBitmapDividerLeft, imageSize.iHeight - aBorderBitmapDividerBottom ), |
|
2702 |
TPoint( imageSize.iWidth - aBorderBitmapDividerRight, imageSize.iHeight ) ); |
|
2703 |
if ( xStretch ) |
|
2704 |
{ |
|
2705 |
aGc.DrawBitmap( bottom, aBitmap, bottomSource ); |
|
2706 |
} |
|
2707 |
else if ( xRepeat && bottomSource.Width() ) |
|
2708 |
{ |
|
2709 |
TInt count = bottom.Width() / bottomSource.Width(); |
|
2710 |
TInt bottomWidth = bottom.Width(); |
|
2711 |
bottom.SetWidth( bottomSource.Width() ); |
|
2712 |
for ( TInt i = 0; i < count; ++i ) |
|
2713 |
{ |
|
2714 |
aGc.DrawBitmap( bottom, aBitmap, bottomSource ); |
|
2715 |
bottom.Move( bottomSource.Width(), 0 ); |
|
2716 |
} |
|
2717 |
bottom.SetWidth( bottomWidth - count * bottomSource.Width() ); |
|
2718 |
aGc.DrawBitmap( bottom, aBitmap, bottomSource ); |
|
2719 |
} |
|
2720 |
else if ( xRound && bottomSource.Width() ) |
|
2721 |
{ |
|
2722 |
TInt count = bottom.Width() / bottomSource.Width(); |
|
2723 |
TInt bottomWidth = bottom.Width(); |
|
2724 |
if ( ( count * bottomSource.Width() ) < bottomWidth ) |
|
2725 |
{ |
|
2726 |
++count; |
|
2727 |
bottom.SetWidth( bottomWidth / count ); |
|
2728 |
} |
|
2729 |
else |
|
2730 |
{ |
|
2731 |
bottom.SetWidth( bottomSource.Width() ); |
|
2732 |
} |
|
2733 |
for ( TInt i = 0; i < count; ++i ) |
|
2734 |
{ |
|
2735 |
aGc.DrawBitmap( bottom, aBitmap, bottomSource ); |
|
2736 |
bottom.Move( bottom.Width(), 0 ); |
|
2737 |
} |
|
2738 |
} |
|
2739 |
TRect left = TRect( |
|
2740 |
TPoint( borderRect.iTl.iX, paddingRect.iTl.iY ), |
|
2741 |
TPoint( paddingRect.iTl.iX, paddingRect.iBr.iY ) ); |
|
2742 |
TRect leftSource = TRect( |
|
2743 |
TPoint( 0, aBorderBitmapDividerTop ), |
|
2744 |
TPoint( aBorderBitmapDividerLeft, imageSize.iHeight - aBorderBitmapDividerBottom ) ); |
|
2745 |
if ( yStretch ) |
|
2746 |
{ |
|
2747 |
aGc.DrawBitmap( left, aBitmap, leftSource ); |
|
2748 |
} |
|
2749 |
else if ( yRepeat && leftSource.Height() ) |
|
2750 |
{ |
|
2751 |
TInt count = left.Height() / leftSource.Height(); |
|
2752 |
TInt leftHeight = left.Height(); |
|
2753 |
left.SetHeight( leftSource.Height() ); |
|
2754 |
for ( TInt i = 0; i < count; ++i ) |
|
2755 |
{ |
|
2756 |
aGc.DrawBitmap( left, aBitmap, leftSource ); |
|
2757 |
left.Move( 0, leftSource.Height() ); |
|
2758 |
} |
|
2759 |
left.SetHeight( leftHeight - count * leftSource.Height() ); |
|
2760 |
aGc.DrawBitmap( left, aBitmap, leftSource ); |
|
2761 |
} |
|
2762 |
else if ( yRound && leftSource.Height() ) |
|
2763 |
{ |
|
2764 |
TInt count = left.Height() / leftSource.Height(); |
|
2765 |
TInt leftHeight = left.Height(); |
|
2766 |
if ( ( count * leftSource.Height() ) < leftHeight ) |
|
2767 |
{ |
|
2768 |
++count; |
|
2769 |
left.SetHeight( leftHeight / count ); |
|
2770 |
} |
|
2771 |
else |
|
2772 |
{ |
|
2773 |
left.SetHeight( leftSource.Width() ); |
|
2774 |
} |
|
2775 |
for ( TInt i = 0; i < count; ++i ) |
|
2776 |
{ |
|
2777 |
aGc.DrawBitmap( left, aBitmap, leftSource ); |
|
2778 |
left.Move( 0, left.Height() ); |
|
2779 |
} |
|
2780 |
} |
|
2781 |
} |
|
2782 |
||
2783 |
// ----------------------------------------------------------------------------- |
|
2784 |
// IsPropertyNone |
|
2785 |
// ----------------------------------------------------------------------------- |
|
2786 |
// |
|
2787 |
static TBool IsPropertyNone( CXnProperty& aProperty ) |
|
2788 |
{ |
|
2789 |
if ( &aProperty ) |
|
2790 |
{ |
|
2791 |
TInt index = 0; |
|
2792 |
CXnDomProperty* domProperty = aProperty.Property(); |
|
2793 |
CXnDomPropertyValue* domPropertyValue = |
|
2794 |
static_cast< CXnDomPropertyValue* >( |
|
2795 |
domProperty->PropertyValueList().Item( index ) ); |
|
2796 |
return domPropertyValue->IsNoneIdent(); |
|
2797 |
} |
|
2798 |
return EFalse; |
|
2799 |
} |
|
2800 |
||
2801 |
// ----------------------------------------------------------------------------- |
|
2802 |
// DrawBordersL |
|
2803 |
// ----------------------------------------------------------------------------- |
|
2804 |
// |
|
2805 |
static void DrawBordersL( const TRect& aRect, CXnNode& aNode, CWindowGc& aGc ) |
|
2806 |
{ |
|
2807 |
TRect borderRect( aNode.BorderRect() ); |
|
2808 |
||
2809 |
if( aNode.PaddingRect() == borderRect ) |
|
2810 |
{ |
|
2811 |
return; |
|
2812 |
} |
|
2813 |
||
2814 |
CXnProperty* commonBorderStyle( aNode.BorderStyleL() ); |
|
2815 |
CXnProperty* borderStyle( aNode.BorderTopStyleL() ); |
|
2816 |
||
2817 |
if ( ( borderStyle && !IsPropertyNone( *borderStyle ) ) || |
|
2818 |
( commonBorderStyle && !IsPropertyNone( *commonBorderStyle ) ) ) |
|
2819 |
{ |
|
2820 |
DrawTopBorderL( aRect, aNode, aGc ); |
|
2821 |
} |
|
2822 |
||
2823 |
borderStyle = aNode.BorderLeftStyleL(); |
|
2824 |
||
2825 |
if ( ( borderStyle && !IsPropertyNone( *borderStyle ) ) || |
|
2826 |
( commonBorderStyle && !IsPropertyNone( *commonBorderStyle ) ) ) |
|
2827 |
{ |
|
2828 |
DrawLeftBorderL( aRect, aNode, aGc ); |
|
2829 |
} |
|
2830 |
||
2831 |
borderStyle = aNode.BorderRightStyleL(); |
|
2832 |
||
2833 |
if ( ( borderStyle && !IsPropertyNone( *borderStyle ) ) || |
|
2834 |
( commonBorderStyle && !IsPropertyNone( *commonBorderStyle ) ) ) |
|
2835 |
{ |
|
2836 |
DrawRightBorderL( aRect, aNode, aGc ); |
|
2837 |
} |
|
2838 |
||
2839 |
borderStyle = aNode.BorderBottomStyleL(); |
|
2840 |
||
2841 |
if ( ( borderStyle && !IsPropertyNone( *borderStyle ) ) || |
|
2842 |
( commonBorderStyle && !IsPropertyNone( *commonBorderStyle ) ) ) |
|
2843 |
{ |
|
2844 |
DrawBottomBorderL( aRect, aNode, aGc ); |
|
2845 |
} |
|
2846 |
} |
|
2847 |
||
2848 |
// ----------------------------------------------------------------------------- |
|
2849 |
// SwapChildArrays |
|
2850 |
// ----------------------------------------------------------------------------- |
|
2851 |
// |
|
2852 |
static void SwapChildArrays( |
|
2853 |
RPointerArray< CXnControlAdapter >& originalArray, |
|
2854 |
RPointerArray< CXnControlAdapter >& sortedArray ) |
|
2855 |
{ |
|
2856 |
originalArray.Reset(); |
|
2857 |
TInt count = sortedArray.Count(); |
|
2858 |
for ( TInt i = 0; i < count; ++i ) |
|
2859 |
{ |
|
2860 |
originalArray.Append( sortedArray[i] ); |
|
2861 |
} |
|
2862 |
sortedArray.Reset(); |
|
2863 |
} |
|
2864 |
||
2865 |
// ----------------------------------------------------------------------------- |
|
2866 |
// IsChildZIndexLowerThanCandidateZIndexL |
|
2867 |
// ----------------------------------------------------------------------------- |
|
2868 |
// |
|
2869 |
static TBool IsChildZIndexLowerThanCandidateZIndexL( |
|
2870 |
CXnProperty* aChildZIndex, |
|
2871 |
CXnDomPropertyValue* aChildZIndexValue, |
|
2872 |
CXnProperty* aCandidateZIndex ) |
|
2873 |
{ |
|
2874 |
if ( !aChildZIndex && !aCandidateZIndex ) |
|
2875 |
{ |
|
2876 |
return ETrue; |
|
2877 |
} |
|
2878 |
if ( !aChildZIndex ) |
|
2879 |
{ |
|
2880 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
2881 |
aCandidateZIndex->Property()->PropertyValueList().Item( 0 ) ); |
|
2882 |
if ( value->IsAutoIdent() ) |
|
2883 |
{ |
|
2884 |
return ETrue; |
|
2885 |
} |
|
2886 |
TReal num = value->FloatValueL(); |
|
2887 |
if ( num > 0 ) |
|
2888 |
{ |
|
2889 |
return ETrue; |
|
2890 |
} |
|
2891 |
} |
|
2892 |
else if ( !aCandidateZIndex ) |
|
2893 |
{ |
|
2894 |
if ( aChildZIndexValue->IsAutoIdent() ) |
|
2895 |
{ |
|
2896 |
return ETrue; |
|
2897 |
} |
|
2898 |
TReal num = aChildZIndexValue->FloatValueL(); |
|
2899 |
if ( num < 0 ) |
|
2900 |
{ |
|
2901 |
return ETrue; |
|
2902 |
} |
|
2903 |
} |
|
2904 |
else |
|
2905 |
{ |
|
2906 |
CXnDomPropertyValue* candidateValue = |
|
2907 |
static_cast< CXnDomPropertyValue* >( |
|
2908 |
aCandidateZIndex->Property()->PropertyValueList().Item( 0 ) ); |
|
2909 |
if ( aChildZIndexValue->IsAutoIdent() && candidateValue->IsAutoIdent() ) |
|
2910 |
{ |
|
2911 |
return ETrue; |
|
2912 |
} |
|
2913 |
else if ( aChildZIndexValue->IsAutoIdent() && !candidateValue->IsAutoIdent() ) |
|
2914 |
{ |
|
2915 |
return ETrue; |
|
2916 |
} |
|
2917 |
else if ( !aChildZIndexValue->IsAutoIdent() && candidateValue->IsAutoIdent() ) |
|
2918 |
{ |
|
2919 |
return EFalse; |
|
2920 |
} |
|
2921 |
TReal childNum = aChildZIndexValue->FloatValueL(); |
|
2922 |
TReal candidateNum = candidateValue->FloatValueL(); |
|
2923 |
if ( childNum <= candidateNum ) |
|
2924 |
{ |
|
2925 |
return ETrue; |
|
2926 |
} |
|
2927 |
} |
|
2928 |
return EFalse; |
|
2929 |
} |
|
2930 |
||
2931 |
// ----------------------------------------------------------------------------- |
|
2932 |
// GetZIndex |
|
2933 |
// ----------------------------------------------------------------------------- |
|
2934 |
// |
|
2935 |
static CXnProperty* GetZIndexL( CXnControlAdapter* aAdapter ) |
|
2936 |
{ |
|
2937 |
CXnComponent* component = aAdapter->Component(); |
|
2938 |
if ( !component ) |
|
2939 |
{ |
|
2940 |
return NULL; |
|
2941 |
} |
|
2942 |
CXnNode& node = component->Node()->Node(); |
|
2943 |
return node.ZIndexL(); |
|
2944 |
} |
|
2945 |
||
2946 |
// ----------------------------------------------------------------------------- |
|
2947 |
// InsertChildToSortedArrayL |
|
2948 |
// ----------------------------------------------------------------------------- |
|
2949 |
// |
|
2950 |
static void InsertChildToSortedArrayL( |
|
2951 |
RPointerArray< CXnControlAdapter >& aTargetArray, |
|
2952 |
CXnControlAdapter* aChild ) |
|
2953 |
{ |
|
2954 |
CXnProperty* childZIndex = GetZIndexL( aChild ); |
|
2955 |
CXnDomPropertyValue* childValue = NULL; |
|
2956 |
if ( childZIndex ) |
|
2957 |
{ |
|
2958 |
childValue = static_cast< CXnDomPropertyValue* >( |
|
2959 |
childZIndex->Property()->PropertyValueList().Item( 0 ) ); |
|
2960 |
} |
|
2961 |
TInt count = aTargetArray.Count(); |
|
2962 |
for ( TInt i = 0; i < count; ++i ) |
|
2963 |
{ |
|
2964 |
CXnControlAdapter* candidate = aTargetArray[i]; |
|
2965 |
if ( IsChildZIndexLowerThanCandidateZIndexL( |
|
2966 |
childZIndex, childValue, GetZIndexL( candidate ) ) ) |
|
2967 |
{ |
|
2968 |
aTargetArray.Insert( aChild, i ); |
|
2969 |
return; |
|
2970 |
} |
|
2971 |
} |
|
2972 |
aTargetArray.Append( aChild ); |
|
2973 |
} |
|
2974 |
||
2975 |
// ----------------------------------------------------------------------------- |
|
2976 |
// InitializeBackgroundBitmapL |
|
2977 |
// ----------------------------------------------------------------------------- |
|
2978 |
// |
|
2979 |
static void InitializeBackgroundBitmapL( CXnUiEngine& aEngine, CXnNode& aNode, |
|
2980 |
TInt& aBitmapIndex, CFbsBitmap*& aBitmap, CFbsBitmap*& aMask, |
|
2981 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, RFs& aFsSession ) |
|
2982 |
{ |
|
2983 |
HBufC* bgPath( GetBackgroundImagePathLC( aNode ) ); |
|
2984 |
TPtr ptr( bgPath->Des() ); |
|
2985 |
||
2986 |
GetBitmapL( aEngine, aNode, ptr, aBitmapIndex, |
|
2987 |
aBitmap, aMask, aIconProvider, aNode.PaddingRect(), aFsSession ); |
|
2988 |
||
2989 |
CleanupStack::PopAndDestroy( bgPath ); |
|
2990 |
||
2991 |
if ( !aMask ) |
|
2992 |
{ |
|
2993 |
HBufC* bgMaskPath( GetBackgroundImageMaskPathLC( aNode ) ); |
|
2994 |
TPtr ptr( bgMaskPath->Des() ); |
|
2995 |
||
2996 |
if ( ptr != KNullDesC ) |
|
2997 |
{ |
|
2998 |
CFbsBitmap* tmpMask( NULL ); |
|
2999 |
||
3000 |
TRAP_IGNORE( GetBitmapL( aEngine, aNode, ptr, aBitmapIndex, aMask, |
|
3001 |
tmpMask, aIconProvider, aNode.PaddingRect(), aFsSession ) ); |
|
3002 |
||
3003 |
delete tmpMask; |
|
3004 |
} |
|
3005 |
||
3006 |
CleanupStack::PopAndDestroy( bgMaskPath ); |
|
3007 |
} |
|
3008 |
} |
|
3009 |
||
3010 |
// ----------------------------------------------------------------------------- |
|
3011 |
// GetBackgroundImagePathLC |
|
3012 |
// ----------------------------------------------------------------------------- |
|
3013 |
// |
|
3014 |
static HBufC* GetBackgroundImagePathLC( CXnNode& aNode ) |
|
3015 |
{ |
|
3016 |
CXnProperty* pathProperty( aNode.BackgroundImageL() ); |
|
3017 |
||
3018 |
if ( pathProperty && pathProperty->StringValue() != KNullDesC8 ) |
|
3019 |
{ |
|
3020 |
HBufC* path( pathProperty->StringValueL() ); |
|
3021 |
CleanupStack::PushL( path ); |
|
3022 |
||
3023 |
CXnUtils::StripQuotes( path ); |
|
3024 |
||
3025 |
return path; |
|
3026 |
} |
|
3027 |
||
3028 |
return KNullDesC().AllocLC(); |
|
3029 |
} |
|
3030 |
||
3031 |
// ----------------------------------------------------------------------------- |
|
3032 |
// GetBackgroundImageMaskPathLC |
|
3033 |
// ----------------------------------------------------------------------------- |
|
3034 |
// |
|
3035 |
static HBufC* GetBackgroundImageMaskPathLC( CXnNode& aNode ) |
|
3036 |
{ |
|
3037 |
CXnProperty* pathProperty( aNode.GetPropertyL( |
|
3038 |
XnPropertyNames::common::KBackgroundMask ) ); |
|
3039 |
||
3040 |
if ( pathProperty && pathProperty->StringValue() != KNullDesC8 ) |
|
3041 |
{ |
|
3042 |
HBufC* path( pathProperty->StringValueL() ); |
|
3043 |
CleanupStack::PushL( path ); |
|
3044 |
||
3045 |
CXnUtils::StripQuotes( path ); |
|
3046 |
||
3047 |
return path; |
|
3048 |
} |
|
3049 |
||
3050 |
return KNullDesC().AllocLC(); |
|
3051 |
} |
|
3052 |
||
3053 |
// ----------------------------------------------------------------------------- |
|
3054 |
// InitializeBorderBitmapL |
|
3055 |
// ----------------------------------------------------------------------------- |
|
3056 |
// |
|
3057 |
static CFbsBitmap* InitializeBorderBitmapL( |
|
3058 |
CXnUiEngine& aEngine, |
|
3059 |
CXnNode& aNode, |
|
3060 |
TInt& aBitmapIndex, |
|
3061 |
TInt& aBorderBitmapDividerTop, |
|
3062 |
TInt& aBorderBitmapDividerRight, |
|
3063 |
TInt& aBorderBitmapDividerBottom, |
|
3064 |
TInt& aBorderBitmapDividerLeft, |
|
3065 |
CXnControlAdapterImpl::TIconProvider*& aIconProvider, |
|
3066 |
RFs& aFsSession ) |
|
3067 |
{ |
|
3068 |
CXnProperty* pathProperty = aNode.BorderImageL(); |
|
3069 |
CFbsBitmap* returnValue = NULL; |
|
3070 |
CFbsBitmap* bitmapMask = NULL; |
|
3071 |
||
3072 |
if ( !pathProperty ) |
|
3073 |
{ |
|
3074 |
return NULL; |
|
3075 |
} |
|
3076 |
||
3077 |
CXnDomList& propertyValueList = pathProperty->Property()->PropertyValueList(); |
|
3078 |
TInt count = propertyValueList.Length(); |
|
3079 |
||
3080 |
for ( TInt i = 0; i < count; ++i ) |
|
3081 |
{ |
|
3082 |
CXnDomPropertyValue* value = static_cast< CXnDomPropertyValue* >( |
|
3083 |
propertyValueList.Item( i ) ); |
|
3084 |
||
3085 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::EUri ) |
|
3086 |
{ |
|
3087 |
const TDesC8& path = value->StringValueL(); |
|
3088 |
||
3089 |
HBufC* utfPath = HBufC::NewL( path.Length() ); |
|
3090 |
TPtr16 ptr = utfPath->Des(); |
|
3091 |
||
3092 |
CnvUtfConverter::ConvertToUnicodeFromUtf8( ptr, path ); |
|
3093 |
CleanupStack::PushL( utfPath ); |
|
3094 |
||
3095 |
StripQuotes( utfPath ); |
|
3096 |
||
3097 |
GetBitmapL( aEngine, aNode, *utfPath, aBitmapIndex, returnValue, |
|
3098 |
bitmapMask, aIconProvider, aNode.BorderRect(), aFsSession ); |
|
3099 |
||
3100 |
delete bitmapMask; |
|
3101 |
||
3102 |
CleanupStack::PopAndDestroy( utfPath ); |
|
3103 |
} |
|
3104 |
else if ( value->PrimitiveValueType() == CXnDomPropertyValue::EPercentage ) |
|
3105 |
{ |
|
3106 |
if ( returnValue ) |
|
3107 |
{ |
|
3108 |
CXnDomPropertyValue* tmpValue = NULL; |
|
3109 |
tmpValue = value->CloneL(); |
|
3110 |
CXnProperty* tmpProperty = NULL; |
|
3111 |
CleanupStack::PushL( tmpValue ); |
|
3112 |
tmpProperty = CXnProperty::NewL( |
|
3113 |
KNullDesC8, |
|
3114 |
tmpValue, |
|
3115 |
*aNode.UiEngine()->ODT()->DomDocument().StringPool() ); |
|
3116 |
CleanupStack::Pop( tmpValue ); |
|
3117 |
TSize imageSize = returnValue->SizeInPixels(); |
|
3118 |
CleanupStack::PushL( tmpProperty ); |
|
3119 |
TInt intValue = static_cast< TInt >( value->FloatValueL() ); |
|
3120 |
TInt dividerValue = 0; |
|
3121 |
||
3122 |
switch ( i ) |
|
3123 |
{ |
|
3124 |
case 1: |
|
3125 |
{ |
|
3126 |
dividerValue = aNode.UiEngine()->VerticalPixelValueL( |
|
3127 |
tmpProperty, imageSize.iHeight ); |
|
3128 |
aBorderBitmapDividerTop = dividerValue; |
|
3129 |
break; |
|
3130 |
} |
|
3131 |
case 2: |
|
3132 |
{ |
|
3133 |
dividerValue = aNode.UiEngine()->HorizontalPixelValueL( |
|
3134 |
tmpProperty, imageSize.iWidth ); |
|
3135 |
aBorderBitmapDividerRight = dividerValue; |
|
3136 |
break; |
|
3137 |
} |
|
3138 |
case 3: |
|
3139 |
{ |
|
3140 |
dividerValue = aNode.UiEngine()->VerticalPixelValueL( |
|
3141 |
tmpProperty, imageSize.iHeight ); |
|
3142 |
aBorderBitmapDividerBottom = dividerValue; |
|
3143 |
break; |
|
3144 |
} |
|
3145 |
case 4: |
|
3146 |
{ |
|
3147 |
dividerValue = aNode.UiEngine()->HorizontalPixelValueL( |
|
3148 |
tmpProperty, imageSize.iWidth ); |
|
3149 |
aBorderBitmapDividerLeft = dividerValue; |
|
3150 |
break; |
|
3151 |
} |
|
3152 |
} |
|
3153 |
||
3154 |
CleanupStack::PopAndDestroy( tmpProperty ); |
|
3155 |
} |
|
3156 |
} |
|
3157 |
else if ( value->PrimitiveValueType() == CXnDomPropertyValue::EString || |
|
3158 |
value->PrimitiveValueType() == CXnDomPropertyValue::EIdent ) |
|
3159 |
{ |
|
3160 |
} |
|
3161 |
else |
|
3162 |
{ |
|
3163 |
TInt intValue = static_cast< TInt >( value->FloatValueL() ); |
|
3164 |
||
3165 |
switch ( i ) |
|
3166 |
{ |
|
3167 |
case 1: |
|
3168 |
{ |
|
3169 |
aBorderBitmapDividerTop = intValue; |
|
3170 |
break; |
|
3171 |
} |
|
3172 |
case 2: |
|
3173 |
{ |
|
3174 |
aBorderBitmapDividerRight = intValue; |
|
3175 |
break; |
|
3176 |
} |
|
3177 |
case 3: |
|
3178 |
{ |
|
3179 |
aBorderBitmapDividerBottom = intValue; |
|
3180 |
break; |
|
3181 |
} |
|
3182 |
case 4: |
|
3183 |
{ |
|
3184 |
aBorderBitmapDividerLeft = intValue; |
|
3185 |
break; |
|
3186 |
} |
|
3187 |
} |
|
3188 |
} |
|
3189 |
} |
|
3190 |
||
3191 |
return returnValue; |
|
3192 |
} |
|
3193 |
||
3194 |
// ----------------------------------------------------------------------------- |
|
3195 |
// BuildTriggerTypeNodeL |
|
3196 |
// ----------------------------------------------------------------------------- |
|
3197 |
// |
|
3198 |
static CXnNode* BuildTriggerTypeNodeL( const TDesC8& aName, |
|
3199 |
const TDesC8& aValue, CXnUiEngine& aUiEngine ) |
|
3200 |
{ |
|
3201 |
CXnNode* node = CXnNode::NewL(); |
|
3202 |
CleanupStack::PushL( node ); |
|
3203 |
CXnType* type = CXnType::NewL( XnPropertyNames::action::KProperty ); |
|
3204 |
CleanupStack::PushL( type ); |
|
3205 |
CXnNodeImpl* impl = CXnNodeImpl::NewL( type ); |
|
3206 |
CleanupStack::Pop( type ); |
|
3207 |
node->SetImpl( impl ); |
|
3208 |
node->SetUiEngine( aUiEngine ); |
|
3209 |
CXnDomPropertyValue* nameValue = CXnDomPropertyValue::NewL( |
|
3210 |
aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3211 |
CleanupStack::PushL( nameValue ); |
|
3212 |
nameValue->SetStringValueL( CXnDomPropertyValue::EString, aName ); |
|
3213 |
CXnProperty* name = CXnProperty::NewL( XnPropertyNames::action::KName, |
|
3214 |
nameValue, *aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3215 |
CleanupStack::Pop( nameValue ); |
|
3216 |
CleanupStack::PushL( name ); |
|
3217 |
node->SetPropertyL( name ); |
|
3218 |
CleanupStack::Pop( name ); |
|
3219 |
CXnDomPropertyValue* valueValue = CXnDomPropertyValue::NewL( |
|
3220 |
aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3221 |
CleanupStack::PushL( valueValue ); |
|
3222 |
valueValue->SetStringValueL( CXnDomPropertyValue::EString, aValue ); |
|
3223 |
CXnProperty* value = CXnProperty::NewL( XnPropertyNames::action::KValue, |
|
3224 |
valueValue, *aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3225 |
CleanupStack::Pop( valueValue ); |
|
3226 |
CleanupStack::PushL( value ); |
|
3227 |
node->SetPropertyL( value ); |
|
3228 |
CleanupStack::Pop( value ); |
|
3229 |
CleanupStack::Pop( node ); |
|
3230 |
return node; |
|
3231 |
} |
|
3232 |
||
3233 |
// ----------------------------------------------------------------------------- |
|
3234 |
// BuildTriggerNodeL |
|
3235 |
// Builds a trigger node |
|
3236 |
// ----------------------------------------------------------------------------- |
|
3237 |
// |
|
3238 |
static CXnNode* BuildTriggerNodeL( |
|
3239 |
CXnUiEngine& aUiEngine, |
|
3240 |
const TDesC8& aTriggerName, |
|
3241 |
const TDesC8& aTriggerValueName, |
|
3242 |
const TDesC8& aTriggerValue ) |
|
3243 |
{ |
|
3244 |
CXnNode* node = CXnNode::NewL(); |
|
3245 |
CleanupStack::PushL( node ); |
|
3246 |
CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger ); |
|
3247 |
CleanupStack::PushL( type ); |
|
3248 |
CXnNodeImpl* impl = CXnNodeImpl::NewL( type ); |
|
3249 |
CleanupStack::Pop( type ); |
|
3250 |
node->SetImpl( impl ); |
|
3251 |
node->SetUiEngine( aUiEngine ); |
|
3252 |
CXnDomPropertyValue* nameValue = |
|
3253 |
CXnDomPropertyValue::NewL( aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3254 |
CleanupStack::PushL( nameValue ); |
|
3255 |
nameValue->SetStringValueL( CXnDomPropertyValue::EString, aTriggerName ); |
|
3256 |
CXnProperty* name = CXnProperty::NewL( XnPropertyNames::action::trigger::KName, |
|
3257 |
nameValue, *aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3258 |
CleanupStack::Pop( nameValue ); |
|
3259 |
CleanupStack::PushL( name ); |
|
3260 |
node->SetPropertyL( name ); |
|
3261 |
CleanupStack::Pop( name ); |
|
3262 |
CXnNode* triggerType = BuildTriggerTypeNodeL( aTriggerValueName, |
|
3263 |
aTriggerValue, aUiEngine ); |
|
3264 |
CleanupStack::PushL( triggerType ); |
|
3265 |
node->AddChildL( triggerType ); |
|
3266 |
CleanupStack::Pop( triggerType ); |
|
3267 |
CleanupStack::Pop( node ); |
|
3268 |
return node; |
|
3269 |
} |
|
3270 |
||
3271 |
// ----------------------------------------------------------------------------- |
|
3272 |
// BuildTriggerNodeL |
|
3273 |
// Builds a trigger node |
|
3274 |
// ----------------------------------------------------------------------------- |
|
3275 |
// |
|
3276 |
static CXnNode* BuildTriggerNodeL( |
|
3277 |
CXnUiEngine& aUiEngine, |
|
3278 |
const TDesC8& aTriggerName ) |
|
3279 |
{ |
|
3280 |
CXnNode* node = CXnNode::NewL(); |
|
3281 |
CleanupStack::PushL( node ); |
|
3282 |
CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger ); |
|
3283 |
CleanupStack::PushL( type ); |
|
3284 |
CXnNodeImpl* impl = CXnNodeImpl::NewL( type ); |
|
3285 |
CleanupStack::Pop( type ); |
|
3286 |
node->SetImpl( impl ); |
|
3287 |
node->SetUiEngine( aUiEngine ); |
|
3288 |
CXnDomPropertyValue* nameValue = |
|
3289 |
CXnDomPropertyValue::NewL( aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3290 |
CleanupStack::PushL( nameValue ); |
|
3291 |
nameValue->SetStringValueL( CXnDomPropertyValue::EString, aTriggerName ); |
|
3292 |
CXnProperty* name = CXnProperty::NewL( XnPropertyNames::action::trigger::KName, |
|
3293 |
nameValue, *aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3294 |
CleanupStack::Pop( nameValue ); |
|
3295 |
CleanupStack::PushL( name ); |
|
3296 |
node->SetPropertyL( name ); |
|
3297 |
CleanupStack::Pop( name ); |
|
3298 |
CleanupStack::Pop( node ); |
|
3299 |
return node; |
|
3300 |
} |
|
3301 |
||
3302 |
// ----------------------------------------------------------------------------- |
|
3303 |
// SoftkeyNode |
|
3304 |
// Gets the node of softkey according to pointer location |
|
3305 |
// ----------------------------------------------------------------------------- |
|
3306 |
// |
|
3307 |
static CXnNode* SoftkeyNode( CXnNode* aMenuBarNode, const TPoint aPosition ) |
|
3308 |
{ |
|
3309 |
if ( aMenuBarNode ) |
|
3310 |
{ |
|
3311 |
CXnMenuAdapter* adapter = static_cast< CXnMenuAdapter* >( |
|
3312 |
aMenuBarNode->ComponentNodeImpl()->Component()->ControlAdapter() ); |
|
3313 |
||
3314 |
CXnNodePluginIf* node( NULL ); |
|
3315 |
||
3316 |
if ( adapter->FindSoftKeyNodeByPosition( aPosition, node ) ) |
|
3317 |
{ |
|
3318 |
return &node->Node(); |
|
3319 |
} |
|
3320 |
} |
|
3321 |
||
3322 |
return NULL; |
|
3323 |
} |
|
3324 |
||
3325 |
// ----------------------------------------------------------------------------- |
|
3326 |
// DrawFocusAppearance |
|
3327 |
// Draws focus appearance |
|
3328 |
// ----------------------------------------------------------------------------- |
|
3329 |
// |
|
3330 |
static void DrawFocusAppearance( CXnNode& aNode, CWindowGc& aGc ) |
|
3331 |
{ |
|
3332 |
TBool grow( EFalse ); |
|
3333 |
||
3334 |
const TDesC8& name( aNode.DomNode()->Name() ); |
|
3335 |
||
3336 |
if( name == XnPropertyNames::KPlugin ) |
|
3337 |
{ |
|
3338 |
grow = ETrue; |
|
3339 |
} |
|
3340 |
else |
|
3341 |
{ |
|
3342 |
TRect marginRect( aNode.MarginRect() ); |
|
3343 |
||
3344 |
CXnNode* parent( aNode.Parent() ); |
|
3345 |
||
3346 |
for( ; parent; parent = parent->Parent() ) |
|
3347 |
{ |
|
3348 |
if( parent->DomNode()->Name() == XnPropertyNames::KPlugin ) |
|
3349 |
{ |
|
3350 |
if( parent->Rect() == marginRect ) |
|
3351 |
{ |
|
3352 |
grow = ETrue; |
|
3353 |
} |
|
3354 |
||
3355 |
break; |
|
3356 |
} |
|
3357 |
} |
|
3358 |
} |
|
3359 |
||
3360 |
TRect rect( aNode.PaddingRect() ); |
|
3361 |
||
3362 |
if( grow ) |
|
3363 |
{ |
|
3364 |
rect.Grow( KFocusGrowValue, KFocusGrowValue ); |
|
3365 |
} |
|
3366 |
||
3367 |
CXnAppUiAdapter* appui( |
|
3368 |
static_cast< CXnAppUiAdapter* >( iAvkonAppUi ) ); |
|
3369 |
||
3370 |
appui->ViewAdapter().FocusControl().Draw( rect, aGc ); |
|
3371 |
} |
|
3372 |
||
3373 |
// ----------------------------------------------------------------------------- |
|
3374 |
// HasHoldTrigger |
|
3375 |
// Queries whether this node has a hold trigger defined |
|
3376 |
// ----------------------------------------------------------------------------- |
|
3377 |
// |
|
3378 |
static CXnDomNode* HasHoldTrigger( CXnDomNode* aNode ) |
|
3379 |
{ |
|
3380 |
if ( !aNode ) |
|
3381 |
{ |
|
3382 |
return NULL; |
|
3383 |
} |
|
3384 |
||
3385 |
if ( aNode->Name() == XnPropertyNames::action::KTrigger ) |
|
3386 |
{ |
|
3387 |
CXnDomList& list( aNode->AttributeList() ); |
|
3388 |
||
3389 |
CXnDomAttribute* name( NULL ); |
|
3390 |
||
3391 |
name = static_cast< CXnDomAttribute* >( |
|
3392 |
list.FindByName( XnPropertyNames::action::KName ) ); |
|
3393 |
||
3394 |
if ( name && name->Value() == XnPropertyNames::action::trigger::name::KHold ) |
|
3395 |
{ |
|
3396 |
return aNode; |
|
3397 |
} |
|
3398 |
} |
|
3399 |
||
3400 |
CXnDomList& list( aNode->ChildNodes() ); |
|
3401 |
||
3402 |
for ( TInt i = 0; i < list.Length(); i++ ) |
|
3403 |
{ |
|
3404 |
CXnDomNode* retval( HasHoldTrigger( |
|
3405 |
static_cast< CXnDomNode* >( list.Item( i ) ) ) ); |
|
3406 |
||
3407 |
if ( retval ) |
|
3408 |
{ |
|
3409 |
return retval; |
|
3410 |
} |
|
3411 |
} |
|
3412 |
||
3413 |
return NULL; |
|
3414 |
} |
|
3415 |
||
3416 |
// ----------------------------------------------------------------------------- |
|
3417 |
// Calculates scaled bitmap size (rect) |
|
3418 |
// ----------------------------------------------------------------------------- |
|
3419 |
// |
|
3420 |
void CalculateScaledBitmapRect( TSize& aScaledSize, const TSize& aDrawSize, |
|
3421 |
const TSize& aImageSize ) |
|
3422 |
{ |
|
3423 |
//no scaling as default |
|
3424 |
TReal scaleRatio( 1.0f ); |
|
3425 |
aScaledSize.SetSize( aDrawSize.iWidth, aDrawSize.iHeight ); |
|
3426 |
||
3427 |
//If any dimension is 0, then we do not bother to scale |
|
3428 |
if ( aDrawSize.iWidth == 0 || aDrawSize.iHeight == 0 ) |
|
3429 |
{ |
|
3430 |
return; |
|
3431 |
} |
|
3432 |
||
3433 |
TReal xRatio = |
|
3434 |
( ( TReal )aImageSize.iWidth / ( TReal )aDrawSize.iWidth ); |
|
3435 |
TReal yRatio = |
|
3436 |
( ( TReal )aImageSize.iHeight / ( TReal )aDrawSize.iHeight ); |
|
3437 |
//Find out appropriate scaling factor |
|
3438 |
xRatio > yRatio ? ( scaleRatio = xRatio ) : ( scaleRatio = yRatio ); |
|
3439 |
||
3440 |
// ratio is too small (can be considered as division by zero) |
|
3441 |
if ( scaleRatio < KEps && scaleRatio > -KEps ) |
|
3442 |
{ |
|
3443 |
return; |
|
3444 |
} |
|
3445 |
||
3446 |
// Otherwise scaling can be done |
|
3447 |
aScaledSize.iWidth = ( TInt )( ( TReal )aImageSize.iWidth / scaleRatio ); |
|
3448 |
aScaledSize.iHeight = |
|
3449 |
( TInt )( ( TReal )aImageSize.iHeight / scaleRatio ); |
|
3450 |
} |
|
3451 |
||
3452 |
// ----------------------------------------------------------------------------- |
|
3453 |
// BuildSwipeTriggerNodeLC |
|
3454 |
// Build trigger node for swipe event |
|
3455 |
// ----------------------------------------------------------------------------- |
|
3456 |
// |
|
3457 |
CXnNode* CXnControlAdapterImpl::BuildSwipeTriggerNodeLC( |
|
3458 |
CXnUiEngine& aUiEngine, |
|
3459 |
const TDesC8& aDirection ) |
|
3460 |
{ |
|
3461 |
CXnDomStringPool* sp( aUiEngine.ODT()->DomDocument().StringPool() ); |
|
3462 |
||
3463 |
CXnNode* node = CXnNode::NewL(); |
|
3464 |
CleanupStack::PushL( node ); |
|
3465 |
||
3466 |
CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger ); |
|
3467 |
CleanupStack::PushL( type ); |
|
3468 |
||
3469 |
CXnNodeImpl* impl = CXnNodeImpl::NewL( type ); |
|
3470 |
CleanupStack::Pop( type ); |
|
3471 |
||
3472 |
node->SetImpl( impl ); |
|
3473 |
node->SetUiEngine( aUiEngine ); |
|
3474 |
||
3475 |
CXnDomPropertyValue* nameValue = CXnDomPropertyValue::NewL( sp ); |
|
3476 |
CleanupStack::PushL( nameValue ); |
|
3477 |
||
3478 |
nameValue->SetStringValueL( |
|
3479 |
CXnDomPropertyValue::EString, |
|
3480 |
XnPropertyNames::action::trigger::name::KSwipe ); |
|
3481 |
||
3482 |
CXnProperty* name = CXnProperty::NewL( |
|
3483 |
XnPropertyNames::action::trigger::KName, |
|
3484 |
nameValue, *sp ); |
|
3485 |
||
3486 |
CleanupStack::Pop( nameValue ); |
|
3487 |
CleanupStack::PushL( name ); |
|
3488 |
||
3489 |
node->SetPropertyL( name ); |
|
3490 |
CleanupStack::Pop( name ); |
|
3491 |
||
3492 |
CXnDomPropertyValue* reasonValue = CXnDomPropertyValue::NewL( sp ); |
|
3493 |
CleanupStack::PushL( reasonValue ); |
|
3494 |
||
3495 |
reasonValue->SetStringValueL( CXnDomPropertyValue::EString, aDirection ); |
|
3496 |
||
3497 |
CXnProperty* reason = CXnProperty::NewL( |
|
3498 |
XnPropertyNames::action::trigger::name::swipe::KDirection, |
|
3499 |
reasonValue, *sp ); |
|
3500 |
||
3501 |
CleanupStack::Pop( reasonValue ); |
|
3502 |
||
3503 |
CleanupStack::PushL( reason ); |
|
3504 |
node->SetPropertyL( reason ); |
|
3505 |
CleanupStack::Pop( reason ); |
|
3506 |
||
3507 |
return node; |
|
3508 |
} |
|
3509 |
||
3510 |
// ----------------------------------------------------------------------------- |
|
3511 |
// CreateGestureHelperL |
|
3512 |
// Checks whether gesture is needed to be detected for this node |
|
3513 |
// ----------------------------------------------------------------------------- |
|
3514 |
// |
|
3515 |
static TBool CreateGestureHelperL( CXnNode& aNode ) |
|
3516 |
{ |
|
3517 |
if ( AknLayoutUtils::PenEnabled() ) |
|
3518 |
{ |
|
3519 |
CXnProperty* prop( aNode.GetPropertyL( XnPropertyNames::common::KSwipe ) ); |
|
3520 |
||
3521 |
if ( prop && prop->StringValue() == XnPropertyNames::KTrue ) |
|
3522 |
{ |
|
3523 |
return ETrue; |
|
3524 |
} |
|
3525 |
} |
|
3526 |
||
3527 |
return EFalse; |
|
3528 |
} |
|
3529 |
||
3530 |
// ============================ MEMBER FUNCTIONS =============================== |
|
3531 |
||
3532 |
// ----------------------------------------------------------------------------- |
|
3533 |
// CXnControlAdapterImpl::NewL |
|
3534 |
// Two-phased constructor. Can leave. |
|
3535 |
// ----------------------------------------------------------------------------- |
|
3536 |
// |
|
3537 |
CXnControlAdapterImpl* CXnControlAdapterImpl::NewL( |
|
3538 |
CXnNodePluginIf& aNode, |
|
3539 |
CXnControlAdapter& aAdapter, |
|
3540 |
CWindowGc& aGc ) |
|
3541 |
{ |
|
3542 |
CXnControlAdapterImpl* self = new ( ELeave ) CXnControlAdapterImpl( aNode ); |
|
3543 |
CleanupStack::PushL( self ); |
|
3544 |
self->ConstructL( aNode, aAdapter, aGc ); |
|
3545 |
CleanupStack::Pop(); |
|
3546 |
return self; |
|
3547 |
} |
|
3548 |
||
3549 |
// ----------------------------------------------------------------------------- |
|
3550 |
// CXnControlAdapterImpl::~CXnControlAdapterImpl |
|
3551 |
// Destructor. |
|
3552 |
// ----------------------------------------------------------------------------- |
|
3553 |
// |
|
3554 |
CXnControlAdapterImpl::~CXnControlAdapterImpl() |
|
3555 |
{ |
|
3556 |
delete iBackgroundBitmap; |
|
3557 |
delete iBackgroundMask; |
|
3558 |
delete iBorderBitmap; |
|
3559 |
delete iContentBitmap; |
|
3560 |
delete iContentMask; |
|
3561 |
||
3562 |
iChildren.Reset(); |
|
3563 |
||
3564 |
if ( iAnimation ) |
|
3565 |
{ |
|
3566 |
iAnimation->Stop(); |
|
3567 |
delete iAnimation; |
|
3568 |
} |
|
3569 |
||
3570 |
delete iGestureFw; |
|
3571 |
delete iSuppressor; |
|
3572 |
} |
|
3573 |
||
3574 |
// ----------------------------------------------------------------------------- |
|
3575 |
// CXnControlAdapterImpl::CXnControlAdapterImpl |
|
3576 |
// C++ default constructor. Must not leave. |
|
3577 |
// ----------------------------------------------------------------------------- |
|
3578 |
// |
|
3579 |
CXnControlAdapterImpl::CXnControlAdapterImpl( CXnNodePluginIf& aNode ) |
|
3580 |
: iNode( aNode ), |
|
3581 |
iBackgrondInitialized ( EFalse ), |
|
3582 |
iBorderInitialized ( EFalse ) |
|
3583 |
{ |
|
3584 |
} |
|
3585 |
||
3586 |
// ----------------------------------------------------------------------------- |
|
3587 |
// CXnControlAdapterImpl::SetComponent |
|
3588 |
// Sets component object to adapter. |
|
3589 |
// ----------------------------------------------------------------------------- |
|
3590 |
// |
|
3591 |
void CXnControlAdapterImpl::SetComponent( CXnComponent* aComponent ) |
|
3592 |
{ |
|
3593 |
iComponent = aComponent; |
|
3594 |
} |
|
3595 |
||
3596 |
// ----------------------------------------------------------------------------- |
|
3597 |
// CXnControlAdapterImpl::Component |
|
3598 |
// Gets component object from adapter. |
|
3599 |
// ----------------------------------------------------------------------------- |
|
3600 |
// |
|
3601 |
CXnComponent* CXnControlAdapterImpl::Component() |
|
3602 |
{ |
|
3603 |
return iComponent; |
|
3604 |
} |
|
3605 |
||
3606 |
// ----------------------------------------------------------------------------- |
|
3607 |
// CXnControlAdapterImpl::Component |
|
3608 |
// Gets component object from adapter. |
|
3609 |
// ----------------------------------------------------------------------------- |
|
3610 |
// |
|
3611 |
CXnComponent* CXnControlAdapterImpl::Component() const |
|
3612 |
{ |
|
3613 |
return iComponent; |
|
3614 |
} |
|
3615 |
||
3616 |
// ----------------------------------------------------------------------------- |
|
3617 |
// CXnControlAdapterImpl::OfferKeyEventL |
|
3618 |
// Handles key events. |
|
3619 |
// ----------------------------------------------------------------------------- |
|
3620 |
// |
|
3621 |
TKeyResponse CXnControlAdapterImpl::OfferKeyEventL( |
|
3622 |
const TKeyEvent& aKeyEvent, |
|
3623 |
TEventCode aType ) |
|
3624 |
{ |
|
3625 |
CXnNode* node( &iNode.Node() ); |
|
3626 |
||
3627 |
// Need to get softkey nodes |
|
3628 |
CXnUiEngine* engine( node->UiEngine() ); |
|
3629 |
||
3630 |
CXnNode* menuBar( engine->MenuBarNode() ); |
|
3631 |
||
3632 |
CXnNode* temp( node ); |
|
3633 |
||
3634 |
for ( ; temp; temp = temp->Parent() ) |
|
3635 |
{ |
|
3636 |
if ( temp == menuBar ) |
|
3637 |
{ |
|
3638 |
// This is softkey node |
|
3639 |
XnMenuInterface::MXnMenuInterface* menuIf( NULL ); |
|
3640 |
XnComponentInterface::MakeInterfaceL( menuIf, menuBar->AppIfL() ); |
|
3641 |
||
3642 |
if ( menuIf ) |
|
3643 |
{ |
|
3644 |
CXnNodePluginIf* eventNode( menuIf->KeyEventNode() ); |
|
3645 |
||
3646 |
if ( eventNode ) |
|
3647 |
{ |
|
3648 |
node = &eventNode->Node(); |
|
3649 |
} |
|
3650 |
} |
|
3651 |
||
3652 |
break; |
|
3653 |
} |
|
3654 |
} |
|
3655 |
||
3656 |
if ( !node ) |
|
3657 |
{ |
|
3658 |
return EKeyWasNotConsumed; |
|
3659 |
} |
|
3660 |
||
3661 |
if ( aKeyEvent.iScanCode == EStdKeyDevice0 || // RSK |
|
3662 |
aKeyEvent.iScanCode == EStdKeyDevice1 || // LSK |
|
3663 |
aKeyEvent.iScanCode == EStdKeyDevice3 || // MSK |
|
3664 |
aKeyEvent.iCode == EKeyEnter ) |
|
3665 |
{ |
|
3666 |
if ( aType == EEventKeyDown ) |
|
3667 |
{ |
|
3668 |
iLongtap = EFalse; |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3669 |
|
34 | 3670 |
_LIT8( KDown, "3" ); // EEventKeyDown == 3 |
3671 |
||
3672 |
CXnNode* keydown( BuildTriggerNodeL( *engine, |
|
3673 |
XnPropertyNames::action::trigger::name::KActivate, |
|
3674 |
XnPropertyNames::action::trigger::name::keyevent::KEventType, KDown ) ); |
|
3675 |
CleanupStack::PushL( keydown ); |
|
3676 |
||
3677 |
node->ReportXuikonEventL( *keydown ); |
|
3678 |
||
3679 |
CleanupStack::PopAndDestroy( keydown ); |
|
3680 |
} |
|
3681 |
else if( aType == EEventKey ) |
|
3682 |
{ |
|
3683 |
if ( aKeyEvent.iRepeats == 0 ) |
|
3684 |
{ |
|
3685 |
if ( !HasHoldTrigger( node->DomNode() ) ) |
|
3686 |
{ |
|
3687 |
// If node doesn't define hold trigger, then report activate |
|
3688 |
// immediately. Otherwise activate is triggered with keyup event |
|
3689 |
node->SetStateL( |
|
3690 |
XnPropertyNames::style::common::KActive ); |
|
3691 |
} |
|
3692 |
} |
|
3693 |
else |
|
3694 |
{ |
|
3695 |
CXnNode* hold( BuildTriggerNodeL( *engine, |
|
3696 |
XnPropertyNames::action::trigger::name::KHold ) ); |
|
3697 |
CleanupStack::PushL( hold ); |
|
3698 |
||
3699 |
node->ReportXuikonEventL( *hold ); |
|
3700 |
||
3701 |
CleanupStack::PopAndDestroy( hold ); |
|
3702 |
||
3703 |
iLongtap = ETrue; |
|
3704 |
} |
|
3705 |
} |
|
3706 |
||
3707 |
else if ( aType == EEventKeyUp ) |
|
3708 |
{ |
|
3709 |
if ( !iLongtap ) |
|
3710 |
{ |
|
3711 |
if ( HasHoldTrigger( node->DomNode() ) ) |
|
3712 |
{ |
|
3713 |
// Hold trigger defined, report activate event here |
|
3714 |
node->SetStateL( |
|
3715 |
XnPropertyNames::style::common::KActive ); |
|
3716 |
} |
|
3717 |
else |
|
3718 |
{ |
|
3719 |
_LIT8( KUp, "2" ); // EEventKeyUp == 2 |
|
3720 |
||
3721 |
CXnNode* keyup( BuildTriggerNodeL( *engine, |
|
3722 |
XnPropertyNames::action::trigger::name::KActivate, |
|
3723 |
XnPropertyNames::action::trigger::name::keyevent::KEventType, KUp ) ); |
|
3724 |
CleanupStack::PushL( keyup ); |
|
3725 |
||
3726 |
node->ReportXuikonEventL( *keyup ); |
|
3727 |
||
3728 |
CleanupStack::PopAndDestroy( keyup ); |
|
3729 |
} |
|
3730 |
} |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3731 |
|
34 | 3732 |
iLongtap = EFalse; |
3733 |
} |
|
3734 |
} |
|
3735 |
else |
|
3736 |
{ |
|
3737 |
// Other than softkey node |
|
3738 |
node->OfferKeyEventL( aKeyEvent, aType ); |
|
3739 |
} |
|
3740 |
||
3741 |
CXnNode* viewNode( engine->ActiveView() ); |
|
3742 |
||
3743 |
if ( viewNode && node != viewNode ) |
|
3744 |
{ |
|
3745 |
viewNode->OfferKeyEventL( aKeyEvent, aType ); |
|
3746 |
} |
|
3747 |
||
3748 |
return EKeyWasConsumed; |
|
3749 |
} |
|
3750 |
||
3751 |
// ----------------------------------------------------------------------------- |
|
3752 |
// CXnControlAdapterImpl::HandleLongTapEventL |
|
3753 |
// Handles the long tap events. |
|
3754 |
// ----------------------------------------------------------------------------- |
|
3755 |
// |
|
3756 |
void CXnControlAdapterImpl::HandleLongTapEventL( |
|
3757 |
const TPoint& /*aPenEventLocation*/, const TPoint& aPenEventScreenLocation ) |
|
3758 |
{ |
|
3759 |
CXnNode* node( &iNode.Node() ); |
|
3760 |
||
3761 |
CXnUiEngine* engine( node->UiEngine() ); |
|
3762 |
||
3763 |
TBool menuBar( node == engine->MenuBarNode() ); |
|
3764 |
||
3765 |
if ( menuBar ) |
|
3766 |
{ |
|
3767 |
// Need to update node to match to the real softkey node |
|
3768 |
node = SoftkeyNode( engine->MenuBarNode(), aPenEventScreenLocation ); |
|
3769 |
} |
|
3770 |
||
3771 |
if ( node ) |
|
3772 |
{ |
|
3773 |
CXnProperty* prop( node->GetPropertyL( |
|
3774 |
XnPropertyNames::common::KLongTap ) ); |
|
3775 |
||
3776 |
if ( prop && prop->StringValue() == XnPropertyNames::KTrue ) |
|
3777 |
{ |
|
3778 |
CXnUiEngine* engine( node->UiEngine() ); |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3779 |
CXnAppUiAdapter& appui( engine->AppUiAdapter() ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3780 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3781 |
appui.ViewAdapter().CloseAllPopupsL(); |
34 | 3782 |
|
3783 |
appui.HideFocus(); |
|
3784 |
||
3785 |
if ( !menuBar ) |
|
3786 |
{ |
|
3787 |
CXnViewControlAdapter* control = static_cast< CXnViewControlAdapter* >( |
|
3788 |
appui.ViewManager().ActiveViewData().ViewNode()->Control() ); |
|
3789 |
||
3790 |
control->ResetGrabbing(); |
|
3791 |
||
3792 |
#ifdef RD_TACTILE_FEEDBACK |
|
3793 |
MTouchFeedback* feedback( MTouchFeedback::Instance() ); |
|
3794 |
||
3795 |
if ( feedback ) |
|
3796 |
{ |
|
3797 |
feedback->InstantFeedback( iAdapter, ETouchFeedbackBasic, |
|
3798 |
ETouchFeedbackVibra, TPointerEvent() ); |
|
3799 |
||
3800 |
} |
|
3801 |
#endif |
|
3802 |
} |
|
3803 |
||
3804 |
// Indicate long tap has taken place |
|
3805 |
iLongtap = ETrue; |
|
3806 |
||
3807 |
CXnNode* hold = BuildTriggerNodeL( *engine, |
|
3808 |
XnPropertyNames::action::trigger::name::KHold ); |
|
3809 |
||
3810 |
CleanupStack::PushL( hold ); |
|
3811 |
||
3812 |
node->ReportXuikonEventL( *hold ); |
|
3813 |
||
3814 |
CleanupStack::PopAndDestroy( hold ); |
|
3815 |
} |
|
3816 |
} |
|
3817 |
} |
|
3818 |
||
3819 |
// ----------------------------------------------------------------------------- |
|
3820 |
// CXnControlAdapterImpl::IsDragThresholdExceeded |
|
3821 |
// Checks if drag threshold is exceeded |
|
3822 |
// ----------------------------------------------------------------------------- |
|
3823 |
// |
|
3824 |
TBool CXnControlAdapterImpl::IsDragThresholdExceeded( const TPoint& aPoint ) |
|
3825 |
{ |
|
3826 |
TBool ret = EFalse; |
|
3827 |
TPoint distance = aPoint - iButtonDownStartPoint; |
|
3828 |
if ( Abs( distance.iX ) >= KDragThreshold || |
|
3829 |
Abs( distance.iY ) >= KDragThreshold ) |
|
3830 |
{ |
|
3831 |
ret = ETrue; |
|
3832 |
} |
|
3833 |
return ret; |
|
3834 |
} |
|
3835 |
||
3836 |
// ----------------------------------------------------------------------------- |
|
3837 |
// CXnControlAdapterImpl::HandlePointerEventL |
|
3838 |
// Handle pointer events |
|
3839 |
// ----------------------------------------------------------------------------- |
|
3840 |
// |
|
3841 |
TBool CXnControlAdapterImpl::HandlePointerEventL( |
|
3842 |
const TPointerEvent& aPointerEvent ) |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3843 |
{ |
34 | 3844 |
const TPointerEvent& event( aPointerEvent ); |
3845 |
||
3846 |
CXnNode* node( &iNode.Node() ); |
|
3847 |
CXnUiEngine* engine( node->UiEngine() ); |
|
3848 |
||
3849 |
if ( !engine->IsPartialInputActive() ) |
|
3850 |
{ |
|
3851 |
InitializeGestureL( aPointerEvent ); |
|
3852 |
} |
|
3853 |
else |
|
3854 |
{ |
|
3855 |
// reset destination |
|
3856 |
iGestureDestination = NULL; |
|
3857 |
} |
|
3858 |
||
3859 |
TBool menuBar( node == engine->MenuBarNode() ); |
|
3860 |
||
3861 |
if ( menuBar ) |
|
3862 |
{ |
|
3863 |
// Need to update node to match to the real softkey node |
|
3864 |
node = SoftkeyNode( engine->MenuBarNode(), event.iParentPosition ); |
|
3865 |
||
3866 |
if ( !node ) |
|
3867 |
{ |
|
3868 |
// No softkey node found, consume event |
|
3869 |
return ETrue; |
|
3870 |
} |
|
3871 |
} |
|
3872 |
else if ( iSuppressor && |
|
3873 |
iSuppressor->SuppressPointerEvent( aPointerEvent ) ) |
|
3874 |
{ |
|
3875 |
// if view does not handle swipe we have to pass event to children |
|
3876 |
return ( iGestureDestination == node ); |
|
3877 |
} |
|
3878 |
||
3879 |
CAknLongTapDetector* detector( iAdapter->LongTapDetector() ); |
|
3880 |
||
3881 |
if ( ( detector && ( !engine->IsPartialInputActive() || |
|
3882 |
event.iType == TPointerEvent::EButton1Up ) ) ) |
|
3883 |
{ |
|
3884 |
if ( menuBar ) |
|
3885 |
{ |
|
3886 |
// CXnMenuAdapter owns the longtap detector, but only |
|
3887 |
// softkey nodes can have longtap functionality, so |
|
3888 |
// need to check whether this softkey node has a longtap |
|
3889 |
// property defined |
|
3890 |
CXnProperty* prop( |
|
3891 |
node->GetPropertyL( XnPropertyNames::common::KLongTap ) ); |
|
3892 |
||
3893 |
if ( prop && prop->StringValue() == XnPropertyNames::KTrue ) |
|
3894 |
{ |
|
3895 |
iAdapter->SetLongTapDelays( KLongTapStartShortDelay, |
|
3896 |
KLongTapTimeShortDelay ); |
|
3897 |
detector->PointerEventL( event ); |
|
3898 |
} |
|
3899 |
} |
|
3900 |
else |
|
3901 |
{ |
|
3902 |
iAdapter->SetLongTapDelays( KLongTapStartLongDelay, |
|
3903 |
KLongTapTimeLongDelay ); |
|
3904 |
detector->PointerEventL( event ); |
|
3905 |
} |
|
3906 |
} |
|
3907 |
||
3908 |
CXnProperty* focusable( |
|
3909 |
node->GetPropertyL( XnPropertyNames::common::KFocusable ) ); |
|
3910 |
||
3911 |
if ( !menuBar && ( !focusable || |
|
3912 |
focusable->StringValue() == XnPropertyNames::KFalse ) ) |
|
3913 |
{ |
|
3914 |
iLongtap = EFalse; |
|
3915 |
||
3916 |
return EFalse; |
|
3917 |
} |
|
3918 |
||
3919 |
if ( event.iType == TPointerEvent::EButton1Down ) |
|
3920 |
{ |
|
3921 |
iLongtap = EFalse; |
|
3922 |
node->HideTooltipsL(); |
|
3923 |
||
3924 |
if ( !menuBar ) |
|
3925 |
{ |
|
3926 |
// save starting point |
|
3927 |
iButtonDownStartPoint = event.iPosition; |
|
3928 |
// Require focus to be shown |
|
3929 |
engine->AppUiAdapter().ShowFocus(); |
|
3930 |
||
3931 |
#ifdef RD_TACTILE_FEEDBACK |
|
3932 |
MTouchFeedback* feedback( MTouchFeedback::Instance() ); |
|
3933 |
||
3934 |
if ( feedback ) |
|
3935 |
{ |
|
3936 |
feedback->InstantFeedback( ETouchFeedbackBasic ); |
|
3937 |
} |
|
3938 |
#endif |
|
3939 |
node->SetStateL( |
|
3940 |
XnPropertyNames::style::common::KFocus, |
|
3941 |
XnEventSource::EStylus ); |
|
3942 |
} |
|
3943 |
} |
|
3944 |
else if ( event.iType == TPointerEvent::EDrag ) |
|
3945 |
{ |
|
3946 |
if ( node->IsStateSet( XnPropertyNames::style::common::KFocus ) ) |
|
3947 |
{ |
|
3948 |
if ( IsDragThresholdExceeded( event.iPosition ) ) |
|
3949 |
{ |
|
3950 |
// Remove focus |
|
3951 |
node->UnsetStateL( |
|
3952 |
XnPropertyNames::style::common::KFocus ); |
|
3953 |
} |
|
3954 |
} |
|
3955 |
} |
|
3956 |
else if ( event.iType == TPointerEvent::EButton1Up ) |
|
3957 |
{ |
|
3958 |
if ( !iLongtap ) |
|
3959 |
{ |
|
3960 |
if ( menuBar ) |
|
3961 |
{ |
|
3962 |
node->SetStateL( XnPropertyNames::style::common::KActive ); |
|
3963 |
} |
|
3964 |
else if ( node->IsStateSet( XnPropertyNames::style::common::KFocus ) ) |
|
3965 |
{ |
|
3966 |
#ifdef RD_TACTILE_FEEDBACK |
|
3967 |
MTouchFeedback* feedback( MTouchFeedback::Instance() ); |
|
3968 |
||
3969 |
if ( feedback ) |
|
3970 |
{ |
|
3971 |
feedback->InstantFeedback( iAdapter, ETouchFeedbackBasic, |
|
3972 |
ETouchFeedbackVibra, |
|
3973 |
aPointerEvent ); |
|
3974 |
} |
|
3975 |
#endif |
|
3976 |
node->SetStateL( XnPropertyNames::style::common::KActive ); |
|
3977 |
} |
|
3978 |
} |
|
3979 |
||
3980 |
// Remove focus |
|
3981 |
engine->AppUiAdapter().HideFocus(); |
|
3982 |
} |
|
3983 |
||
3984 |
return EFalse; |
|
3985 |
} |
|
3986 |
||
3987 |
// ----------------------------------------------------------------------------- |
|
3988 |
// CXnControlAdapterImpl::DoDrawL |
|
3989 |
// Leaving draw function. |
|
3990 |
// ----------------------------------------------------------------------------- |
|
3991 |
// |
|
3992 |
void CXnControlAdapterImpl::DoDrawL( const TRect& aRect, CWindowGc& aGc ) const |
|
3993 |
{ |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3994 |
if( !iComponent ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3995 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3996 |
return; |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
3997 |
} |
34 | 3998 |
CXnNode& node = iComponent->Node()->Node(); |
3999 |
||
4000 |
DrawBordersL( aRect, node, aGc ); |
|
4001 |
||
4002 |
const_cast< CXnControlAdapterImpl* >( this )->DrawBackgroundDataL( aRect, node, aGc ); |
|
4003 |
||
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4004 |
if ( node.IsStateSet( XnPropertyNames::style::common::KFocus ) ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4005 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4006 |
CXnProperty* prop( node.GetPropertyL( |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4007 |
XnPropertyNames::common::KFocusAppearance ) ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4008 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4009 |
if ( prop && prop->StringValue() == XnPropertyNames::KNone ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4010 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4011 |
// Current element refuses to draw focus appearance |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4012 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4013 |
else |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4014 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4015 |
DrawFocusAppearance( node, aGc ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4016 |
} |
34 | 4017 |
} |
4018 |
||
4019 |
// Draw plus sign for empty plugins in edit mode. |
|
4020 |
if( node.UiEngine()->EditMode()->EditState() ) |
|
4021 |
{ |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4022 |
CXnControlAdapterImpl* adapter = const_cast< CXnControlAdapterImpl* >( this ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4023 |
TBool editstate = iNode.IsEditState(); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4024 |
|
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4025 |
if( editstate ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4026 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4027 |
adapter->DrawPlusSign( node, aGc ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4028 |
} |
34 | 4029 |
} |
4030 |
||
4031 |
if ( iAnimation ) |
|
4032 |
{ |
|
4033 |
TRect rect = iComponent->Node()->Rect(); |
|
4034 |
iAnimation->Render( aGc, rect ); |
|
4035 |
} |
|
4036 |
||
4037 |
if ( iBorderBitmap ) |
|
4038 |
{ |
|
4039 |
DrawBorderImagesL( |
|
4040 |
aRect, node, aGc, iBorderBitmap, |
|
4041 |
iBorderBitmapDividerTop, iBorderBitmapDividerRight, |
|
4042 |
iBorderBitmapDividerBottom, iBorderBitmapDividerLeft ); |
|
4043 |
} |
|
4044 |
||
4045 |
DrawContentImageL( aGc ); |
|
4046 |
} |
|
4047 |
||
4048 |
// ----------------------------------------------------------------------------- |
|
4049 |
// CXnControlAdapterImpl::DrawBackgroundDataL |
|
4050 |
// Draws the background (color and image) |
|
4051 |
// ----------------------------------------------------------------------------- |
|
4052 |
// |
|
4053 |
void CXnControlAdapterImpl::DrawBackgroundDataL( |
|
4054 |
const TRect& aRect, |
|
4055 |
CXnNode& aNode, |
|
4056 |
CWindowGc& aGc ) |
|
4057 |
{ |
|
4058 |
if( aNode.UiEngine()->EditMode()->EditState() ) |
|
4059 |
{ |
|
4060 |
DrawEditModeBgData( aNode, aGc ); |
|
4061 |
return; |
|
4062 |
} |
|
4063 |
||
4064 |
if ( !iBackgroundBitmap && iBackgroundMask ) |
|
4065 |
// mask, but no bitmap: draw masked color (if available) |
|
4066 |
{ |
|
4067 |
DrawTransparentColorL( aNode, aGc, iBackgroundMask ); |
|
4068 |
} |
|
4069 |
else if ( !iBackgroundBitmap || !iBackgroundMask ) |
|
4070 |
// no mask or no bitmap: draw color (if available) |
|
4071 |
{ |
|
4072 |
DrawBackgroundColorL( aRect, aNode, aGc ); |
|
4073 |
} |
|
4074 |
||
4075 |
CXnProperty* colorProperty( aNode.BackgroundColorL() ); |
|
4076 |
DrawBackgroundSkinL( aNode, iBackgroundMask, aGc, colorProperty ); |
|
4077 |
||
4078 |
if ( !iBackgroundBitmap ) |
|
4079 |
{ |
|
4080 |
return; |
|
4081 |
} |
|
4082 |
||
4083 |
CXnProperty* pathProperty( aNode.BackgroundImageL() ); |
|
4084 |
||
4085 |
if ( pathProperty && pathProperty->StringValue() != KNullDesC8 ) |
|
4086 |
{ |
|
4087 |
if ( iBackgroundMask ) |
|
4088 |
{ |
|
4089 |
// draw transparent background image |
|
4090 |
DrawBackgroundImageL( aRect, aNode, aGc, iBackgroundBitmap, iBackgroundMask ); |
|
4091 |
} |
|
4092 |
else |
|
4093 |
{ |
|
4094 |
// draw background image without mask |
|
4095 |
DrawBackgroundImageL( aRect, aNode, aGc, iBackgroundBitmap, NULL ); |
|
4096 |
} |
|
4097 |
} |
|
4098 |
} |
|
4099 |
||
4100 |
// ----------------------------------------------------------------------------- |
|
4101 |
// CXnControlAdapterImpl::DrawEditModeBgDataL |
|
4102 |
// |
|
4103 |
// ----------------------------------------------------------------------------- |
|
4104 |
// |
|
4105 |
void CXnControlAdapterImpl::DrawEditModeBgData( |
|
4106 |
CXnNode& aNode, |
|
4107 |
CWindowGc& aGc ) |
|
4108 |
{ |
|
4109 |
// Draw rastered background for plugins |
|
4110 |
const TDesC8& widgetType = aNode.DomNode()->Name(); |
|
4111 |
if( widgetType == XnPropertyNames::KPlugin ) |
|
4112 |
{ |
|
4113 |
TRect rect = aNode.PaddingRect(); |
|
4114 |
DrawBackgroundSkin( KAknsIIDQgnHomeEditBgWidget, aGc, rect ); |
|
4115 |
} |
|
4116 |
} |
|
4117 |
||
4118 |
// ----------------------------------------------------------------------------- |
|
4119 |
// CXnControlAdapterImpl::DrawPlusSign |
|
4120 |
// |
|
4121 |
// ----------------------------------------------------------------------------- |
|
4122 |
// |
|
4123 |
void CXnControlAdapterImpl::DrawPlusSign( CXnNode& aNode, CWindowGc& aGc ) |
|
4124 |
{ |
|
4125 |
const TDesC8& widgetType = aNode.DomNode()->Name(); |
|
4126 |
if( widgetType == XnPropertyNames::KPlugin ) |
|
4127 |
{ |
|
4128 |
CXnPluginData* data( aNode.UiEngine()->ViewManager()->ActiveViewData().Plugin( &aNode ) ); |
|
4129 |
if( data && !data->Occupied() ) // Empty widget |
|
4130 |
{ |
|
4131 |
// Draw + -icon |
|
4132 |
// Make rect as 50% of the widget's height. |
|
4133 |
// It needs to be square in order to keep aspect ratio. |
|
4134 |
TRect rect = aNode.PaddingRect(); |
|
4135 |
TInt w = rect.Width(); |
|
4136 |
TInt h = rect.Height(); |
|
4137 |
rect.Shrink( ( w - h * 0.5 ) * 0.5, h * 0.25 ); |
|
4138 |
DrawBackgroundSkin( KAknsIIDQgnHomeAdd, aGc, rect ); |
|
4139 |
} |
|
4140 |
} |
|
4141 |
} |
|
4142 |
||
4143 |
// ----------------------------------------------------------------------------- |
|
4144 |
// CXnControlAdapterImpl::DrawTransparentColorL |
|
4145 |
// Draws masked background by RGB color. |
|
4146 |
// ----------------------------------------------------------------------------- |
|
4147 |
// |
|
4148 |
void CXnControlAdapterImpl::DrawTransparentColorL( |
|
4149 |
CXnNode& aNode, |
|
4150 |
CWindowGc& aGc, |
|
4151 |
CFbsBitmap* aMask ) |
|
4152 |
{ |
|
4153 |
CXnProperty* colorProperty( aNode.BackgroundColorL() ); |
|
4154 |
||
4155 |
if ( colorProperty ) |
|
4156 |
{ |
|
4157 |
// check value type |
|
4158 |
CXnDomPropertyValue* value = |
|
4159 |
static_cast< CXnDomPropertyValue* >( |
|
4160 |
colorProperty->Property()->PropertyValueList().Item( 0 ) ); |
|
4161 |
||
4162 |
if ( value->PrimitiveValueType() == CXnDomPropertyValue::ERgbColor ) |
|
4163 |
{ |
|
4164 |
CFbsBitmap* bitmap( NULL ); |
|
4165 |
TRgb rgb( value->RgbColorValueL() ); |
|
4166 |
bitmap = CreateBitmapFromColorL( aMask->SizeInPixels(), rgb ); |
|
4167 |
||
4168 |
aGc.DrawBitmapMasked( |
|
4169 |
aNode.PaddingRect(), |
|
4170 |
bitmap, |
|
4171 |
TRect( TPoint( 0, 0 ), bitmap->SizeInPixels() ), |
|
4172 |
aMask, |
|
4173 |
EFalse ); |
|
4174 |
||
4175 |
delete bitmap; |
|
4176 |
} |
|
4177 |
} |
|
4178 |
} |
|
4179 |
||
4180 |
// ----------------------------------------------------------------------------- |
|
4181 |
// CXnControlAdapterImpl::DrawBackgroundSkin |
|
4182 |
// Draws a skin item to the given rect |
|
4183 |
// ----------------------------------------------------------------------------- |
|
4184 |
// |
|
4185 |
void CXnControlAdapterImpl::DrawBackgroundSkin(const TAknsItemID& aSkinId, |
|
4186 |
CWindowGc& aGc, TRect aRect) |
|
4187 |
{ |
|
4188 |
TRect shrunkRect = aRect; |
|
4189 |
||
4190 |
shrunkRect.Shrink( |
|
4191 |
KSkinGfxInnerRectShrink, |
|
4192 |
KSkinGfxInnerRectShrink ); |
|
4193 |
||
4194 |
AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), aGc, |
|
4195 |
aRect, shrunkRect, aSkinId, KAknsIIDDefault ); |
|
4196 |
} |
|
4197 |
||
4198 |
// ----------------------------------------------------------------------------- |
|
4199 |
// CXnControlAdapterImpl::DrawBackgroundSkinL |
|
4200 |
// Draws a skin item to the padding rect |
|
4201 |
// ----------------------------------------------------------------------------- |
|
4202 |
// |
|
4203 |
void CXnControlAdapterImpl::DrawBackgroundSkinL(CXnNode& aNode, |
|
4204 |
CFbsBitmap* aMask, CWindowGc& aGc, CXnProperty* aBgColor, |
|
4205 |
TRect aRect) |
|
4206 |
{ |
|
4207 |
if( aRect == TRect::EUninitialized ) |
|
4208 |
{ |
|
4209 |
aRect = aNode.PaddingRect(); |
|
4210 |
} |
|
4211 |
||
4212 |
CXnProperty* colorProperty( aBgColor ); |
|
4213 |
if ( colorProperty ) |
|
4214 |
{ |
|
4215 |
HBufC* skinID = colorProperty->StringValueL(); |
|
4216 |
CleanupStack::PushL( skinID ); |
|
4217 |
||
4218 |
if ( skinID->Length() != 0 ) |
|
4219 |
{ |
|
4220 |
TAknsItemID itemID; |
|
4221 |
StripQuotes( skinID ); |
|
4222 |
||
4223 |
if ( CXnUtils::ResolveSkinItemIDL( *skinID, itemID ) ) |
|
4224 |
{ |
|
4225 |
if ( aMask ) // If there is a mask, draw masked. |
|
4226 |
{ |
|
4227 |
TRect paddingRect = aRect; |
|
4228 |
TRect outerRect = TRect( paddingRect.Size() ); |
|
4229 |
TRect innerRect = outerRect; |
|
4230 |
innerRect.Shrink( |
|
4231 |
KSkinGfxInnerRectShrink, |
|
4232 |
KSkinGfxInnerRectShrink ); |
|
4233 |
||
4234 |
if ( !iBackgroundBitmap ) |
|
4235 |
{ |
|
4236 |
iBackgroundBitmap = new ( ELeave ) CFbsBitmap; |
|
4237 |
iBackgroundBitmap->Create( aMask->SizeInPixels(), |
|
4238 |
aGc.Device()->DisplayMode() ); |
|
4239 |
||
4240 |
CFbsBitmapDevice* device = |
|
4241 |
CFbsBitmapDevice::NewL( iBackgroundBitmap ); |
|
4242 |
CleanupStack::PushL( device ); |
|
4243 |
||
4244 |
CBitmapContext* bc( NULL ); |
|
4245 |
||
4246 |
User::LeaveIfError( device->CreateBitmapContext( bc ) ); |
|
4247 |
CleanupStack::PushL( bc ); |
|
4248 |
||
4249 |
CAknsFrameBackgroundControlContext* frameContext = |
|
4250 |
CAknsFrameBackgroundControlContext::NewL( |
|
4251 |
itemID, outerRect, innerRect, EFalse ); |
|
4252 |
CleanupStack::PushL( frameContext ); |
|
4253 |
||
4254 |
AknsDrawUtils::Background( AknsUtils::SkinInstance(), |
|
4255 |
frameContext, NULL, |
|
4256 |
static_cast< CWindowGc& >( *bc ), |
|
4257 |
outerRect, KAknsDrawParamNoClearUnderImage ); |
|
4258 |
||
4259 |
CleanupStack::PopAndDestroy( 3, device ); |
|
4260 |
} |
|
4261 |
||
4262 |
aGc.DrawBitmapMasked( paddingRect, |
|
4263 |
iBackgroundBitmap, |
|
4264 |
TRect(TPoint(0, 0), iBackgroundBitmap->SizeInPixels()), |
|
4265 |
aMask, |
|
4266 |
ETrue ); |
|
4267 |
} |
|
4268 |
else // draw background skin graphics without mask |
|
4269 |
{ |
|
4270 |
TRect paddingRect = aRect; |
|
4271 |
TRect shrunkRect = paddingRect; |
|
4272 |
||
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4273 |
if ( itemID == KAknsIIDQsnFrPopupSub ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4274 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4275 |
shrunkRect.Shrink( |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4276 |
KSkinGfxInnerRectShrink + 2, |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4277 |
KSkinGfxInnerRectShrink + 2 ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4278 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4279 |
else |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4280 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4281 |
shrunkRect.Shrink( |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4282 |
KSkinGfxInnerRectShrink, |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4283 |
KSkinGfxInnerRectShrink ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4284 |
} |
34 | 4285 |
|
4286 |
CAknsFrameBackgroundControlContext* frameContext = |
|
4287 |
CAknsFrameBackgroundControlContext::NewL( |
|
4288 |
itemID, paddingRect, shrunkRect, EFalse ); |
|
4289 |
||
4290 |
CleanupStack::PushL( frameContext ); |
|
4291 |
||
4292 |
AknsDrawUtils::Background( AknsUtils::SkinInstance(), |
|
4293 |
frameContext, |
|
4294 |
NULL, |
|
4295 |
aGc, |
|
4296 |
paddingRect, |
|
4297 |
KAknsDrawParamNoClearUnderImage ); |
|
4298 |
||
4299 |
CleanupStack::PopAndDestroy( frameContext ); |
|
4300 |
} |
|
4301 |
} |
|
4302 |
} |
|
4303 |
||
4304 |
CleanupStack::PopAndDestroy( skinID ); |
|
4305 |
} |
|
4306 |
} |
|
4307 |
||
4308 |
// ----------------------------------------------------------------------------- |
|
4309 |
// DrawBackgroundImageL |
|
4310 |
// Draws the background image |
|
4311 |
// ----------------------------------------------------------------------------- |
|
4312 |
// |
|
4313 |
void CXnControlAdapterImpl::DrawBackgroundImageL( |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4314 |
const TRect& /*aRect*/, |
34 | 4315 |
CXnNode& aNode, |
4316 |
CWindowGc& aGc, |
|
4317 |
CFbsBitmap* aBitmap, |
|
4318 |
CFbsBitmap* aMask ) |
|
4319 |
{ |
|
4320 |
if ( !aBitmap ) |
|
4321 |
{ |
|
4322 |
return; |
|
4323 |
} |
|
4324 |
||
4325 |
TRect rect = aNode.PaddingRect(); |
|
4326 |
TBool scaleImage = EFalse; |
|
4327 |
||
4328 |
if (!GetBackgroundSizeFromPropertyL( rect, aNode, aBitmap, scaleImage ) ) |
|
4329 |
{ |
|
4330 |
return; |
|
4331 |
} |
|
4332 |
if ( AknIconUtils::IsMifIcon( aBitmap ) ) |
|
4333 |
{ |
|
4334 |
if ( scaleImage ) |
|
4335 |
{ |
|
4336 |
AknIconUtils::SetSize( aBitmap, rect.Size(), EAspectRatioNotPreserved ); |
|
4337 |
} |
|
4338 |
else |
|
4339 |
{ |
|
4340 |
AknIconUtils::SetSize( aBitmap, rect.Size(), EAspectRatioPreserved ); |
|
4341 |
} |
|
4342 |
} |
|
4343 |
TRect imageRect = rect; |
|
4344 |
rect = aNode.PaddingRect(); |
|
4345 |
TBool heightSet = EFalse; |
|
4346 |
TBool backgroundPosFound = EFalse; |
|
4347 |
TRAP_IGNORE( backgroundPosFound = GetBackgroundPositionFromPropertyL( |
|
4348 |
aNode, scaleImage, rect, imageRect, aBitmap, heightSet ); ); |
|
4349 |
if ( !backgroundPosFound ) |
|
4350 |
{ |
|
4351 |
return; |
|
4352 |
} |
|
4353 |
if ( !heightSet ) |
|
4354 |
{ |
|
4355 |
rect.Move( 0, rect.Height() / 2 ); |
|
4356 |
if ( scaleImage ) |
|
4357 |
{ |
|
4358 |
rect.Move( 0, -imageRect.Height() / 2 ); |
|
4359 |
} |
|
4360 |
else |
|
4361 |
{ |
|
4362 |
rect.Move( 0, -aBitmap->SizeInPixels().iHeight / 2 ); |
|
4363 |
} |
|
4364 |
} |
|
4365 |
TRect tmpRect = aNode.PaddingRect(); |
|
4366 |
LimitRectToPaddingRect( aNode, rect ); |
|
4367 |
TBool repeatX = EFalse; |
|
4368 |
TBool repeatY = EFalse; |
|
4369 |
TBool spaceX = EFalse; |
|
4370 |
TBool spaceY = EFalse; |
|
4371 |
TRAP_IGNORE( GetBackroundRepeatValuesL( aNode, repeatX, repeatY, spaceX, spaceY ) ); |
|
4372 |
TRect bitmapRect = TRect( |
|
4373 |
TPoint( 0, 0 ), |
|
4374 |
TPoint( aBitmap->SizeInPixels().iWidth, aBitmap->SizeInPixels().iHeight ) ); |
|
4375 |
TInt xRepeatCount = 0; |
|
4376 |
TInt yRepeatCount = 0; |
|
4377 |
TRect paddingRect = aNode.PaddingRect(); |
|
4378 |
if ( scaleImage ) |
|
4379 |
{ |
|
4380 |
if ( imageRect.Width() && imageRect.Height() ) |
|
4381 |
{ |
|
4382 |
xRepeatCount = paddingRect.Width() / imageRect.Width(); |
|
4383 |
yRepeatCount = paddingRect.Height() / imageRect.Height(); |
|
4384 |
} |
|
4385 |
} |
|
4386 |
else |
|
4387 |
{ |
|
4388 |
TSize size = aBitmap->SizeInPixels(); |
|
4389 |
if ( size.iWidth == 0 || size.iHeight == 0 ) |
|
4390 |
{ |
|
4391 |
return; |
|
4392 |
} |
|
4393 |
xRepeatCount = paddingRect.Width() / size.iWidth; |
|
4394 |
yRepeatCount = paddingRect.Height() / size.iHeight; |
|
4395 |
} |
|
4396 |
||
4397 |
if ( xRepeatCount == 0 && yRepeatCount == 0 || |
|
4398 |
!repeatX && !repeatY && !spaceX && !spaceY ) |
|
4399 |
{ |
|
4400 |
TRect newRect = TRect( |
|
4401 |
rect.iTl, |
|
4402 |
TPoint( |
|
4403 |
rect.iTl.iX + imageRect.Width(), |
|
4404 |
rect.iTl.iY + imageRect.Height() ) ); |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4405 |
//aGc.SetClippingRect( aRect ); |
34 | 4406 |
|
4407 |
if ( aMask ) |
|
4408 |
{ |
|
4409 |
aGc.DrawBitmapMasked( newRect, |
|
4410 |
aBitmap, |
|
4411 |
TRect(TPoint(0, 0), aBitmap->SizeInPixels()), |
|
4412 |
aMask, |
|
4413 |
EFalse ); |
|
4414 |
} |
|
4415 |
else |
|
4416 |
{ |
|
4417 |
TRect newRect = TRect( |
|
4418 |
rect.iTl, |
|
4419 |
TPoint( |
|
4420 |
rect.iTl.iX + imageRect.Width(), |
|
4421 |
rect.iTl.iY + imageRect.Height() ) ); |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
4422 |
//aGc.SetClippingRect( aRect ); |
34 | 4423 |
|
4424 |
aGc.DrawBitmap( newRect, aBitmap, bitmapRect ); |
|
4425 |
} |
|
4426 |
||
4427 |
aGc.CancelClippingRect(); |
|
4428 |
||
4429 |
return; |
|
4430 |
} |
|
4431 |
||
4432 |
DrawRepeatedBackgroundImage( |
|
4433 |
aGc, |
|
4434 |
aNode, |
|
4435 |
rect, |
|
4436 |
imageRect, |
|
4437 |
bitmapRect, |
|
4438 |
aBitmap, |
|
4439 |
repeatX, |
|
4440 |
repeatY, |
|
4441 |
spaceX, |
|
4442 |
spaceY, |
|
4443 |
xRepeatCount, |
|
4444 |
yRepeatCount ); |
|
4445 |
} |
|
4446 |
||
4447 |
// ----------------------------------------------------------------------------- |
|
4448 |
// CXnControlAdapterImpl::Draw |
|
4449 |
// Draws the control |
|
4450 |
// ----------------------------------------------------------------------------- |
|
4451 |
// |
|
4452 |
void CXnControlAdapterImpl::Draw( const TRect& aRect ) const |
|
4453 |
{ |
|
4454 |
if ( iBlank ) |
|
4455 |
{ |
|
4456 |
return; |
|
4457 |
} |
|
4458 |
||
4459 |
CWindowGc& gc = iAdapter->SystemGc(); |
|
4460 |
//gc.SetClippingRect(aRect); |
|
4461 |
#ifdef _XN_DEBUG_ |
|
4462 |
CXnComponent* comp = Component(); |
|
4463 |
CXnNode& node = comp->Node()->Node(); |
|
4464 |
TRect contentRect = node.Rect(); |
|
4465 |
TRect marginRect = node.MarginRect(); |
|
4466 |
TRect paddingRect = node.PaddingRect(); |
|
4467 |
||
4468 |
gc.SetBrushStyle( CGraphicsContext::ENullBrush ); |
|
4469 |
gc.SetPenColor( KRgbBlue ); |
|
4470 |
gc.DrawRect( marginRect ); |
|
4471 |
gc.SetPenColor( KRgbGray ); |
|
4472 |
gc.DrawRect( paddingRect ); |
|
4473 |
gc.SetPenColor( KRgbRed ); |
|
4474 |
gc.DrawRect( contentRect ); |
|
4475 |
#endif |
|
4476 |
TRAP_IGNORE( DoDrawL( aRect, gc )); |
|
4477 |
//gc.CancelClippingRect(); |
|
4478 |
RPointerArray< CXnControlAdapter > sortedArray; |
|
4479 |
TBool needsSorting = EFalse; |
|
4480 |
for ( TInt count = iChildren.Count() - 1; count >= 0; --count ) |
|
4481 |
{ |
|
4482 |
needsSorting = ETrue; |
|
4483 |
CXnControlAdapter* child = iChildren[count]; |
|
4484 |
TRAP_IGNORE( InsertChildToSortedArrayL( sortedArray, child ) ); |
|
4485 |
} |
|
4486 |
if ( !needsSorting ) |
|
4487 |
{ |
|
4488 |
return; |
|
4489 |
} |
|
4490 |
SwapChildArrays( iChildren, sortedArray ); |
|
4491 |
} |
|
4492 |
||
4493 |
// ----------------------------------------------------------------------------- |
|
4494 |
// CXnControlAdapterImpl::Draw |
|
4495 |
// Draws the control |
|
4496 |
// ----------------------------------------------------------------------------- |
|
4497 |
// |
|
4498 |
void CXnControlAdapterImpl::Draw( const TRect& aRect, CWindowGc& aGc ) const |
|
4499 |
{ |
|
4500 |
if ( iBlank ) |
|
4501 |
{ |
|
4502 |
return; |
|
4503 |
} |
|
4504 |
||
4505 |
// aGc.SetClippingRect( aRect ); |
|
4506 |
#ifdef _XN_DEBUG_ |
|
4507 |
CXnComponent* comp = Component(); |
|
4508 |
CXnNode& node = comp->Node()->Node(); |
|
4509 |
TRect contentRect = node.Rect(); |
|
4510 |
TRect marginRect = node.MarginRect(); |
|
4511 |
TRect paddingRect = node.PaddingRect(); |
|
4512 |
aGc.SetBrushStyle( CGraphicsContext::ENullBrush ); |
|
4513 |
aGc.SetPenColor( KRgbBlue ); |
|
4514 |
aGc.DrawRect( marginRect ); |
|
4515 |
aGc.SetPenColor( KRgbGray ); |
|
4516 |
aGc.DrawRect( paddingRect ); |
|
4517 |
aGc.SetPenColor( KRgbRed ); |
|
4518 |
aGc.DrawRect( contentRect ); |
|
4519 |
#endif |
|
4520 |
TRAP_IGNORE( DoDrawL( aRect, aGc ) ); |
|
4521 |
// aGc.CancelClippingRect(); |
|
4522 |
} |
|
4523 |
||
4524 |
// ----------------------------------------------------------------------------- |
|
4525 |
// CXnControlAdapterImpl::ComponentControl |
|
4526 |
// Return a child control by index |
|
4527 |
// ----------------------------------------------------------------------------- |
|
4528 |
// |
|
4529 |
CCoeControl* CXnControlAdapterImpl::ComponentControl( TInt aIndex ) const |
|
4530 |
{ |
|
4531 |
return iChildren[aIndex]; |
|
4532 |
} |
|
4533 |
||
4534 |
// ----------------------------------------------------------------------------- |
|
4535 |
// CXnControlAdapterImpl::CountComponentControls |
|
4536 |
// Return count of children |
|
4537 |
// ----------------------------------------------------------------------------- |
|
4538 |
// |
|
4539 |
TInt CXnControlAdapterImpl::CountComponentControls() const |
|
4540 |
{ |
|
4541 |
return iChildren.Count(); |
|
4542 |
} |
|
4543 |
||
4544 |
// ----------------------------------------------------------------------------- |
|
4545 |
// CXnControlAdapterImpl::AppendChildL |
|
4546 |
// ----------------------------------------------------------------------------- |
|
4547 |
// |
|
4548 |
void CXnControlAdapterImpl::AppendChildL(CXnControlAdapter& aChild, CXnNode& aNode) |
|
4549 |
{ |
|
4550 |
if( !aChild.OwnsWindow() ) |
|
4551 |
{ |
|
4552 |
SetControlContext( aChild, aNode ); |
|
4553 |
if( iChildren.Append( &aChild ) != KErrNone ) |
|
4554 |
{ |
|
4555 |
User::Leave( KXnErrAppendingChildToControlAdapterFailed ); |
|
4556 |
} |
|
4557 |
aChild.SetContainerWindowL( *iAdapter ); |
|
4558 |
} |
|
4559 |
} |
|
4560 |
||
4561 |
||
4562 |
// ----------------------------------------------------------------------------- |
|
4563 |
// ConvertHslToRgb |
|
4564 |
// Converts a HSL color to RGB color |
|
4565 |
// ----------------------------------------------------------------------------- |
|
4566 |
// |
|
4567 |
static TRgb ConvertHslToRgb( |
|
4568 |
TInt aHue, TInt aSaturation, TInt aLightness ) |
|
4569 |
{ |
|
4570 |
TRgb rgb( 0, 0, 0 ); |
|
4571 |
TReal h( aHue ); |
|
4572 |
h /= 360; |
|
4573 |
TReal s( aSaturation ); |
|
4574 |
s /= 100; |
|
4575 |
TReal l( aLightness ); |
|
4576 |
l /= 100; |
|
4577 |
||
4578 |
if ( 0 == aSaturation ) |
|
4579 |
{ |
|
4580 |
rgb.SetRed( TInt( l * 255 ) ); |
|
4581 |
rgb.SetGreen( TInt( l * 255 ) ); |
|
4582 |
rgb.SetBlue( TInt( l * 255 ) ); |
|
4583 |
} |
|
4584 |
else |
|
4585 |
{ |
|
4586 |
TReal m1( 0 ); |
|
4587 |
TReal m2( 0 ); |
|
4588 |
||
4589 |
// l<=0.5: PUT l*(s+1) IN m2 |
|
4590 |
if ( aLightness < 0.5 ) |
|
4591 |
{ |
|
4592 |
m2 = l * ( s + 1.0 ); |
|
4593 |
} |
|
4594 |
// PUT l+s-l*s IN m2 |
|
4595 |
else |
|
4596 |
{ |
|
4597 |
m2 = l + s - ( l * s ); |
|
4598 |
} |
|
4599 |
||
4600 |
// PUT l*2-m2 IN m1 |
|
4601 |
m1 = l * 2.0 - m2; |
|
4602 |
||
4603 |
TReal helperH( h ); |
|
4604 |
TReal helperM1( m1 ); |
|
4605 |
TReal helperM2( m2 ); |
|
4606 |
||
4607 |
// calculate Red |
|
4608 |
helperH = h + ( 1.0 / 3.0 ); |
|
4609 |
||
4610 |
// IF h<0: PUT h+1 IN h |
|
4611 |
if ( helperH < 0 ) |
|
4612 |
{ |
|
4613 |
helperH += 1.0; |
|
4614 |
} |
|
4615 |
||
4616 |
// IF h>1: PUT h-1 IN h |
|
4617 |
else if ( helperH > 1 ) |
|
4618 |
{ |
|
4619 |
helperH -= 1.0; |
|
4620 |
} |
|
4621 |
else |
|
4622 |
{ |
|
4623 |
} |
|
4624 |
||
4625 |
TReal val( 0 ); |
|
4626 |
||
4627 |
// IF h*6<1: RETURN m1+(m2-m1)*h*6 |
|
4628 |
if ( ( helperH * 6 ) < 1 ) |
|
4629 |
{ |
|
4630 |
val = ( 255 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) ); |
|
4631 |
} |
|
4632 |
||
4633 |
// IF h*2<1: RETURN m2 ) |
|
4634 |
else if ( ( helperH * 2.0 ) < 1.0 ) |
|
4635 |
{ |
|
4636 |
val = ( 255.0 * helperM2 ); |
|
4637 |
} |
|
4638 |
||
4639 |
// IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6 |
|
4640 |
else if ( ( helperH * 3.0 ) < 2.0 ) |
|
4641 |
{ |
|
4642 |
val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * |
|
4643 |
( 2.0 / 3.0 - helperH ) * 6.0 ) ); |
|
4644 |
} |
|
4645 |
else |
|
4646 |
{ |
|
4647 |
val = 255.0 * helperM1; |
|
4648 |
} |
|
4649 |
TInt tmpVal = TInt( val + 0.5 ); |
|
4650 |
rgb.SetRed( ( tmpVal >= 0) ? tmpVal : -tmpVal ); |
|
4651 |
||
4652 |
// calculate Green |
|
4653 |
// PUT hue.to.rgb(m1, m2, h ) IN g |
|
4654 |
helperH = h; |
|
4655 |
helperM1 = m1; |
|
4656 |
helperM2 = m2; |
|
4657 |
||
4658 |
// IF h<0: PUT h+1 IN h |
|
4659 |
if ( helperH < 0 ) |
|
4660 |
{ |
|
4661 |
helperH += 1.0; |
|
4662 |
} |
|
4663 |
// IF h>1: PUT h-1 IN h |
|
4664 |
else if ( helperH > 1 ) |
|
4665 |
{ |
|
4666 |
helperH -= 1.0; |
|
4667 |
} |
|
4668 |
else |
|
4669 |
{ |
|
4670 |
} |
|
4671 |
||
4672 |
// IF h*6<1: RETURN m1+(m2-m1)*h*6 |
|
4673 |
if ( ( helperH * 6 ) < 1 ) |
|
4674 |
{ |
|
4675 |
val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) ); |
|
4676 |
} |
|
4677 |
// IF h*2<1: RETURN m2 |
|
4678 |
else if ( ( helperH * 2 ) < 1 ) |
|
4679 |
{ |
|
4680 |
val = ( 255.0 * helperM2 ); |
|
4681 |
} |
|
4682 |
// IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6 |
|
4683 |
else if ( ( helperH * 3 ) < 2 ) |
|
4684 |
{ |
|
4685 |
val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * |
|
4686 |
( 2.0 / 3.0 - helperH ) * 6.0 ) ); |
|
4687 |
} |
|
4688 |
else |
|
4689 |
{ |
|
4690 |
val = 255.0 * helperM1; |
|
4691 |
} |
|
4692 |
||
4693 |
tmpVal = TInt( val + 0.5 ); |
|
4694 |
rgb.SetGreen( ( tmpVal >= 0) ? tmpVal : tmpVal ); |
|
4695 |
||
4696 |
// calculate Blue |
|
4697 |
// PUT hue.to.rgb(m1, m2, h-1/3) IN b |
|
4698 |
helperH = h - ( 1.0 / 3.0 ); |
|
4699 |
helperM1 = m1; |
|
4700 |
helperM2 = m2; |
|
4701 |
||
4702 |
// IF h<0: PUT h+1 IN h |
|
4703 |
if ( helperH < 0 ) |
|
4704 |
{ |
|
4705 |
helperH += 1.0; |
|
4706 |
} |
|
4707 |
// IF h>1: PUT h-1 IN h |
|
4708 |
else if ( helperH > 1 ) |
|
4709 |
{ |
|
4710 |
helperH -= 1.0; |
|
4711 |
} |
|
4712 |
else |
|
4713 |
{ |
|
4714 |
} |
|
4715 |
||
4716 |
// IF h*6<1: RETURN m1+(m2-m1)*h*6 |
|
4717 |
if ( ( helperH * 6 ) < 1 ) |
|
4718 |
{ |
|
4719 |
val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * helperH * 6.0 ) ); |
|
4720 |
} |
|
4721 |
// IF h*2<1: RETURN m2 |
|
4722 |
else if ( ( helperH * 2 ) < 1 ) |
|
4723 |
{ |
|
4724 |
val = ( 255.0 * helperM2 ); |
|
4725 |
} |
|
4726 |
// IF h*3<2: RETURN m1+(m2-m1)*(2/3-h)*6 |
|
4727 |
else if ( ( helperH * 3 ) < 2 ) |
|
4728 |
{ |
|
4729 |
val = ( 255.0 * ( helperM1 + ( helperM2 - helperM1 ) * |
|
4730 |
( 2.0 / 3.0 - helperH ) * 6.0 ) ); |
|
4731 |
} |
|
4732 |
else |
|
4733 |
{ |
|
4734 |
val = 255.0 * helperM1; |
|
4735 |
} |
|
4736 |
||
4737 |
tmpVal = TInt( val + 0.5 ); |
|
4738 |
rgb.SetBlue( ( tmpVal >= 0) ? tmpVal : -tmpVal ); |
|
4739 |
||
4740 |
} |
|
4741 |
return rgb; |
|
4742 |
} |
|
4743 |
||
4744 |
// ----------------------------------------------------------------------------- |
|
4745 |
// ConvertRgbToHsl |
|
4746 |
// Converts a RGB color to HSL color |
|
4747 |
// ----------------------------------------------------------------------------- |
|
4748 |
// |
|
4749 |
static void ConvertRgbToHsl( |
|
4750 |
TRgb aRGB, |
|
4751 |
TUint& aHue, |
|
4752 |
TUint& aSaturation, |
|
4753 |
TUint& aLightness ) |
|
4754 |
{ |
|
4755 |
TReal red = static_cast< TReal >( aRGB.Red() ) / 255.0; |
|
4756 |
TReal green = static_cast< TReal >( aRGB.Green() ) / 255.0; |
|
4757 |
TReal blue = static_cast< TReal >( aRGB.Blue() ) / 255.0; |
|
4758 |
TReal maxColor = ( red > green && red > blue ) ? |
|
4759 |
red : ( green > red && green > blue ) ? green : blue; |
|
4760 |
TReal minColor = ( red <= green && red <= blue ) ? |
|
4761 |
red : ( green <= red && green <= blue ) ? green : blue; |
|
4762 |
TReal lightness = ( maxColor + minColor ) / 2.0; |
|
4763 |
if ( maxColor == minColor ) |
|
4764 |
{ |
|
4765 |
aSaturation = 0; |
|
4766 |
aHue = 0; |
|
4767 |
aLightness = static_cast< TInt >( 100.0 * lightness + 0.5 ); |
|
4768 |
return; |
|
4769 |
} |
|
4770 |
||
4771 |
if ( lightness < 0.5 ) |
|
4772 |
{ |
|
4773 |
TReal saturation = ( maxColor - minColor ) / ( maxColor + minColor ); |
|
4774 |
aSaturation = static_cast< TInt >( 100.0 * saturation + 0.5 ); |
|
4775 |
} |
|
4776 |
else |
|
4777 |
{ |
|
4778 |
TReal saturation = ( maxColor - minColor ) / ( 2.0 - maxColor - minColor ); |
|
4779 |
aSaturation = static_cast< TInt >( 100.0 * saturation + 0.5 ); |
|
4780 |
} |
|
4781 |
||
4782 |
if ( red == maxColor ) |
|
4783 |
{ |
|
4784 |
TReal hue = ( green - blue ) / ( maxColor - minColor ); |
|
4785 |
TInt tmp = static_cast< TInt >( 60.0 * hue + 0.5 ); |
|
4786 |
aHue = ( tmp >= 0 ) ? tmp : tmp + 360; |
|
4787 |
} |
|
4788 |
else if ( green == maxColor ) |
|
4789 |
{ |
|
4790 |
TReal hue = 2.0 + ( ( blue - red ) / ( maxColor - minColor ) ); |
|
4791 |
TInt tmp = static_cast< TInt >( 60.0 * hue + 0.5 ); |
|
4792 |
aHue = ( tmp >= 0 ) ? tmp : tmp + 360; |
|
4793 |
} |
|
4794 |
else |
|
4795 |
{ |
|
4796 |
TReal hue = 4.0 + ( ( red - green ) / ( maxColor - minColor ) ); |
|
4797 |
TInt tmp = static_cast< TInt >( 60.0 * hue + 0.5 ); |
|
4798 |
aHue = ( tmp >= 0 ) ? tmp : tmp + 360; |
|
4799 |
} |
|
4800 |
||
4801 |
aLightness = static_cast< TInt >( 100.0 * lightness + 0.5 ); |
|
4802 |
} |
|
4803 |
||
4804 |
// ----------------------------------------------------------------------------- |
|
4805 |
// CXnControlAdapterImpl::IsDrawingAllowed |
|
4806 |
// Checks whether drawing is allowed |
|
4807 |
// ----------------------------------------------------------------------------- |
|
4808 |
// |
|
4809 |
TBool CXnControlAdapterImpl::IsDrawingAllowed() const |
|
4810 |
{ |
|
4811 |
TBool retVal = EFalse; |
|
4812 |
CXnNode& node = Component()->Node()->Node(); |
|
4813 |
CXnProperty* propVisibility = NULL; |
|
4814 |
TRAP_IGNORE( propVisibility = node.VisibilityL() ); |
|
4815 |
if ( propVisibility ) |
|
4816 |
{ |
|
4817 |
const TDesC8& visibility = propVisibility->StringValue(); |
|
4818 |
if ( visibility != KNullDesC8 ) |
|
4819 |
{ |
|
4820 |
if ( visibility == XnPropertyNames::style::common::visibility::KHidden ) |
|
4821 |
{ |
|
4822 |
return EFalse; |
|
4823 |
} |
|
4824 |
else |
|
4825 |
{ |
|
4826 |
retVal = ETrue; |
|
4827 |
} |
|
4828 |
} |
|
4829 |
} |
|
4830 |
else |
|
4831 |
{ |
|
4832 |
// default value for visibility |
|
4833 |
retVal = ETrue; |
|
4834 |
} |
|
4835 |
CXnProperty* propDisplay = NULL; |
|
4836 |
TRAP_IGNORE( propDisplay = node.DisplayL() ); |
|
4837 |
if ( propDisplay ) |
|
4838 |
{ |
|
4839 |
const TDesC8& display = propDisplay->StringValue(); |
|
4840 |
if ( display != KNullDesC8 ) |
|
4841 |
{ |
|
4842 |
if ( display == XnPropertyNames::style::common::display::KNone ) |
|
4843 |
{ |
|
4844 |
return EFalse; |
|
4845 |
} |
|
4846 |
else |
|
4847 |
{ |
|
4848 |
retVal = ETrue; |
|
4849 |
} |
|
4850 |
} |
|
4851 |
} |
|
4852 |
if ( node.IsDropped() ) |
|
4853 |
{ |
|
4854 |
return EFalse; |
|
4855 |
} |
|
4856 |
else |
|
4857 |
{ |
|
4858 |
retVal = ETrue; |
|
4859 |
} |
|
4860 |
return retVal; |
|
4861 |
} |
|
4862 |
||
4863 |
// ----------------------------------------------------------------------------- |
|
4864 |
// CXnControlAdapterImpl::ContentBitmaps |
|
4865 |
// Gets content bitmaps |
|
4866 |
// ----------------------------------------------------------------------------- |
|
4867 |
// |
|
4868 |
void CXnControlAdapterImpl::ContentBitmaps( |
|
4869 |
CFbsBitmap*& aBitmap, |
|
4870 |
CFbsBitmap*& aMask ) |
|
4871 |
{ |
|
4872 |
aBitmap = iContentBitmap; |
|
4873 |
aMask = iContentMask; |
|
4874 |
} |
|
4875 |
||
4876 |
// ----------------------------------------------------------------------------- |
|
4877 |
// CXnControlAdapterImpl::SetContentBitmaps |
|
4878 |
// Sets content bitmaps |
|
4879 |
// ----------------------------------------------------------------------------- |
|
4880 |
// |
|
4881 |
void CXnControlAdapterImpl::SetContentBitmaps( |
|
4882 |
CFbsBitmap* aBitmap, |
|
4883 |
CFbsBitmap* aMask ) |
|
4884 |
{ |
|
4885 |
delete iContentBitmap; |
|
4886 |
iContentBitmap = NULL; |
|
4887 |
||
4888 |
delete iContentMask; |
|
4889 |
iContentMask = NULL; |
|
4890 |
||
4891 |
iContentBitmap = aBitmap; |
|
4892 |
iContentMask = aMask; |
|
4893 |
} |
|
4894 |
||
4895 |
// ----------------------------------------------------------------------------- |
|
4896 |
// CXnControlAdapterImpl::SetContentBitmapsL |
|
4897 |
// Sets content bitmaps |
|
4898 |
// ----------------------------------------------------------------------------- |
|
4899 |
// |
|
4900 |
void CXnControlAdapterImpl::SetContentBitmapsL( const TDesC& aBitmapUrl, |
|
4901 |
const TDesC& aMaskUrl ) |
|
4902 |
{ |
|
4903 |
delete iContentBitmap; |
|
4904 |
iContentBitmap = NULL; |
|
4905 |
||
4906 |
delete iContentMask; |
|
4907 |
iContentMask = NULL; |
|
4908 |
||
4909 |
CXnNode& node( iNode.Node() ); |
|
4910 |
CXnUiEngine* engine( node.UiEngine() ); |
|
4911 |
||
4912 |
TRect rect( node.Rect() ); |
|
4913 |
||
4914 |
GetBitmapL( *engine, node, aBitmapUrl, iContentBitmapIndex, |
|
4915 |
iContentBitmap, iContentMask, iIconProvider, rect, FsSession() ); |
|
4916 |
if ( !iContentBitmap ) |
|
4917 |
{ |
|
4918 |
CXnProperty* prop( node.GetPropertyL( |
|
4919 |
XnPropertyNames::appearance::common::KFallBackImage ) ); |
|
4920 |
||
4921 |
if ( prop ) |
|
4922 |
{ |
|
4923 |
HBufC* fallBackImage( prop->StringValueL( ) ); |
|
4924 |
||
4925 |
CleanupStack::PushL( fallBackImage ); |
|
4926 |
||
4927 |
if ( *fallBackImage != KNullDesC ) |
|
4928 |
{ |
|
4929 |
StripQuotes( fallBackImage ); |
|
4930 |
||
4931 |
GetBitmapL( *engine, node, *fallBackImage, iContentBitmapIndex, |
|
4932 |
iContentBitmap, iContentMask, iIconProvider, rect, FsSession() ); |
|
4933 |
} |
|
4934 |
||
4935 |
CleanupStack::PopAndDestroy( fallBackImage ); |
|
4936 |
} |
|
4937 |
} |
|
4938 |
||
4939 |
if ( !iContentMask ) |
|
4940 |
{ |
|
4941 |
if ( aMaskUrl != KNullDesC ) |
|
4942 |
{ |
|
4943 |
CFbsBitmap* bitmapMask( NULL ); |
|
4944 |
||
4945 |
GetBitmapL( *engine, node, aMaskUrl, iContentMaskIndex, |
|
4946 |
iContentMask, bitmapMask, iIconProvider, rect, FsSession() ); |
|
4947 |
||
4948 |
delete bitmapMask; |
|
4949 |
} |
|
4950 |
} |
|
4951 |
} |
|
4952 |
||
4953 |
// ----------------------------------------------------------------------------- |
|
4954 |
// CXnControlAdapterImpl::DrawContentImage |
|
4955 |
// Draws content image |
|
4956 |
// ----------------------------------------------------------------------------- |
|
4957 |
// |
|
4958 |
void CXnControlAdapterImpl::DrawContentImage() const |
|
4959 |
{ |
|
4960 |
TRAP_IGNORE( DrawContentImageL( *iGc ) ); |
|
4961 |
} |
|
4962 |
||
4963 |
// ----------------------------------------------------------------------------- |
|
4964 |
// CXnControlAdapterImpl::DrawContentImage |
|
4965 |
// Draws content image |
|
4966 |
// ----------------------------------------------------------------------------- |
|
4967 |
// |
|
4968 |
void CXnControlAdapterImpl::DrawContentImageL( CWindowGc& aGc ) const |
|
4969 |
{ |
|
4970 |
if ( !iContentBitmap ) |
|
4971 |
{ |
|
4972 |
return; |
|
4973 |
} |
|
4974 |
||
4975 |
TRect rect = iComponent->Node()->Node().Rect(); |
|
4976 |
||
4977 |
// Check if the node has a property "preserve image aspect ratio". |
|
4978 |
TBool preserveAspectRatio = ETrue; |
|
4979 |
CXnNode& currentNode = iComponent->Node()->Node(); |
|
4980 |
||
4981 |
CXnProperty* aspectProperty = currentNode.GetPropertyL( |
|
4982 |
XnPropertyNames::image::KS60AspectRatio ); |
|
4983 |
if ( aspectProperty ) |
|
4984 |
{ |
|
4985 |
const TDesC8& value = aspectProperty->StringValue(); |
|
4986 |
||
4987 |
if ( value.CompareF( XnPropertyNames::image::KNone ) == 0 ) |
|
4988 |
{ |
|
4989 |
preserveAspectRatio = EFalse; |
|
4990 |
} |
|
4991 |
} |
|
4992 |
||
4993 |
TRect bitmapRect = rect; |
|
4994 |
bitmapRect.Move( -rect.iTl.iX, -rect.iTl.iY ); |
|
4995 |
// Finds appropriate method of scaling |
|
4996 |
if ( AknIconUtils::IsMifIcon( iContentBitmap ) ) |
|
4997 |
{ |
|
4998 |
if ( preserveAspectRatio ) |
|
4999 |
{ |
|
5000 |
AknIconUtils::SetSize( |
|
5001 |
iContentBitmap, bitmapRect.Size(), |
|
5002 |
EAspectRatioPreservedAndUnusedSpaceRemoved ); |
|
5003 |
AknIconUtils::SetSize( |
|
5004 |
iContentMask, bitmapRect.Size(), |
|
5005 |
EAspectRatioPreservedAndUnusedSpaceRemoved ); |
|
5006 |
// In some cases resizing might fail with previous settings |
|
5007 |
if ( iContentBitmap->SizeInPixels().iHeight == 0 || |
|
5008 |
iContentBitmap->SizeInPixels().iWidth == 0 ) |
|
5009 |
{ |
|
5010 |
AknIconUtils::SetSize( |
|
5011 |
iContentBitmap, bitmapRect.Size(), |
|
5012 |
EAspectRatioPreserved ); |
|
5013 |
AknIconUtils::SetSize( |
|
5014 |
iContentMask, bitmapRect.Size(), |
|
5015 |
EAspectRatioPreserved ); |
|
5016 |
} |
|
5017 |
} |
|
5018 |
else |
|
5019 |
{ |
|
5020 |
AknIconUtils::SetSize( |
|
5021 |
iContentBitmap, bitmapRect.Size(), EAspectRatioNotPreserved ); |
|
5022 |
AknIconUtils::SetSize( |
|
5023 |
iContentMask, bitmapRect.Size(), EAspectRatioNotPreserved ); |
|
5024 |
} |
|
5025 |
// Set a new bitmap size |
|
5026 |
bitmapRect.SetSize( iContentBitmap->SizeInPixels() ); |
|
5027 |
} |
|
5028 |
else |
|
5029 |
{ |
|
5030 |
if ( preserveAspectRatio ) |
|
5031 |
{ |
|
5032 |
TSize newBitmapSize; |
|
5033 |
// scaling is done in bitmap drawing routine, here only the |
|
5034 |
// sacling rect is calculated |
|
5035 |
CalculateScaledBitmapRect( newBitmapSize, rect.Size(), |
|
5036 |
iContentBitmap->SizeInPixels() ); |
|
5037 |
bitmapRect.SetSize( newBitmapSize ); |
|
5038 |
} |
|
5039 |
} |
|
5040 |
||
5041 |
// Calculate new point to start draw |
|
5042 |
// in order to center bitmap to drawing area |
|
5043 |
rect.iTl.iY += |
|
5044 |
( rect.Height() - bitmapRect.Height() ) / 2; |
|
5045 |
rect.iTl.iX += |
|
5046 |
( rect.Width() - bitmapRect.Width() ) / 2; |
|
5047 |
// sets a new size to draw |
|
5048 |
rect.SetSize( bitmapRect.Size() ); |
|
5049 |
||
5050 |
if ( iContentBitmap && iContentMask ) |
|
5051 |
{ |
|
5052 |
aGc.DrawBitmapMasked( rect, |
|
5053 |
iContentBitmap, |
|
5054 |
TRect(TPoint(0, 0), iContentBitmap->SizeInPixels()), |
|
5055 |
iContentMask, |
|
5056 |
ETrue ); |
|
5057 |
} |
|
5058 |
else if ( iContentBitmap ) |
|
5059 |
{ |
|
5060 |
aGc.DrawBitmap( rect, iContentBitmap ); |
|
5061 |
} |
|
5062 |
} |
|
5063 |
||
5064 |
// ----------------------------------------------------------------------------- |
|
5065 |
// CXnControlAdapterImpl::SizeChanged |
|
5066 |
// ----------------------------------------------------------------------------- |
|
5067 |
// |
|
5068 |
void CXnControlAdapterImpl::SizeChanged() |
|
5069 |
{ |
|
5070 |
TRAP_IGNORE( InitializeBackgroundAndBorderBitmapsL() ); |
|
5071 |
} |
|
5072 |
||
5073 |
// ----------------------------------------------------------------------------- |
|
5074 |
// CXnControlAdapterImpl::SkinChanged |
|
5075 |
// ----------------------------------------------------------------------------- |
|
5076 |
// |
|
5077 |
void CXnControlAdapterImpl::SkinChanged() |
|
5078 |
{ |
|
5079 |
TRAP_IGNORE( InitializeBackgroundAndBorderBitmapsL( ETrue ) ); |
|
5080 |
} |
|
5081 |
||
5082 |
// ----------------------------------------------------------------------------- |
|
5083 |
// CXnControlAdapterImpl::FocusChangedL |
|
5084 |
// ----------------------------------------------------------------------------- |
|
5085 |
// |
|
5086 |
void CXnControlAdapterImpl::FocusChangedL( TBool aFocused ) |
|
5087 |
{ |
|
5088 |
CXnNode& node( iNode.Node() ); |
|
5089 |
||
5090 |
CXnUiEngine* engine( node.UiEngine() ); |
|
5091 |
||
5092 |
CXnNode* menubar( engine->MenuBarNode() ); |
|
5093 |
||
5094 |
if ( engine->IsEditMode() || !node.IsLayoutCapable() || !menubar ) |
|
5095 |
{ |
|
5096 |
return; |
|
5097 |
} |
|
5098 |
||
5099 |
XnMenuInterface::MXnMenuInterface* menuIf( NULL ); |
|
5100 |
||
5101 |
XnComponentInterface::MakeInterfaceL( menuIf, menubar->AppIfL() ); |
|
5102 |
||
5103 |
if ( !menuIf ) |
|
5104 |
{ |
|
5105 |
return; |
|
5106 |
} |
|
5107 |
||
5108 |
CXnViewManager* manager( engine->ViewManager() ); |
|
5109 |
||
5110 |
const TDesC8& ns( node.Namespace() ); |
|
5111 |
||
5112 |
CXnPluginData* data( manager->ActiveViewData().Plugin( ns ) ); |
|
5113 |
||
5114 |
if ( !data ) |
|
5115 |
{ |
|
5116 |
return; |
|
5117 |
} |
|
5118 |
||
5119 |
CXnNode* plugin( data->Node()->LayoutNode() ); |
|
5120 |
||
5121 |
CXnNode* extension( NULL ); |
|
5122 |
||
5123 |
if ( plugin == engine->ActiveView() ) |
|
5124 |
{ |
|
5125 |
// Pretend that this node is extension |
|
5126 |
extension = &node; |
|
5127 |
} |
|
5128 |
else |
|
5129 |
{ |
|
5130 |
RPointerArray< CXnNode >& children( plugin->Children() ); |
|
5131 |
||
5132 |
for ( TInt i = 0; i < children.Count(); i++ ) |
|
5133 |
{ |
|
5134 |
CXnNode* child( children[i] ); |
|
5135 |
||
5136 |
const TDesC8& type( child->Type()->Type() ); |
|
5137 |
||
5138 |
if ( type == XnPropertyNames::menu::KMenuExtension ) |
|
5139 |
{ |
|
5140 |
extension = child; |
|
5141 |
break; |
|
5142 |
} |
|
5143 |
} |
|
5144 |
} |
|
5145 |
||
5146 |
if ( !extension ) |
|
5147 |
{ |
|
5148 |
// No extension available |
|
5149 |
return; |
|
5150 |
} |
|
5151 |
||
5152 |
// Find proper softkey from extension |
|
5153 |
RPointerArray< CXnNode >& children( extension->Children() ); |
|
5154 |
||
5155 |
for ( TInt i = 0; i < children.Count(); i++ ) |
|
5156 |
{ |
|
5157 |
CXnNode* child( children[i] ); |
|
5158 |
||
5159 |
const TDesC8& type( child->Type()->Type() ); |
|
5160 |
||
5161 |
if ( type == XnPropertyNames::softkey::KNodeName ) |
|
5162 |
{ |
|
5163 |
||
5164 |
CXnProperty* prop( child->GetPropertyL( |
|
5165 |
XnPropertyNames::softkey::KTypeAttribute ) ); |
|
5166 |
||
5167 |
if ( prop ) |
|
5168 |
{ |
|
5169 |
const TDesC8& type( prop->StringValue() ); |
|
5170 |
||
5171 |
XnMenuInterface::MXnMenuInterface::TSoftKeyPosition pos; |
|
5172 |
||
5173 |
if ( type == XnPropertyNames::softkey::type::KLeft ) |
|
5174 |
{ |
|
5175 |
pos = XnMenuInterface::MXnMenuInterface::ELeft; |
|
5176 |
} |
|
5177 |
else if ( type == XnPropertyNames::softkey::type::KMiddle ) |
|
5178 |
{ |
|
5179 |
pos = XnMenuInterface::MXnMenuInterface::ECenter; |
|
5180 |
} |
|
5181 |
else if ( type == XnPropertyNames::softkey::type::KRight ) |
|
5182 |
{ |
|
5183 |
pos = XnMenuInterface::MXnMenuInterface::ERight; |
|
5184 |
} |
|
5185 |
else |
|
5186 |
{ |
|
5187 |
// Declaration error |
|
5188 |
__ASSERT_DEBUG( EFalse, Panic( EXnInvalidState ) ); |
|
5189 |
break; |
|
5190 |
} |
|
5191 |
||
5192 |
if ( aFocused ) |
|
5193 |
{ |
|
5194 |
// Set softkey |
|
5195 |
menuIf->SetSoftKeyL( &child->PluginIfL(), pos ); |
|
5196 |
} |
|
5197 |
else |
|
5198 |
{ |
|
5199 |
// Remove softkey |
|
5200 |
menuIf->SetSoftKeyL( NULL, pos ); |
|
5201 |
} |
|
5202 |
||
5203 |
// This is not a correct way to do dirty setting, |
|
5204 |
// but here in case of menubar it is acceptable |
|
5205 |
engine->AddDirtyNodeL( menubar, XnDirtyLevel::ERender ); |
|
5206 |
} |
|
5207 |
} |
|
5208 |
} |
|
5209 |
} |
|
5210 |
||
5211 |
// ----------------------------------------------------------------------------- |
|
5212 |
// CXnControlAdapterImpl::InitializeBackgroundandBorderBitmapsL |
|
5213 |
// ----------------------------------------------------------------------------- |
|
5214 |
// |
|
5215 |
void CXnControlAdapterImpl::InitializeBackgroundAndBorderBitmapsL( |
|
5216 |
TBool aForceRecreate ) |
|
5217 |
{ |
|
5218 |
CXnNode& node( iNode.Node() ); |
|
5219 |
CXnUiEngine* engine( node.UiEngine() ); |
|
5220 |
||
5221 |
CXnProperty* backgroundImageProperty( node.BackgroundImageL() ); |
|
5222 |
||
5223 |
// if skin changed we need recreate icons |
|
5224 |
if ( backgroundImageProperty && aForceRecreate ) |
|
5225 |
{ |
|
5226 |
iBackgrondInitialized = EFalse; |
|
5227 |
} |
|
5228 |
||
5229 |
if ( backgroundImageProperty && !iBackgrondInitialized ) |
|
5230 |
{ |
|
5231 |
delete iBackgroundBitmap; |
|
5232 |
iBackgroundBitmap = NULL; |
|
5233 |
||
5234 |
delete iBackgroundMask; |
|
5235 |
iBackgroundMask = NULL; |
|
5236 |
||
5237 |
InitializeBackgroundBitmapL( *engine, node, iBackgroundBitmapIndex, |
|
5238 |
iBackgroundBitmap, iBackgroundMask, iIconProvider, FsSession() ); |
|
5239 |
||
5240 |
HBufC* bgPath( GetBackgroundImagePathLC( node ) ); |
|
5241 |
||
5242 |
if ( *bgPath != KNullDesC ) |
|
5243 |
{ |
|
5244 |
iAnimIDResolved = CXnUtils::ResolveSkinItemIDL( *bgPath, iAnimIID ); |
|
5245 |
} |
|
5246 |
CleanupStack::PopAndDestroy( bgPath ); |
|
5247 |
iBackgrondInitialized = ETrue; |
|
5248 |
} |
|
5249 |
||
5250 |
CXnProperty* borderImageProperty( node.BorderImageL() ); |
|
5251 |
||
5252 |
// if skin changed we need recreate icons |
|
5253 |
if ( borderImageProperty && aForceRecreate ) |
|
5254 |
{ |
|
5255 |
iBorderInitialized = EFalse; |
|
5256 |
} |
|
5257 |
||
5258 |
if ( borderImageProperty && !iBorderInitialized ) |
|
5259 |
{ |
|
5260 |
delete iBorderBitmap; |
|
5261 |
iBorderBitmap = NULL; |
|
5262 |
||
5263 |
iBorderBitmap = InitializeBorderBitmapL( |
|
5264 |
*engine, node, |
|
5265 |
iBorderBitmapIndex, iBorderBitmapDividerTop, |
|
5266 |
iBorderBitmapDividerRight, |
|
5267 |
iBorderBitmapDividerBottom, iBorderBitmapDividerLeft, |
|
5268 |
iIconProvider, FsSession() ); |
|
5269 |
||
5270 |
iBorderInitialized = ETrue; |
|
5271 |
} |
|
5272 |
} |
|
5273 |
||
5274 |
// ----------------------------------------------------------------------------- |
|
5275 |
// CXnControlAdapterImpl::ConstructL |
|
5276 |
// 2nd phase constructor. Can leave. |
|
5277 |
// ----------------------------------------------------------------------------- |
|
5278 |
// |
|
5279 |
void CXnControlAdapterImpl::ConstructL( |
|
5280 |
CXnNodePluginIf& aNode, |
|
5281 |
CXnControlAdapter& aAdapter, |
|
5282 |
CWindowGc& aGc ) |
|
5283 |
{ |
|
5284 |
iGc = &aGc; |
|
5285 |
||
5286 |
iAdapter = &aAdapter; |
|
5287 |
||
5288 |
if ( CreateGestureHelperL( aNode.Node() ) ) |
|
5289 |
{ |
|
5290 |
iGestureFw = CAknTouchGestureFw::NewL( *this, aAdapter ); |
|
5291 |
iGestureFw->SetGestureInterestL( EAknTouchGestureFwGroupFlick ); |
|
5292 |
} |
|
5293 |
||
5294 |
if ( aNode.Type()->Type() == KView ) |
|
5295 |
{ |
|
5296 |
iSuppressor = CAknPointerEventSuppressor::NewL(); |
|
5297 |
iSuppressor->SetMaxTapMove( TSize( KMaxTapMove, KMaxTapMove) ); |
|
5298 |
iSuppressor->SetMaxTapDuration( KLongTapTimeLongDelay ); |
|
5299 |
} |
|
5300 |
} |
|
5301 |
||
5302 |
// ----------------------------------------------------------------------------- |
|
5303 |
// CXnControlAdapterImpl::LoadBitmap |
|
5304 |
// Load a bitmap from the server. Ownership is transferred. |
|
5305 |
// ----------------------------------------------------------------------------- |
|
5306 |
// |
|
5307 |
CFbsBitmap* CXnControlAdapterImpl::LoadBitmap( const TDesC& aBitmapUrl ) |
|
5308 |
{ |
|
5309 |
CXnNode& node( iNode.Node() ); |
|
5310 |
CXnUiEngine* engine( node.UiEngine() ); |
|
5311 |
||
5312 |
CFbsBitmap* bitmap( NULL ); |
|
5313 |
CFbsBitmap* mask( NULL ); |
|
5314 |
||
5315 |
TRect rect( node.Rect() ); |
|
5316 |
||
5317 |
TInt index( 0 ); |
|
5318 |
||
5319 |
TRAP_IGNORE( GetBitmapL( |
|
5320 |
*engine, node, |
|
5321 |
aBitmapUrl, index, |
|
5322 |
bitmap, mask, |
|
5323 |
iIconProvider, rect, FsSession() ) ); |
|
5324 |
||
5325 |
delete mask; |
|
5326 |
||
5327 |
return bitmap; |
|
5328 |
} |
|
5329 |
||
5330 |
// ----------------------------------------------------------------------------- |
|
5331 |
// CXnControlAdapterImpl::GetBitmapAndMask |
|
5332 |
// Load a bitmap and mask from the server. Ownership is transferred. |
|
5333 |
// ----------------------------------------------------------------------------- |
|
5334 |
// |
|
5335 |
void CXnControlAdapterImpl::GetBitmapAndMask( |
|
5336 |
const TDesC& aBitmapUrl, |
|
5337 |
const TDesC& aMaskUrl, |
|
5338 |
CFbsBitmap*& aBitmap, |
|
5339 |
CFbsBitmap*& aMask ) |
|
5340 |
{ |
|
5341 |
CXnNode& node( iNode.Node() ); |
|
5342 |
CXnUiEngine* engine( node.UiEngine() ); |
|
5343 |
||
5344 |
TRect rect( node.Rect() ); |
|
5345 |
||
5346 |
TInt index( 0 ); |
|
5347 |
||
5348 |
TRAP_IGNORE( GetBitmapL( |
|
5349 |
*engine, node, |
|
5350 |
aBitmapUrl, index, |
|
5351 |
aBitmap, aMask, |
|
5352 |
iIconProvider, rect, FsSession() ) ); |
|
5353 |
||
5354 |
if ( !aMask ) |
|
5355 |
{ |
|
5356 |
if ( aMaskUrl != KNullDesC ) |
|
5357 |
{ |
|
5358 |
CFbsBitmap* bitmapMask( NULL ); |
|
5359 |
||
5360 |
TRAP_IGNORE( GetBitmapL( |
|
5361 |
*engine, node, |
|
5362 |
aMaskUrl, index, |
|
5363 |
aMask, bitmapMask, |
|
5364 |
iIconProvider, rect, FsSession() ) ); |
|
5365 |
||
5366 |
delete bitmapMask; |
|
5367 |
} |
|
5368 |
} |
|
5369 |
} |
|
5370 |
||
5371 |
// ----------------------------------------------------------------------------- |
|
5372 |
// CXnControlAdapterImpl::AnimFrameReady |
|
5373 |
// Callback of the animated skin background. |
|
5374 |
// ----------------------------------------------------------------------------- |
|
5375 |
// |
|
5376 |
void CXnControlAdapterImpl::AnimFrameReady( TInt aError, TInt /* aAnimId */ ) |
|
5377 |
{ |
|
5378 |
if ( !aError ) |
|
5379 |
{ |
|
5380 |
iAdapter->DrawNow(); |
|
5381 |
} |
|
5382 |
} |
|
5383 |
||
5384 |
// ----------------------------------------------------------------------------- |
|
5385 |
// CXnControlAdapterImpl::CreateAnimationL |
|
5386 |
// ----------------------------------------------------------------------------- |
|
5387 |
// |
|
5388 |
void CXnControlAdapterImpl::CreateAnimationL( /* TDesC& aPath */ ) |
|
5389 |
{ |
|
5390 |
if ( iAnimation ) |
|
5391 |
{ |
|
5392 |
delete iAnimation; |
|
5393 |
iAnimation = NULL; |
|
5394 |
} |
|
5395 |
||
5396 |
iAnimation = CAknsEffectAnim::NewL( this ); |
|
5397 |
TBool ok = iAnimation->ConstructFromSkinL( iAnimIID ); |
|
5398 |
if ( !ok ) |
|
5399 |
{ |
|
5400 |
delete iAnimation; |
|
5401 |
iAnimation = NULL; |
|
5402 |
User::Leave( KErrNotSupported ); |
|
5403 |
} |
|
5404 |
||
5405 |
CXnNode& node = iComponent->Node()->Node(); |
|
5406 |
if ( !node.IsLaidOut() ) |
|
5407 |
{ |
|
5408 |
// Animation is created before layout of nodes has been calculated |
|
5409 |
node.UiEngine()->LayoutUIL( &node ); |
|
5410 |
} |
|
5411 |
TRect rect( node.Rect() ); |
|
5412 |
||
5413 |
iAnimation->BeginConfigInputLayersL( rect.Size(), ETrue ); |
|
5414 |
||
5415 |
if ( iAnimation->InputRgbGc() ) |
|
5416 |
{ |
|
5417 |
TRect mainPane; |
|
5418 |
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, mainPane ); |
|
5419 |
TRect mainPaneRect( mainPane.Size() ); |
|
5420 |
||
5421 |
MAknsSkinInstance* skin = AknsUtils::SkinInstance(); |
|
5422 |
MAknsControlContext* cc = NULL; |
|
5423 |
const TAknsItemID* id = &KAknsIIDNone; |
|
5424 |
if ( AknsUtils::AvkonSkinEnabled() ) |
|
5425 |
{ |
|
5426 |
cc = CAknsListBoxBackgroundControlContext::NewL( |
|
5427 |
KAknsIIDQsnBgAreaMainListGene, |
|
5428 |
mainPaneRect, |
|
5429 |
EFalse, |
|
5430 |
*id, |
|
5431 |
mainPaneRect ); |
|
5432 |
||
5433 |
AknsDrawUtils::DrawBackground( AknsUtils::SkinInstance(), |
|
5434 |
cc, |
|
5435 |
NULL, |
|
5436 |
*iAnimation->InputRgbGc(), |
|
5437 |
TPoint(), |
|
5438 |
rect, |
|
5439 |
KAknsDrawParamBottomLevelRGBOnly ); |
|
5440 |
} |
|
5441 |
} |
|
5442 |
||
5443 |
iAnimation->EndConfigInputLayersL(); |
|
5444 |
} |
|
5445 |
||
5446 |
// ----------------------------------------------------------------------------- |
|
5447 |
// CXnControlAdapterImpl::StartHighlightAnimation() |
|
5448 |
// ----------------------------------------------------------------------------- |
|
5449 |
// |
|
5450 |
void CXnControlAdapterImpl::StartHighlightAnimation( TBool aAnimRestart ) |
|
5451 |
{ |
|
5452 |
TBool focused = EFalse; |
|
5453 |
||
5454 |
// No need to start animation again if already running |
|
5455 |
if ( iAnimation ) |
|
5456 |
{ |
|
5457 |
if ( iAnimation->State() == EAknsAnimStateRunning && !aAnimRestart ) |
|
5458 |
{ |
|
5459 |
return; |
|
5460 |
} |
|
5461 |
} |
|
5462 |
// Check control's focus |
|
5463 |
if ( iComponent ) |
|
5464 |
{ |
|
5465 |
CXnNodePluginIf* pluginIf = iComponent->Node(); |
|
5466 |
if ( pluginIf ) |
|
5467 |
{ |
|
5468 |
focused = pluginIf->IsFocusedState(); |
|
5469 |
} |
|
5470 |
else |
|
5471 |
{ |
|
5472 |
return; |
|
5473 |
} |
|
5474 |
} |
|
5475 |
||
5476 |
// If the node is not focused or no Anim ID, return. |
|
5477 |
if ( !focused || !iAnimIDResolved ) |
|
5478 |
{ |
|
5479 |
return; |
|
5480 |
} |
|
5481 |
||
5482 |
// Restart animation |
|
5483 |
if ( aAnimRestart ) |
|
5484 |
{ |
|
5485 |
if ( iAnimation ) |
|
5486 |
{ |
|
5487 |
iAnimation->Stop(); |
|
5488 |
delete iAnimation; |
|
5489 |
iAnimation = NULL; |
|
5490 |
||
5491 |
TRAPD( error, CreateAnimationL() ); |
|
5492 |
||
5493 |
if ( !error ) |
|
5494 |
{ |
|
5495 |
iAnimation->Start(); |
|
5496 |
return; |
|
5497 |
} |
|
5498 |
} |
|
5499 |
} |
|
5500 |
||
5501 |
// Node is focused. Try to start animation. |
|
5502 |
if ( iAnimation ) |
|
5503 |
{ |
|
5504 |
iAnimation->Start(); |
|
5505 |
} |
|
5506 |
else |
|
5507 |
{ |
|
5508 |
TRAPD( error, CreateAnimationL() ); |
|
5509 |
||
5510 |
if ( !error ) |
|
5511 |
{ |
|
5512 |
iAnimation->Start(); |
|
5513 |
} |
|
5514 |
} |
|
5515 |
} |
|
5516 |
||
5517 |
// ----------------------------------------------------------------------------- |
|
5518 |
// CXnControlAdapterImpl::StopHighlightAnimation() |
|
5519 |
// ----------------------------------------------------------------------------- |
|
5520 |
// |
|
5521 |
void CXnControlAdapterImpl::StopHighlightAnimation() |
|
5522 |
{ |
|
5523 |
if ( iAnimation ) |
|
5524 |
{ |
|
5525 |
// Stop animation and delete. |
|
5526 |
iAnimation->Stop(); |
|
5527 |
delete iAnimation; |
|
5528 |
iAnimation = NULL; |
|
5529 |
||
5530 |
iAdapter->DrawNow(); |
|
5531 |
} |
|
5532 |
} |
|
5533 |
||
5534 |
// ----------------------------------------------------------------------------- |
|
5535 |
// CXnControlAdapterImpl::MeasureAdaptiveContentL |
|
5536 |
// ----------------------------------------------------------------------------- |
|
5537 |
// |
|
5538 |
TSize CXnControlAdapterImpl::MeasureAdaptiveContentL( |
|
5539 |
const TSize& /* aAvailableSize */ ) |
|
5540 |
{ |
|
5541 |
// By default the size is 0 |
|
5542 |
return TSize( 0, 0 ); |
|
5543 |
} |
|
5544 |
||
5545 |
// ----------------------------------------------------------------------------- |
|
5546 |
// CXnControlAdapterImpl::SetBlank |
|
5547 |
// |
|
5548 |
// ----------------------------------------------------------------------------- |
|
5549 |
// |
|
5550 |
void CXnControlAdapterImpl::SetBlank( TBool aBlank ) |
|
5551 |
{ |
|
5552 |
iBlank = aBlank; |
|
5553 |
} |
|
5554 |
||
5555 |
// ----------------------------------------------------------------------------- |
|
5556 |
// CXnControlAdapterImpl::DoHandlePropertyChangeL |
|
5557 |
// ----------------------------------------------------------------------------- |
|
5558 |
// |
|
5559 |
void CXnControlAdapterImpl::DoHandlePropertyChangeL( CXnProperty* /*aProperty*/ ) |
|
5560 |
{ |
|
5561 |
} |
|
5562 |
||
5563 |
// ----------------------------------------------------------------------------- |
|
5564 |
// CXnControlAdapterImpl::UpdateBackgroundImageL |
|
5565 |
// ----------------------------------------------------------------------------- |
|
5566 |
// |
|
5567 |
CXnControlAdapterImpl::TPropertyChangeResponse CXnControlAdapterImpl::UpdateBackgroundImageL( |
|
5568 |
CXnProperty* aProperty ) |
|
5569 |
{ |
|
5570 |
if ( aProperty ) |
|
5571 |
{ |
|
5572 |
const TDesC8& name( aProperty->Property()->Name() ); |
|
5573 |
||
5574 |
if ( name == XnPropertyNames::appearance::common::KBackGroundImage ) |
|
5575 |
{ |
|
5576 |
delete iBackgroundBitmap; |
|
5577 |
iBackgroundBitmap = NULL; |
|
5578 |
||
5579 |
delete iBackgroundMask; |
|
5580 |
iBackgroundMask = NULL; |
|
5581 |
||
5582 |
InitializeBackgroundBitmapL( *( iNode.Node().UiEngine() ), iNode.Node(), |
|
5583 |
iBackgroundBitmapIndex, iBackgroundBitmap, iBackgroundMask, |
|
5584 |
iIconProvider, FsSession()); |
|
5585 |
||
5586 |
return EPropertyChangeConsumed; |
|
5587 |
} |
|
5588 |
} |
|
5589 |
||
5590 |
return EPropertyChangeNotConsumed; |
|
5591 |
} |
|
5592 |
||
5593 |
// ----------------------------------------------------------------------------- |
|
5594 |
// CXnControlAdapterImpl::HandleScreenDeviceChangedL |
|
5595 |
// ----------------------------------------------------------------------------- |
|
5596 |
// |
|
5597 |
void CXnControlAdapterImpl::HandleScreenDeviceChangedL() |
|
5598 |
{ |
|
5599 |
} |
|
5600 |
||
5601 |
// ----------------------------------------------------------------------------- |
|
5602 |
// CreateBitmapFromColorL |
|
5603 |
// Creates a bitmap object with the given size and fill color |
|
5604 |
// ----------------------------------------------------------------------------- |
|
5605 |
// |
|
5606 |
static CFbsBitmap* CreateBitmapFromColorL( TSize aSize, TRgb aColor ) |
|
5607 |
{ |
|
5608 |
CFbsBitmap* newBitmap = new ( ELeave ) CFbsBitmap; |
|
5609 |
newBitmap->Create( aSize, EColor16M ); |
|
5610 |
CleanupStack::PushL( newBitmap ); |
|
5611 |
||
5612 |
CFbsBitmapDevice* bitmapDev = CFbsBitmapDevice::NewL( newBitmap ); |
|
5613 |
CleanupStack::PushL( bitmapDev ); |
|
5614 |
||
5615 |
CFbsBitGc* bc = NULL; |
|
5616 |
User::LeaveIfError( bitmapDev->CreateContext( bc ) ); |
|
5617 |
CleanupStack::PushL( bc ); |
|
5618 |
||
5619 |
bc->SetBrushColor( aColor ); |
|
5620 |
bc->Clear(); // area is filled with the brush color |
|
5621 |
||
5622 |
CleanupStack::PopAndDestroy( bc ); |
|
5623 |
CleanupStack::PopAndDestroy( bitmapDev ); |
|
5624 |
CleanupStack::Pop( newBitmap ); |
|
5625 |
return newBitmap; |
|
5626 |
} |
|
5627 |
||
5628 |
// ----------------------------------------------------------------------------- |
|
5629 |
// InitializeGestureL |
|
5630 |
// Sets up gesture |
|
5631 |
// ----------------------------------------------------------------------------- |
|
5632 |
// |
|
5633 |
void CXnControlAdapterImpl::InitializeGestureL( |
|
5634 |
const TPointerEvent& aPointerEvent ) |
|
5635 |
{ |
|
5636 |
if ( !iGestureFw || aPointerEvent.iType != TPointerEvent::EButton1Down ) |
|
5637 |
{ |
|
5638 |
return; |
|
5639 |
} |
|
5640 |
||
5641 |
CXnUiEngine* engine( iNode.Node().UiEngine() ); |
|
5642 |
// Set default destination |
|
5643 |
iGestureDestination = &iNode.Node(); |
|
5644 |
||
5645 |
RPointerArray< CXnPluginData >& plugins( |
|
5646 |
engine->ViewManager()->ActiveViewData().PluginData() ); |
|
5647 |
||
5648 |
for ( TInt i = 0; i < plugins.Count(); i++ ) |
|
5649 |
{ |
|
5650 |
CXnPluginData* plugin( plugins[i] ); |
|
5651 |
||
5652 |
if ( plugin->Occupied() ) |
|
5653 |
{ |
|
5654 |
CXnNode* widget( plugin->Node()->LayoutNode() ); |
|
5655 |
||
5656 |
if ( widget->MarginRect().Contains( aPointerEvent.iPosition ) ) |
|
5657 |
{ |
|
5658 |
// Resolve swipe destination |
|
5659 |
CXnProperty* prop( widget->GetPropertyL( |
|
5660 |
XnPropertyNames::common::KSwipeDestination ) ); |
|
5661 |
||
5662 |
if ( prop ) |
|
5663 |
{ |
|
5664 |
const TDesC8& value( prop->StringValue() ); |
|
5665 |
||
5666 |
if( value == XnPropertyNames::KWidget ) |
|
5667 |
{ |
|
5668 |
// Set widget as destination |
|
5669 |
iGestureDestination = widget; |
|
5670 |
} |
|
5671 |
else if( value == XnPropertyNames::KNone ) |
|
5672 |
{ |
|
5673 |
// Set no destination |
|
5674 |
iGestureDestination = NULL; |
|
5675 |
} |
|
5676 |
} |
|
5677 |
break; |
|
5678 |
} |
|
5679 |
} |
|
5680 |
} |
|
5681 |
} |
|
5682 |
||
5683 |
// ----------------------------------------------------------------------------- |
|
5684 |
// ----------------------------------------------------------------------------- |
|
5685 |
// |
|
5686 |
void CXnControlAdapterImpl::RemoveChildAdapters() |
|
5687 |
{ |
|
5688 |
iChildren.Reset(); |
|
5689 |
} |
|
5690 |
||
5691 |
// ----------------------------------------------------------------------------- |
|
5692 |
// ----------------------------------------------------------------------------- |
|
5693 |
// |
|
5694 |
RPointerArray< CXnControlAdapter >& CXnControlAdapterImpl::ChildAdapters() |
|
5695 |
{ |
|
5696 |
return iChildren; |
|
5697 |
} |
|
5698 |
||
5699 |
// ----------------------------------------------------------------------------- |
|
5700 |
// ----------------------------------------------------------------------------- |
|
5701 |
// |
|
5702 |
RFs& CXnControlAdapterImpl::FsSession() |
|
5703 |
{ |
|
5704 |
return iAdapter->ControlEnv()->FsSession(); |
|
5705 |
} |
|
5706 |
||
5707 |
// ----------------------------------------------------------------------------- |
|
5708 |
// ----------------------------------------------------------------------------- |
|
5709 |
// |
|
5710 |
void CXnControlAdapterImpl::HandleTouchGestureL( MAknTouchGestureFwEvent& aEvent ) |
|
5711 |
{ |
|
5712 |
if ( aEvent.Group() == EAknTouchGestureFwGroupFlick ) |
|
5713 |
{ |
|
5714 |
TAknTouchGestureFwType type = aEvent.Type(); |
|
5715 |
||
5716 |
const TDesC8* swipe( NULL ); |
|
5717 |
||
5718 |
if ( type == EAknTouchGestureFwFlickLeft ) |
|
5719 |
{ |
|
5720 |
swipe = &XnPropertyNames::action::trigger::name::swipe::direction::KLeft; |
|
5721 |
} |
|
5722 |
else if ( type == EAknTouchGestureFwFlickRight ) |
|
5723 |
{ |
|
5724 |
swipe = &XnPropertyNames::action::trigger::name::swipe::direction::KRight; |
|
5725 |
} |
|
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5726 |
|
34 | 5727 |
if ( swipe && iGestureDestination ) |
5728 |
{ |
|
5729 |
CXnUiEngine* engine = iNode.Node().UiEngine(); |
|
5730 |
||
5731 |
// Remove focus |
|
5732 |
engine->AppUiAdapter().HideFocus(); |
|
5733 |
||
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5734 |
if ( ( engine->AppUiAdapter().ViewSwitcher() != NULL ) && |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5735 |
( engine->AppUiAdapter().ViewSwitcher()->FingerFollowSupported() ) && |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5736 |
( !iGestureDestination || iGestureDestination == &iNode.Node() ) ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5737 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5738 |
engine->AppUiAdapter().ViewSwitcher()->TouchGesture( type ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5739 |
} |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5740 |
else if ( iGestureDestination ) |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5741 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5742 |
CXnNode* trigger( BuildSwipeTriggerNodeLC( *engine, *swipe ) ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5743 |
iGestureDestination->ReportXuikonEventL( *trigger ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5744 |
CleanupStack::PopAndDestroy( trigger ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5745 |
} |
34 | 5746 |
CXnAppUiAdapter& appui( engine->AppUiAdapter() ); |
5747 |
CXnViewData& data( appui.ViewManager().ActiveViewData() ); |
|
5748 |
||
5749 |
CXnViewControlAdapter* control = |
|
5750 |
static_cast< CXnViewControlAdapter* >( data.ViewNode()->Control() ); |
|
5751 |
||
5752 |
control->ResetGrabbing(); |
|
5753 |
} |
|
5754 |
} |
|
5755 |
} |
|
5756 |
||
35
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5757 |
// ----------------------------------------------------------------------------- |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5758 |
// ----------------------------------------------------------------------------- |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5759 |
// |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5760 |
TBool CXnControlAdapterImpl::IsWidgetGestureDest() |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5761 |
{ |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5762 |
return ( !iGestureDestination || iGestureDestination != &iNode.Node() ); |
3321d3e205b6
Revision: 201033
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
34
diff
changeset
|
5763 |
} |
34 | 5764 |
|
5765 |
// ============================= TIconProvider =============================== |
|
5766 |
||
5767 |
// ----------------------------------------------------------------------------- |
|
5768 |
// Constructor |
|
5769 |
// ----------------------------------------------------------------------------- |
|
5770 |
// |
|
5771 |
CXnControlAdapterImpl::TIconProvider::TIconProvider( RFile& aFile ) : |
|
5772 |
iFile( aFile ) |
|
5773 |
{ |
|
5774 |
} |
|
5775 |
||
5776 |
// ----------------------------------------------------------------------------- |
|
5777 |
// Destructor |
|
5778 |
// ----------------------------------------------------------------------------- |
|
5779 |
// |
|
5780 |
CXnControlAdapterImpl::TIconProvider::~TIconProvider() |
|
5781 |
{ |
|
5782 |
iFile.Close(); |
|
5783 |
} |
|
5784 |
||
5785 |
// ----------------------------------------------------------------------------- |
|
5786 |
// Retreive Icon handle |
|
5787 |
// ----------------------------------------------------------------------------- |
|
5788 |
// |
|
5789 |
void CXnControlAdapterImpl::TIconProvider::RetrieveIconFileHandleL( |
|
5790 |
RFile& aFile, const TIconFileType /*aType*/) |
|
5791 |
{ |
|
5792 |
aFile.Duplicate( iFile ); |
|
5793 |
} |
|
5794 |
||
5795 |
// ----------------------------------------------------------------------------- |
|
5796 |
// Finish |
|
5797 |
// ----------------------------------------------------------------------------- |
|
5798 |
// |
|
5799 |
void CXnControlAdapterImpl::TIconProvider::Finished() |
|
5800 |
{ |
|
5801 |
iFile.Close(); |
|
5802 |
delete this; |
|
5803 |
} |
|
5804 |