/*

* Copyright (c) 2002-2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  Implementation part of bridge pattern in CXnNode

*

*/

// System includes

#include <AknUtils.h>

#include <utf.h>

#include <mmf/common/mmfcontrollerpluginresolver.h>

// User includes

#include "xnnodeimpl.h"

#include "xnnode.h"

#include "xnpropertylist.h"

#include "xnproperty.h"

#include "xnuiengine.h"

#include "xnappuiadapter.h"

#include "xncontroladapter.h"

#include "xnpopupcontroladapter.h"

#include "xnmenuadapter.h"

#include "xndomlist.h"

#include "xndomdocument.h"

#include "xnpointerarray.h"

#include "xnodt.h"

#include "xntype.h"

#include "xndomnode.h"

#include "xndomattribute.h"

#include "xndompropertyvalue.h"

#include "xnpopup.h"

#include "c_xnutils.h"

#include "xneditmode.h"

#include "xneditor.h"

#include "xntext.h"

#include "xnscrollablecontroladapter.h"

#include "xnviewdata.h"

#include "xnrootdata.h"

#include "xnpanic.h"

#include "xnlistquerydialogadapter.h"

#include "xneffectmanager.h"

#include "xnviewadapter.h"

#include "xnbackgroundmanager.h"

#include "xntexteditor.h"

// Local constants

_LIT8( KId, "id" );

_LIT8( KName, "name" );

_LIT8( KToolTip, "tooltip" );

_LIT8( KMenuBar, "menubar" );

_LIT8( KTextEditor, "texteditor" );

_LIT8( KPlugin, "plugin" );

_LIT8( KActionsHandler, "actionshandler" );

const TInt KUnitMaxLen = 2;

const TInt KOneView = 1;

_LIT8( KPseudoClassFocus, "focus" );

_LIT8( KPseudoClassPressedDown, "presseddown" );

_LIT8( KPseudoClassPassiveFocus, "passivefocus" );

_LIT8( KPseudoClassHold, "hold" );

_LIT8( KPseudoClassHover, "hover" );

_LIT8( KPseudoClassLink, "link" );

_LIT8( KPseudoClassVisited, "visited" );

_LIT8( KPseudoClassActive, "active" );

_LIT8( KPseudoClassEdit, "edit" );

_LIT8( KCompound, "compound" );

_LIT8( KTrue, "true" );

_LIT8( KDisplay, "display" );

_LIT8( KBlock, "block" );

_LIT8( KNone, "none" );

_LIT8( KGainEnd, "gainend" );

_LIT8( KLoseEnd, "loseend" );

