1 /* |
|
2 * Copyright (c) 2007 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: The basic implementation for presentation elements. |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include "alf/alfelement.h" |
|
20 #include <alf/alfwidgetcontrol.h> |
|
21 #include <alf/alfvarianttype.h> |
|
22 #include "alf/ialfvisualtemplate.h" |
|
23 #include "alf/alfreferencetovisual.h" |
|
24 //#include "alf/alfperf.h" |
|
25 #include <alf/alfexceptions.h> |
|
26 |
|
27 #include "alfelementattributeownerimpl.h" |
|
28 |
|
29 namespace Alf |
|
30 { |
|
31 |
|
32 class AlfVisualData |
|
33 { |
|
34 public: |
|
35 AlfVisualData( CAlfVisual* aVisualTree, uint aDataID ) : |
|
36 mVisualTree( aVisualTree ), mDataID( aDataID ) |
|
37 { |
|
38 } |
|
39 CAlfVisual *mVisualTree; |
|
40 uint mDataID; |
|
41 ~AlfVisualData() |
|
42 { |
|
43 |
|
44 } |
|
45 |
|
46 }; |
|
47 |
|
48 class AlfElementImpl |
|
49 { |
|
50 public: |
|
51 AlfElementImpl() |
|
52 { |
|
53 mControl = 0; |
|
54 mVisualTemplate = 0; |
|
55 mParentElement = 0; |
|
56 mParentLayout = 0; |
|
57 } |
|
58 ~AlfElementImpl() |
|
59 { |
|
60 if (mVisualTemplate) |
|
61 { |
|
62 delete mVisualTemplate; |
|
63 mVisualTemplate = 0; |
|
64 } |
|
65 if (mParentLayout) |
|
66 { |
|
67 delete mParentLayout; |
|
68 mParentLayout = 0; |
|
69 } |
|
70 |
|
71 mVisualTreeArray.clear(); |
|
72 } |
|
73 /** |
|
74 * The control. Not own. |
|
75 */ |
|
76 CAlfWidgetControl* mControl; |
|
77 |
|
78 /** |
|
79 * The element name. |
|
80 */ |
|
81 UString mName; |
|
82 |
|
83 /** |
|
84 * The visual template for creating visual trees. Own. |
|
85 */ |
|
86 IAlfVisualTemplate* mVisualTemplate; |
|
87 |
|
88 /* |
|
89 * Parent element. NULL for root elements. Not own. |
|
90 */ |
|
91 IAlfElement *mParentElement; |
|
92 |
|
93 /* |
|
94 * Array of created visual trees with the associated data IDs. |
|
95 */ |
|
96 AlfPtrVector<AlfVisualData>mVisualTreeArray; //RArray<TAlfVisualData> mVisualTreeArray; |
|
97 |
|
98 /* |
|
99 * Reference to the default parent layout. Own. |
|
100 */ |
|
101 AlfReferenceToVisual *mParentLayout; |
|
102 |
|
103 /* |
|
104 * IAlfAttributeOwner implementation. Own. |
|
105 */ |
|
106 auto_ptr<AlfElementAttributeOwnerImpl> mAttributeOwnerImpl; |
|
107 }; |
|
108 |
|
109 // ======== MEMBER FUNCTIONS ======== |
|
110 |
|
111 OSN_EXPORT AlfElement::AlfElement() |
|
112 { |
|
113 } |
|
114 |
|
115 OSN_EXPORT void AlfElement::construct( CAlfWidgetControl& aControl, const char* aName ) |
|
116 { |
|
117 mData.reset(new (EMM) AlfElementImpl()); |
|
118 |
|
119 mData->mControl = &aControl; |
|
120 mData->mName = UString(aName); |
|
121 mData->mParentLayout=NULL; |
|
122 mData->mParentElement=NULL; |
|
123 mData->mVisualTemplate=NULL; |
|
124 mData->mVisualTreeArray.setAutoDelete(true); |
|
125 mData->mAttributeOwnerImpl.reset(new (EMM) AlfElementAttributeOwnerImpl(*this, |
|
126 *mData->mControl)); |
|
127 aControl.addElement(this); |
|
128 } |
|
129 |
|
130 |
|
131 OSN_EXPORT AlfElement::AlfElement(CAlfWidgetControl& aControl, const char* aName) |
|
132 { |
|
133 construct( aControl, aName ); |
|
134 |
|
135 } |
|
136 |
|
137 OSN_EXPORT AlfElement::~AlfElement() |
|
138 { |
|
139 } |
|
140 |
|
141 OSN_EXPORT const char* AlfElement::name() const |
|
142 { |
|
143 return mData->mName.getUtf8(); |
|
144 } |
|
145 |
|
146 OSN_EXPORT void AlfElement::createChildVisualTree( |
|
147 IAlfElement* aElement, IAlfVariantType& aChildData, |
|
148 IAlfBranch& aData, int aIndex, uint aDataID ) |
|
149 { |
|
150 // Pass directly to the child element CreateVisualTree, no need |
|
151 // to do anything else. Derived classes may need additional steps here. |
|
152 // ALF_PERF_START( perfdata, "AlfElement-createVisualTree-createChildVisualTree") |
|
153 aElement->createVisualTree( aChildData, aData, aIndex, aDataID, |
|
154 aElement->defaultParentLayout( aDataID ), |
|
155 aIndex ); |
|
156 // ALF_PERF_STOP( perfdata, "AlfElement-createVisualTree-createChildVisualTree") |
|
157 } |
|
158 |
|
159 OSN_EXPORT CAlfVisual* AlfElement::createVisualTree( |
|
160 IAlfVariantType& aData, IAlfBranch& aParentData, int aIndex, |
|
161 uint aParentDataID, CAlfLayout* aParentLayout, int aLayoutIndex ) |
|
162 { |
|
163 if ( aIndex >= 0 && aIndex <= aParentData.childrenCount() ) |
|
164 { |
|
165 // Update data IDs of all visual trees after the new visual tree |
|
166 // Start from the aIndex, and increase all indices by one |
|
167 updateDataIDs( aParentData, aIndex, 1, aParentDataID, aParentDataID ); |
|
168 |
|
169 // Create the new visual tree |
|
170 uint dataID = control().elementDataId( *this, aIndex, aParentDataID ); |
|
171 return createVisualTree( aData, dataID, aParentLayout, aLayoutIndex ); |
|
172 } |
|
173 ALF_THROW(AlfElementException,EInvalidElement,"AlfElement") |
|
174 } |
|
175 |
|
176 OSN_EXPORT CAlfVisual* AlfElement::createVisualTree( |
|
177 IAlfVariantType& aData, uint aDataID, CAlfLayout* aParentLayout, int aLayoutIndex ) |
|
178 { |
|
179 CAlfVisual *retVisual = NULL; |
|
180 IAlfMap* currentData = NULL; |
|
181 IAlfBranch* branch = NULL; |
|
182 if ( aData.type()== IAlfVariantType::EMap ) |
|
183 { |
|
184 currentData = aData.map(); |
|
185 } |
|
186 else if (aData.type()== IAlfVariantType::EBranch) |
|
187 { |
|
188 branch = aData.branch(); |
|
189 currentData = aData.branch()->data(); |
|
190 } |
|
191 |
|
192 if ( currentData && mData->mVisualTemplate ) |
|
193 { |
|
194 //Find the visual tree with data id |
|
195 int index = findFromArray( aDataID ); |
|
196 if ( index < 0 ) |
|
197 { |
|
198 // Create a new visual tree |
|
199 try |
|
200 { |
|
201 retVisual = mData->mVisualTemplate->createVisualTree(*mData->mControl, |
|
202 currentData, aParentLayout, aLayoutIndex); |
|
203 } |
|
204 catch (...) |
|
205 { |
|
206 ALF_THROW(AlfVisualException,ECanNotCreateVisual,"AlfElement") |
|
207 } |
|
208 // Append the visual into the array |
|
209 mData->mVisualTreeArray.resize(mData->mVisualTreeArray.count()+1); |
|
210 mData->mVisualTreeArray.insert(mData->mVisualTreeArray.count(),(new (EMM) AlfVisualData(retVisual, aDataID))); |
|
211 } |
|
212 else |
|
213 { |
|
214 ALF_THROW(AlfVisualException,EInvalidElement,"AlfElement") |
|
215 } |
|
216 } |
|
217 |
|
218 if ( branch ) |
|
219 { |
|
220 // Pass to children |
|
221 int count = branch->childrenCount(); |
|
222 for ( int i = 0; i < count; ++i ) |
|
223 { |
|
224 IAlfElement* element = mData->mControl->findElement( |
|
225 branch->childName( i ).getUtf8() ); |
|
226 if ( element ) |
|
227 { |
|
228 createChildVisualTree( |
|
229 element, *branch->childData( i ), *branch, i, aDataID ); |
|
230 } |
|
231 } |
|
232 } |
|
233 |
|
234 return retVisual; |
|
235 } |
|
236 |
|
237 OSN_EXPORT void AlfElement::removeChildVisualTree( |
|
238 IAlfElement* aElement, IAlfBranch& aData, int aIndex, uint aDataID ) |
|
239 { |
|
240 // Pass directly to the child element RemoveVisualTree, no need |
|
241 // to do anything else. Derived classes may need additional steps here. |
|
242 aElement->removeVisualTree( aData, aIndex, aDataID ); |
|
243 } |
|
244 |
|
245 OSN_EXPORT void AlfElement::removeVisualTree( IAlfBranch& aParentData, |
|
246 int aIndex, uint aParentDataID ) |
|
247 { |
|
248 if ( aIndex < aParentData.childrenCount() ) |
|
249 { |
|
250 IAlfVariantType* data = aParentData.childData( aIndex ); |
|
251 uint dataID = control().elementDataId( *this, aIndex, aParentDataID ); |
|
252 |
|
253 removeVisualTree( *data, dataID ); |
|
254 |
|
255 // Update data IDs of all visual trees after the removed visual tree |
|
256 // Start from the aIndex + 1, and decrease all indices by one |
|
257 updateDataIDs( aParentData, aIndex + 1, -1, aParentDataID, aParentDataID ); |
|
258 } |
|
259 else |
|
260 ALF_THROW(AlfVisualException,EInvalidElement,"AlfElement") |
|
261 } |
|
262 |
|
263 OSN_EXPORT void AlfElement::removeVisualTree( IAlfVariantType& aData, uint aDataID ) |
|
264 { |
|
265 if ( aData.type() == IAlfVariantType::EBranch ) |
|
266 { |
|
267 // Pass to children |
|
268 IAlfBranch* branch = aData.branch(); |
|
269 int count = branch->childrenCount(); |
|
270 for ( int i = 0; i < count; ++i ) |
|
271 { |
|
272 IAlfElement* element = mData->mControl->findElement( branch->childName( i ).getUtf8() ); |
|
273 if ( element ) |
|
274 { |
|
275 removeChildVisualTree( element, *branch, i, aDataID ); |
|
276 } |
|
277 } |
|
278 } |
|
279 |
|
280 // Remove visual tree from this element |
|
281 int index = findFromArray( aDataID ); |
|
282 if (index >= 0) |
|
283 { |
|
284 CAlfVisual* visual = mData->mVisualTreeArray[index]->mVisualTree; |
|
285 visual->RemoveAndDestroyAllD(); |
|
286 mData->mVisualTreeArray.remove( index ); |
|
287 } |
|
288 else |
|
289 { |
|
290 ALF_THROW(AlfVisualException,EInvalidElement,"AlfElement") |
|
291 } |
|
292 } |
|
293 |
|
294 OSN_EXPORT void AlfElement::updateVisualTree( |
|
295 IAlfVariantType& aNewData, IAlfVariantType& aOldData, uint aDataID ) |
|
296 { |
|
297 IAlfMap* currentNewData = NULL; |
|
298 IAlfMap* currentOldData = NULL; |
|
299 IAlfBranch* branch = NULL; |
|
300 IAlfBranch* oldBranch = NULL; |
|
301 |
|
302 if ( aNewData.type()== IAlfVariantType::EMap ) |
|
303 { |
|
304 currentNewData = aNewData.map(); |
|
305 } |
|
306 else if (aNewData.type()== IAlfVariantType::EBranch) |
|
307 { |
|
308 branch = aNewData.branch(); |
|
309 currentNewData = branch->data(); |
|
310 } |
|
311 |
|
312 if (&aOldData) |
|
313 { |
|
314 if (aOldData.type()== IAlfVariantType::EMap) |
|
315 { |
|
316 currentOldData = aOldData.map(); |
|
317 } |
|
318 else if (aOldData.type()== IAlfVariantType::EBranch) |
|
319 { |
|
320 oldBranch = aOldData.branch(); |
|
321 currentOldData = aOldData.branch()->data(); |
|
322 } |
|
323 } |
|
324 |
|
325 if ( currentNewData && mData->mVisualTemplate ) |
|
326 { |
|
327 //Find the visual tree with data id |
|
328 int index = findFromArray( aDataID ); |
|
329 if (index >= 0) |
|
330 { |
|
331 // Update the contents of the visual tree |
|
332 CAlfVisual* visual = mData->mVisualTreeArray[index]->mVisualTree; |
|
333 //ALF_PERF_START( perfdata, "AlfElement-updateVisualTree-VTUpdateVisualTree") |
|
334 mData->mVisualTreeArray[index]->mVisualTree = |
|
335 mData->mVisualTemplate->updateVisualTree( |
|
336 currentNewData, currentOldData, *visual ); |
|
337 //ALF_PERF_STOP( perfdata, "AlfElement-UpdateVisualTree-VTUpdateVisualTree") |
|
338 } |
|
339 } |
|
340 |
|
341 if ( branch ) |
|
342 { |
|
343 // Pass to children |
|
344 int count = branch->childrenCount(); |
|
345 for ( int i = 0; i < count; ++i ) |
|
346 { |
|
347 IAlfElement* element = mData->mControl->findElement( branch->childName( i ).getUtf8() ); |
|
348 if ( element ) |
|
349 { |
|
350 IAlfVariantType* oldData = NULL; |
|
351 if (oldBranch) |
|
352 { |
|
353 oldData = oldBranch->childData( i ); |
|
354 } |
|
355 |
|
356 element->updateVisualTree( *branch->childData( i ), *oldData, |
|
357 mData->mControl->elementDataId( *element, i, aDataID ) ); |
|
358 } |
|
359 } |
|
360 } |
|
361 } |
|
362 |
|
363 OSN_EXPORT void AlfElement::addVisualTree(CAlfVisual* aVisualTree, uint aDataID) |
|
364 { |
|
365 int index = findFromArray( aDataID ); |
|
366 if ( index >= 0 || aVisualTree == NULL ) |
|
367 { |
|
368 ALF_THROW(AlfVisualException,EInvalidElement,"AlfElement") |
|
369 } |
|
370 // Append the visual with the assiciated data id into the array |
|
371 |
|
372 mData->mVisualTreeArray.resize(mData->mVisualTreeArray.count()+1); |
|
373 mData->mVisualTreeArray.insert(mData->mVisualTreeArray.count(),(new (EMM) AlfVisualData(aVisualTree, aDataID))); |
|
374 } |
|
375 |
|
376 OSN_EXPORT void AlfElement::replaceVisualTree( IAlfVariantType& aData, uint aDataID, uint aOldDataID ) |
|
377 { |
|
378 IAlfVariantType* oldData = control().elementData(*this, aOldDataID ); |
|
379 |
|
380 int index = findFromArray( aOldDataID ); |
|
381 if ( index < 0 ) |
|
382 { |
|
383 ALF_THROW(AlfVisualException,EInvalidElement,"AlfElement") |
|
384 } |
|
385 mData->mVisualTreeArray[index]->mDataID = aDataID; |
|
386 |
|
387 // Update the contents of the visual tree with the new data |
|
388 updateVisualTree( aData, *oldData, aDataID ); |
|
389 } |
|
390 |
|
391 OSN_EXPORT void AlfElement::updateDataIDs( |
|
392 IAlfBranch& aParentBranch, int aStartIndex, |
|
393 int aOffset, uint /*aOldParentDataId*/, uint aParentDataID ) |
|
394 { |
|
395 |
|
396 for ( int i = 0; i < mData->mVisualTreeArray.count(); ++i ) |
|
397 { |
|
398 uint oldDataID = mData->mVisualTreeArray[i]->mDataID; |
|
399 uint index = control().dataIdToIndex( *this, oldDataID ); |
|
400 uint newDataID = control().elementDataId( |
|
401 *this, index + aOffset, aParentDataID ); |
|
402 if ( index >= aStartIndex && oldDataID != newDataID ) |
|
403 { |
|
404 // Update the data ID |
|
405 mData->mVisualTreeArray[i]->mDataID = newDataID; |
|
406 // The old data ID was used to calculate the child element data IDs |
|
407 // We need to update the visual trees in child elements |
|
408 IAlfVariantType* data = aParentBranch.childData( index ); |
|
409 if ( data != NULL ) |
|
410 { |
|
411 if ( data->type() == IAlfVariantType::EBranch ) |
|
412 { |
|
413 IAlfBranch* branch = data->branch(); |
|
414 for ( int j = 0; j < branch->childrenCount(); ++j ) |
|
415 { |
|
416 IAlfElement* childElement = |
|
417 mData->mControl->findElement( branch->childName( j ).getUtf8() ); |
|
418 if ( childElement ) |
|
419 { |
|
420 childElement->updateDataIDs( |
|
421 *branch, 0, 0, oldDataID, newDataID ); |
|
422 } |
|
423 } |
|
424 } |
|
425 } |
|
426 } |
|
427 } |
|
428 } |
|
429 |
|
430 OSN_EXPORT CAlfLayout* AlfElement::defaultParentLayout(uint aParentDataID) |
|
431 { |
|
432 if (mData->mParentLayout) |
|
433 { |
|
434 CAlfVisual* visual=NULL; |
|
435 try |
|
436 { |
|
437 visual = mData->mParentLayout->resolve(*mData->mControl, aParentDataID); |
|
438 } |
|
439 catch (...) |
|
440 { |
|
441 ALF_THROW(AlfVisualException,EInvalidVisual,"AlfElement") |
|
442 } |
|
443 return (CAlfLayout *)visual; |
|
444 } |
|
445 return NULL; |
|
446 } |
|
447 |
|
448 OSN_EXPORT void AlfElement::setDefaultParentLayout(AlfReferenceToVisual* aReference) |
|
449 { |
|
450 if (mData->mParentLayout) |
|
451 { |
|
452 delete mData->mParentLayout; |
|
453 mData->mParentLayout = 0; |
|
454 } |
|
455 mData->mParentLayout = aReference; |
|
456 } |
|
457 |
|
458 OSN_EXPORT void AlfElement::setVisualTemplate(IAlfVisualTemplate& aTemplate) throw() |
|
459 { |
|
460 // Remove the visual template from its previous owner |
|
461 if(aTemplate.owner()) |
|
462 { |
|
463 aTemplate.owner()->removeVisualTemplate(); |
|
464 } |
|
465 |
|
466 // Set the visual template to this element |
|
467 mData->mVisualTemplate = &aTemplate; |
|
468 mData->mVisualTemplate->setOwner(this); |
|
469 } |
|
470 |
|
471 OSN_EXPORT IAlfVisualTemplate* AlfElement::getVisualTemplate() const throw() |
|
472 { |
|
473 return mData->mVisualTemplate; |
|
474 } |
|
475 |
|
476 OSN_EXPORT void AlfElement::destroyVisualTemplate() throw() |
|
477 { |
|
478 if (mData->mVisualTemplate) |
|
479 { |
|
480 delete mData->mVisualTemplate; |
|
481 mData->mVisualTemplate = 0; |
|
482 } |
|
483 } |
|
484 |
|
485 OSN_EXPORT IAlfVisualTemplate* AlfElement::removeVisualTemplate() throw() |
|
486 { |
|
487 IAlfVisualTemplate* ret = mData->mVisualTemplate; |
|
488 |
|
489 // Set owner to NULL in removed visual template |
|
490 if(mData->mVisualTemplate) |
|
491 { |
|
492 mData->mVisualTemplate->setOwner(0); |
|
493 } |
|
494 mData->mVisualTemplate = 0; |
|
495 |
|
496 return ret; |
|
497 } |
|
498 |
|
499 OSN_EXPORT CAlfVisual* AlfElement::findVisual(const char* aName, uint aDataID) |
|
500 { |
|
501 int index = findFromArray( aDataID ); |
|
502 if ( index < 0 ) |
|
503 { |
|
504 return NULL; |
|
505 } |
|
506 return mData->mVisualTreeArray[index]->mVisualTree->FindTag(TPtrC8((unsigned char*)aName));//Alf dependency |
|
507 } |
|
508 |
|
509 OSN_EXPORT CAlfVisual* AlfElement::findVisual(uint aDataID) |
|
510 { |
|
511 int index = findFromArray( aDataID ); |
|
512 if ( index < 0 ) |
|
513 { |
|
514 return NULL; |
|
515 } |
|
516 return mData->mVisualTreeArray[index]->mVisualTree; |
|
517 } |
|
518 |
|
519 OSN_EXPORT uint AlfElement::dataID( const CAlfVisual& aVisual ) const |
|
520 { |
|
521 for ( int i = 0; i < mData->mVisualTreeArray.count(); ++i ) |
|
522 { |
|
523 if ( mData->mVisualTreeArray[i]->mVisualTree == &aVisual ) |
|
524 { |
|
525 return mData->mVisualTreeArray[i]->mDataID; |
|
526 } |
|
527 } |
|
528 return 0; |
|
529 } |
|
530 |
|
531 int AlfElement::findFromArray( uint aDataID ) const |
|
532 { |
|
533 for ( int i = 0; i < mData->mVisualTreeArray.count(); ++i ) |
|
534 { |
|
535 if ( mData->mVisualTreeArray[i]->mDataID == aDataID ) |
|
536 { |
|
537 return i; |
|
538 } |
|
539 } |
|
540 return -1; |
|
541 } |
|
542 |
|
543 OSN_EXPORT const IAlfElement* AlfElement::parentElement() const |
|
544 { |
|
545 return mData->mParentElement; |
|
546 } |
|
547 |
|
548 OSN_EXPORT void AlfElement::setParentElement(IAlfElement& aParent) |
|
549 { |
|
550 mData->mParentElement = &aParent; |
|
551 } |
|
552 |
|
553 OSN_EXPORT CAlfWidgetControl& AlfElement::control() |
|
554 { |
|
555 return *mData->mControl; |
|
556 } |
|
557 |
|
558 OSN_EXPORT void AlfElement::removeAndDestroyVisuals( int aTimeMilliseconds ) |
|
559 { |
|
560 //remove child elements |
|
561 for (int i = 0; i<control().numElements(); i++) |
|
562 { |
|
563 IAlfElement& element = control().element(i); |
|
564 if (element.parentElement() == this) |
|
565 { |
|
566 element.removeAndDestroyVisuals(aTimeMilliseconds); |
|
567 } |
|
568 } |
|
569 |
|
570 //remove visual trees and elements, that are linked |
|
571 //to this element with parentlayout. |
|
572 for (int i = 0 ; i < mData->mVisualTreeArray.count(); i++) |
|
573 { |
|
574 AlfVisualData* vData = mData->mVisualTreeArray[i]; |
|
575 CAlfVisual* visual = vData->mVisualTree; |
|
576 if(visual) |
|
577 { |
|
578 CAlfLayout* layout = dynamic_cast<CAlfLayout*>(visual); |
|
579 if (layout) |
|
580 { |
|
581 for (int j = 0; j<control().numElements(); j++) |
|
582 { |
|
583 IAlfElement& element = control().element(j); |
|
584 CAlfLayout* parent = element.defaultParentLayout(vData->mDataID); |
|
585 if (parent && contains(*parent)) |
|
586 { |
|
587 element.removeAndDestroyVisuals(aTimeMilliseconds); |
|
588 } |
|
589 } |
|
590 } |
|
591 visual->RemoveAndDestroyAllD(); |
|
592 vData->mVisualTree = NULL; |
|
593 } |
|
594 } |
|
595 |
|
596 mData->mVisualTreeArray.clear(); |
|
597 } |
|
598 |
|
599 |
|
600 //From IAlfElement |
|
601 OSN_EXPORT bool AlfElement::contains(CAlfVisual& aVisual) const |
|
602 { |
|
603 CAlfVisual* visual = &aVisual; |
|
604 //traverse back to the root parent |
|
605 while (visual) |
|
606 { |
|
607 for (int i = 0 ; i < mData->mVisualTreeArray.count(); i++) |
|
608 { |
|
609 if (visual == mData->mVisualTreeArray[i]->mVisualTree)//is this visual parent of passed visual? |
|
610 return true; |
|
611 } |
|
612 visual = visual->Layout(); |
|
613 } |
|
614 return false; //referred visual is not part of this element. |
|
615 } |
|
616 |
|
617 // --------------------------------------------------------------------------- |
|
618 // From class IAlfInterfaceBase. |
|
619 // Getter for interfaces provided by the element. |
|
620 // --------------------------------------------------------------------------- |
|
621 // |
|
622 OSN_EXPORT IAlfInterfaceBase* AlfElement::makeInterface( const IfId& aType ) |
|
623 { |
|
624 UString param(aType.mImplementationId); |
|
625 if (param == IAlfElement::type().mImplementationId) |
|
626 { |
|
627 return static_cast<IAlfElement*>(this); |
|
628 } |
|
629 else if (param == IAlfAttributeOwner::type().mImplementationId) |
|
630 { |
|
631 return static_cast<IAlfAttributeOwner*>(mData->mAttributeOwnerImpl.get()); |
|
632 } |
|
633 return NULL; |
|
634 } |
|
635 |
|
636 } // Alf |
|