struct CLayoutPropertyCache : public CBase

    {

    CLayoutPropertyCache() :

        iWidths( 1 ),

        iHeights( 1 ),

        iMarginLefts( 1 ),

        iMarginRights( 1 ),

        iBorderLefts( 1 ),

        iBorderRights( 1 ),

        iPaddingLefts( 1 ),

        iPaddingRights( 1 ),

        iMarginTops( 1 ),

        iMarginBottoms( 1 ),

        iBorderTops( 1 ),

        iBorderBottoms( 1 ),

        iPaddingTops( 1 ),

        iPaddingBottoms( 1 ),

        iBorderWidths( 1 ),

        iBlockProgressions( 1 ),

        iDirections( 1 ),

        iPositions( 1 ),

        iMaxHeights( 1 ),

        iMinHeights( 1 ),

        iMaxWidths( 1 ),

        iMinWidths( 1 ),

        iDisplays( 2 ),

        iVisibilities( 1 ),

        iLefts( 1 ),

        iRights( 1 ),

        iTops( 1 ),

        iBottoms( 1 ),

        iBorderLeftStyles( 1 ),

        iBorderRightStyles( 1 ),

        iBorderTopStyles( 1 ),

        iBorderBottomStyles( 1 ),

        iBorderStyles( 1 ),

        iDisplayPriorities( 1 ),

        iNavIndexes( 1 ),

        iBackgroundColors( 1 ),

        iBackgroundImages( 1 ),

        iFocusBackgrounds( 2 )

            {

            }

    ~CLayoutPropertyCache()

        {

        iWidths.Reset();

        iHeights.Reset();

        iMarginLefts.Reset();

        iMarginRights.Reset();

        iBorderLefts.Reset();

        iBorderRights.Reset();

        iPaddingLefts.Reset();

        iPaddingRights.Reset();

        iMarginTops.Reset();

        iMarginBottoms.Reset();

        iBorderTops.Reset();

        iBorderBottoms.Reset();

        iPaddingTops.Reset();

        iPaddingBottoms.Reset();

        iBorderWidths.Reset();

        iBlockProgressions.Reset();

        iDirections.Reset();

        iPositions.Reset();

        iMaxHeights.Reset();

        iMinHeights.Reset();

        iMaxWidths.Reset();

        iMinWidths.Reset();

        iDisplays.Reset();

        iVisibilities.Reset();

        iLefts.Reset();

        iRights.Reset();

        iTops.Reset();

        iBottoms.Reset();

        iBorderLeftStyles.Reset();

        iBorderRightStyles.Reset();

        iBorderTopStyles.Reset();

        iBorderBottomStyles.Reset();

        iBorderStyles.Reset();

        iDisplayPriorities.Reset();

        iNavIndexes.Reset();

        iBackgroundColors.Reset();

        iZIndexes.Reset();

        iBackgroundImages.Reset();

        iFocusBackgrounds.Reset();

        }

    CXnProperty* iWidth;

    RPointerArray< CXnProperty > iWidths;

    CXnProperty* iHeight;

    RPointerArray< CXnProperty > iHeights;

    CXnProperty* iMarginLeft;

    RPointerArray< CXnProperty > iMarginLefts;

    CXnProperty* iMarginRight;

    RPointerArray< CXnProperty > iMarginRights;

    CXnProperty* iBorderLeft;

    RPointerArray< CXnProperty > iBorderLefts;

    CXnProperty* iBorderRight;

    RPointerArray< CXnProperty > iBorderRights;

    CXnProperty* iPaddingLeft;

    RPointerArray< CXnProperty > iPaddingLefts;

    CXnProperty* iPaddingRight;

    RPointerArray< CXnProperty > iPaddingRights;

    CXnProperty* iMarginTop;

    RPointerArray< CXnProperty > iMarginTops;

    CXnProperty* iMarginBottom;

    RPointerArray< CXnProperty > iMarginBottoms;

    CXnProperty* iBorderTop;

    RPointerArray< CXnProperty > iBorderTops;

    CXnProperty* iBorderBottom;

    RPointerArray< CXnProperty > iBorderBottoms;

    CXnProperty* iPaddingTop;

    RPointerArray< CXnProperty > iPaddingTops;

    CXnProperty* iPaddingBottom;

    RPointerArray< CXnProperty > iPaddingBottoms;

    CXnProperty* iBorderWidth;

    RPointerArray< CXnProperty > iBorderWidths;

    CXnProperty* iBlockProgression;

    RPointerArray< CXnProperty > iBlockProgressions;

    CXnProperty* iDirection;

    RPointerArray< CXnProperty > iDirections;

    CXnProperty* iPosition;

    RPointerArray< CXnProperty > iPositions;

    CXnProperty* iMaxHeight;

    RPointerArray< CXnProperty > iMaxHeights;

    CXnProperty* iMinHeight;

    RPointerArray< CXnProperty > iMinHeights;

    CXnProperty* iMaxWidth;

    RPointerArray< CXnProperty > iMaxWidths;

    CXnProperty* iMinWidth;

    RPointerArray< CXnProperty > iMinWidths;

    CXnProperty* iDisplay;

    RPointerArray< CXnProperty > iDisplays;

    CXnProperty* iVisibility;

    RPointerArray< CXnProperty > iVisibilities;

    CXnProperty* iLeft;

    RPointerArray< CXnProperty > iLefts;

    CXnProperty* iRight;

    RPointerArray< CXnProperty > iRights;

    CXnProperty* iTop;

    RPointerArray< CXnProperty > iTops;

    CXnProperty* iBottom;

    RPointerArray< CXnProperty > iBottoms;

    CXnProperty* iBorderLeftStyle;

    RPointerArray< CXnProperty > iBorderLeftStyles;

    CXnProperty* iBorderRightStyle;

    RPointerArray< CXnProperty > iBorderRightStyles;

    CXnProperty* iBorderTopStyle;

    RPointerArray< CXnProperty > iBorderTopStyles;

    CXnProperty* iBorderBottomStyle;

    RPointerArray< CXnProperty > iBorderBottomStyles;

    CXnProperty* iBorderStyle;

    RPointerArray< CXnProperty > iBorderStyles;

    CXnProperty* iBorderImage;

    CXnProperty* iDisplayPriority;

    RPointerArray< CXnProperty > iDisplayPriorities;

    CXnProperty* iNavIndex;

    RPointerArray< CXnProperty > iNavIndexes;

    CXnProperty* iZIndex;

    RPointerArray< CXnProperty > iZIndexes;

    CXnProperty* iBackgroundColor;

    RPointerArray< CXnProperty > iBackgroundColors;

    CXnProperty* iBackgroundImage;

    RPointerArray< CXnProperty > iBackgroundImages;

    CXnProperty* iFocusBackground;

    RPointerArray< CXnProperty > iFocusBackgrounds;

    };

// Local function prototypes

static TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode );

static TBool DoMatchTriggerForKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType,

    CXnDomNode& aTriggerNode );

static void GetFocusCandidatesL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode,

    RPointerArray< CXnNode >& aFocusCandidates );

static void RunAppUiNotificationL( CXnUiEngine& aEngine, CXnNode& aNode,

    CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

static void RunFullScreenEffectL(

    CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunActivateNextViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunActivatePreviousViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunAddViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunRemoveViewL( CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunActivateL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunActivateEditorL( CXnNodeImpl* aThis, CXnNode& aLayoutNode,

    CXnUiEngine& aEngine, CXnDomNode& aEventNode, TBool aActivate );

static void RunDeactivateL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunSystemSetPCDataL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, const TDesC8& aId,

    const TDesC8& aData );

static void GetNumberValues( const TDesC8& aData, TReal& aNumber,

    CXnDomPropertyValue::TPrimitiveValueType& aValueType );

static void RunSystemSetNumberL( CXnUiEngine& aEngine, CXnNode* aNode,

    const TDesC8& aName, const RPointerArray< HBufC8 >& aValues );

static void RunSystemSetRGBL( CXnUiEngine& aEngine, CXnNode* aNode,

    const TDesC8& aName, const RPointerArray< HBufC8 >& aValues );

static void RunSystemSetStringL(

    CXnUiEngine& aEngine, CXnNode* aNode, const TDesC8& aName,

    const RPointerArray< HBufC8 >& aValues,

    const CXnDomPropertyValue::TPrimitiveValueType aValueType );

static void GetSystemSetDataL( CXnDomNode& aDomNode, HBufC8*& aId,

    const TDesC8** aPseudoClass = NULL, const TDesC8** aName = NULL,

    RPointerArray< HBufC8 >* aValues = NULL, const TDesC8** aType = NULL,

    TBool aSettings = EFalse, const TDesC8& aProvidedId = KNullDesC8,

    const TDesC8** aClassId = NULL );

static void RunSystemSetL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode,

    TBool aSettings = EFalse, const TDesC8& aId = KNullDesC8 );

static void RunTryDisplayingMenuL(

    CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunTryDisplayingStylusPopupL(

    CXnNodeImpl* aThis, CXnNode& aNode, CXnUiEngine& aEngine,

    CXnDomNode& aEventNode );

static void RunTryDisplayingListQueryDialogL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnDomNode& aEventNode );

static void RunSetInitialFocusL( CXnUiEngine& aEngine );

static TBool RunEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    CXnDomNode& aEventNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

static void RunEventsL( CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    CXnDomNode& aActionNode, CXnDomNode& aTriggerNode, CXnNode& aEventData );

static TBool DoMatchTriggerForHighLevelKeyEventL( CXnNode& aNode,

    const TKeyEvent& aKeyEvent, TEventCode aType, const TDesC8& highLevelKey );

static TBool MatchTriggerForKeyEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    const TKeyEvent& aKeyEvent, TEventCode aType,

    CXnDomNode& aActionNode, CXnDomNode& aTriggerNode );

static TBool MatchTriggerForEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    CXnNode& aEventData, CXnDomNode& aActionNode, CXnDomNode& aTriggerNode,

    TInt aSource );

static TBool MatchActionForKeyEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    const TKeyEvent& aKeyEvent, TEventCode aType, CXnDomNode& aActionNode );

static TBool IsTriggerActiveL( CXnDomNode& aNode );

static TBool MatchActionForEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    CXnNode& aEventData, CXnDomNode& aActionNode, TInt aSource );

static CXnNode* FindLoopedFocusableNodeL( CXnNode& aNode, TBool aForward );

static CXnNode* FindNextFocusableNodeByNavIndexL( CXnNode& aNode, TBool aForward );

static TBool FindNextFocusableNodeL( CXnNode& aNode, TBool aForward );

static CXnNode* FindNextNodeFromRightL(

    RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse, CXnUiEngine* aEngine = NULL );

static CXnNode* FindNextNodeFromLeftL(

    RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse, CXnUiEngine* aEngine = NULL );

static CXnNode* FindNextNodeFromBelowL(

    RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse );

static CXnNode* FindNextNodeFromAboveL(

    RPointerArray< CXnNode >& aArray, CXnNode& aNode, TBool stayInNamespace = EFalse );

static CXnNode* FindPluginNode( CXnNode& aNode );

static TBool DoInternalFocusChangeL(

    CXnUiEngine& aEngine, CXnNode& aNode, const TKeyEvent& aKeyEvent,

    TEventCode aType );

static TBool DoTriggerKeyEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    const TKeyEvent& aKeyEvent, TEventCode aType );

static void DoTriggerEventL(

    CXnNodeImpl* aThis, CXnUiEngine& aEngine, CXnNode& aNode,

    CXnNode& aActionsParent, CXnNode& aEventData, TInt aSource );

static TBool DoReceiveFocusL( CXnNode& aNode, CXnUiEngine& aEngine );

static void InformPropertyChangeL( CXnNode& aNode, CXnProperty* aProperty = NULL );

static CXnNode* BuildEventTypeNodeL( TEventCode aType, CXnUiEngine& aUiEngine );

static CXnNode* BuildModifiersNodeL(

    const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

static CXnNode* BuildKeyCodeNodeL(

    const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

static CXnNode* BuildScanCodeNodeL(

    const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

static CXnNode* BuildRepeatsNodeL(

    const TKeyEvent& aKeyEvent, CXnUiEngine& aUiEngine );

static void BuildPropertyNodesL( CXnNode& aNode, const TKeyEvent& aKeyEvent,

    TEventCode aType, CXnUiEngine& aUiEngine );

static CXnNode* BuildKeyTriggerNodeL( const TKeyEvent& aKeyEvent, TEventCode aType,

    CXnUiEngine& aUiEngine );

static CXnDomPropertyValue* GetNavIndexL( CXnNode& aNode );

static CXnNode* BackwardL( CXnNode& aNode );

static CXnNode* ForwardL( CXnNode& aNode );

static CXnNode* BackwardLoopL( CXnNode& aNode );

static CXnNode* ForwardLoopL( CXnNode& aNode );

static TInt CompareNavIndexesL(

    CXnDomPropertyValue* aCurrentPropertyValue,

    CXnDomPropertyValue* aNextPropertyValue );

static void ReplaceOrAppend(

    CXnProperty* aProperty, RPointerArray< CXnProperty >& aArray,

    TBool aAppendOnly );

static TBool DisplayValueMatchL( CXnNode& aNode, const TDesC8& aDisplayValue );

static void SetStringPropertyToNodeL(

    CXnDomStringPool& aStringPool, CXnNode& aNode,

    const TDesC8& aPropertyName, const TDesC8& aPropertyValue );

static void SetFloatPropertyToNodeL(

    CXnDomStringPool& aStringPool, CXnNode& aNode,

    const TDesC8& aPropertyName, TReal aPropertyValue,

    CXnDomPropertyValue::TPrimitiveValueType aValueType );

static CXnNode* FindYoungestSiblingWithDisplayL(

    RPointerArray< CXnNode >& aSiblingArray,

    const TDesC8& aDisplayValue,

    TInt& aIndex );

static CXnNode* FindOldestSiblingWithDisplayL(

    RPointerArray< CXnNode >& aSiblingArray,

    const TDesC8& aDisplayValue,

    TInt& aIndex );

static TBool IsCompoundNodeL( CXnNode* aNode );

static void NotifyScrollNodeL( CXnNode* aNode, TBool aBegin, TBool aGainEnd );

static void DoCompoundNodeBeginKeyL(

    RPointerArray< CXnNode >& aChildren, CXnNode* aFocusedNode );

static void DoCompoundNodeEndKeyL(

    RPointerArray< CXnNode >& aChildren, CXnNode* aFocusedNode );

static void DoCompoundNodeScrollingL(

    CXnNode& aFocusedNode,

    const TKeyEvent& aKeyEvent,

    TEventCode aType );

static CXnNode* BuildTriggerNodeL(

    CXnUiEngine& aUiEngine, const TDesC8& aTriggerName );

static CXnNode* IsNodeNavigableL( CXnNode* aParent );

static TBool IsNodeNavigableL( CXnNode& aNode, TBool aIgnoreDropped = EFalse );

static TInt DirtyLevelFromPropertyL( CXnNode& aNode, const TDesC8& aPropName );

static TBool IsNodeDisplayedL(

    CXnNode& aNode, TBool aCheckVisiblity = EFalse, TBool aCheckParent = ETrue );

static void EnableStatePropertyL(

    CXnNode& aNode,

    CXnDomProperty::TPseudoClass aPseudoClass,

    CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

    CXnProperty*& aProperty,

    RPointerArray< CXnProperty >& aArray, TInt& aLevel,

    TBool aInformChange = EFalse );

static void DisableStatePropertyL(

    CXnNode& aNode,

    CXnDomProperty::TPseudoClass aPseudoClass,

    CXnProperty* ( CXnNode::* aGetCachedPropertyL )(),

    CXnProperty*& aProperty,

    RPointerArray< CXnProperty >& aArray,

    RArray< CXnDomProperty::TPseudoClass >& aStates, TInt& aLevel,

    TBool aInformChange = EFalse );

static TBool MatchTitleScrollTriggerL(

    CXnNode& aEventData, CXnDomNode& aTriggerNode );

// ============================= LOCAL FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// ResolveEffectId

// -----------------------------------------------------------------------------

//

static TInt ResolveEffectId( CXnDomNode& aEventNode )

    {

    TInt effect( 0 );

    const TDesC8& value( aEventNode.AttributeValue( 

        XnPropertyNames::common::KEffectId ) );

    if( value != KNullDesC8 )

        {

        TLex8 lex( value );

        lex.Val( effect );    

        }

    return effect;

    }

// -----------------------------------------------------------------------------

// Checks whether trigger is runnable

// -----------------------------------------------------------------------------

//

TBool IsTriggerRunnableL( CXnDomNode& aTriggerNode )

    {

    TBool ret( ETrue );

    CXnNode* layoutNode = aTriggerNode.LayoutNode();

    if ( layoutNode )

        {

        CXnProperty* display =

            layoutNode->GetPropertyL( XnPropertyNames::style::common::KDisplay );

        if ( display && display->StringValue() ==

             XnPropertyNames::style::common::display::KNone )

            {

            ret = EFalse;

            }

        }

    return ret;

    }

// -----------------------------------------------------------------------------

// DirtyLevelFromPropertyL

// -----------------------------------------------------------------------------

//

static TInt DirtyLevelFromPropertyL( CXnNode& aNode, const TDesC8& aPropName )

    {

    if ( aPropName == XnPropertyNames::style::common::KDisplay ||

        aPropName == XnPropertyNames::style::common::KBlockProgression ||

        aPropName == XnPropertyNames::style::common::KDirection ||

        aPropName == XnPropertyNames::style::common::KPosition ||

        aPropName == XnPropertyNames::style::common::KTop ||

        aPropName == XnPropertyNames::style::common::KLeft ||

        aPropName == XnPropertyNames::style::common::KBottom ||

        aPropName == XnPropertyNames::style::common::KRight ||

        aPropName == XnPropertyNames::style::common::KWidth ||

        aPropName == XnPropertyNames::style::common::KHeight ||

        aPropName == XnPropertyNames::style::common::KMinWidth ||

        aPropName == XnPropertyNames::style::common::KMaxWidth ||

        aPropName == XnPropertyNames::style::common::KMinHeight ||

        aPropName == XnPropertyNames::style::common::KMaxHeight ||

        aPropName == XnPropertyNames::style::common::KS60DisplayPriority ||

        aPropName == XnPropertyNames::style::common::KMarginTop ||

        aPropName == XnPropertyNames::style::common::KMarginRight ||

        aPropName == XnPropertyNames::style::common::KMarginBottom ||

        aPropName == XnPropertyNames::style::common::KMarginLeft ||

        aPropName == XnPropertyNames::style::common::KBorderWidth ||

        aPropName == XnPropertyNames::style::common::KBorderTopWidth ||

        aPropName == XnPropertyNames::style::common::KBorderRightWidth ||

        aPropName == XnPropertyNames::style::common::KBorderBottomWidth ||

        aPropName == XnPropertyNames::style::common::KBorderLeftWidth ||

        aPropName == XnPropertyNames::style::common::KBorderLeftWidth ||

        aPropName == XnPropertyNames::style::common::KPaddingRight ||

        aPropName == XnPropertyNames::style::common::KPaddingBottom ||

        aPropName == XnPropertyNames::style::common::KPaddingLeft )

        {

        TInt retval( XnDirtyLevel::ELayoutAndRenderSiblings );

        CXnProperty* prop( aNode.PositionL() );

        if ( prop )

            {

            const TDesC8& value( prop->StringValue() );

            if ( value == XnPropertyNames::style::common::position::KAbsolute ||

                 value == XnPropertyNames::style::common::position::KFloating )

                {

                retval = XnDirtyLevel::ELayoutAndRender;

                }

            }

        if ( aNode.Type()->Type() == KToolTip )

            {

            retval = XnDirtyLevel::ELayoutAndRender;

            }

        return retval;

        }