/*

* Copyright (c) 2002-2004 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:  Node of the layout tree

*

*/

// INCLUDES

#include "xnnode.h"

#include "xnnodepluginif.h"

#include "xnnodeappif.h"

#include "xnnodeimpl.h"

#include "xnviewsnodeimpl.h"

#include "xnviewnodeimpl.h"

#include "xncomponentnodeimpl.h"

#include "xnproperty.h"

#include "xntype.h"

#include "xncomponent.h"

#include "xnscrollablecontroladapter.h"

_LIT8( KView, "view" );

// ============================ MEMBER FUNCTIONS ===============================

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

// CXnNode::NewL()

// Two-phased constructor.

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

//

CXnNode* CXnNode::NewL()

    {

    CXnNode* self = new ( ELeave ) CXnNode;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CXnNode::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CXnNode::ConstructL()

    {

    }

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

// CXnNode::CXnNode()

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CXnNode::CXnNode()

    {

    }

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

// CXnNode::~CXnNode()

// C++ default destructor.

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

//

CXnNode::~CXnNode()

    {

    delete iImpl;

    delete iPluginIf;

    delete iAppIf;

    }

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

// CXnNode::Impl

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

//

CXnNodeImpl* CXnNode::Impl()

    {

    return iImpl;

    }

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

// CXnNode::RootNodeImpl

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

//

CXnNodeImpl* CXnNode::RootNodeImpl()

    {

    return iRootNodeImpl;

    }

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

// CXnNode::ViewNodeImpl

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

//

CXnViewNodeImpl* CXnNode::ViewNodeImpl()

    {

    return iViewNodeImpl;

    }

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

// CXnNode::ComponentNodeImpl

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

//

CXnComponentNodeImpl* CXnNode::ComponentNodeImpl()

    {

    return iComponentNodeImpl;

    }

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

// CXnNode::SetImpl

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

//

void CXnNode::SetImpl( CXnNodeImpl* aImpl )

    {

    if ( aImpl )

        {

        delete iImpl;

        iImpl = aImpl;

        iImpl->SetNode( *this );

        }

    }

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

// CXnNode::SetRootNodeImpl

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

//

void CXnNode::SetRootNodeImpl( CXnNodeImpl* aRootNodeImpl )

    {

    if ( aRootNodeImpl )

        {

        delete iImpl;

        iRootNodeImpl = aRootNodeImpl;

        iImpl = iRootNodeImpl;

        iImpl->SetNode( *this );

        }

    }

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

// CXnNode::SetViewsNodeImpl

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

//

void CXnNode::SetViewsNodeImpl( CXnViewsNodeImpl* aViewsNodeImpl )

    {

    if ( aViewsNodeImpl )

        {

        delete iImpl;

        iViewsNodeImpl = aViewsNodeImpl;

        iImpl = iViewsNodeImpl;

        iImpl->SetNode( *this );

        }

    }

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

// CXnNode::SetViewNodeImpl

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

//

void CXnNode::SetViewNodeImpl( CXnViewNodeImpl* aViewNodeImpl )

    {

    if ( aViewNodeImpl )

        {

        delete iImpl;

        iViewNodeImpl = aViewNodeImpl;

        iImpl = iViewNodeImpl;

        iImpl->SetNode( *this );

        }

    }

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

// CXnNode::SetComponentNodeImpl

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

//

void CXnNode::SetComponentNodeImpl( CXnComponentNodeImpl* aComponentNodeImpl )

    {

    if ( aComponentNodeImpl )

        {

        delete iImpl;

        iComponentNodeImpl = aComponentNodeImpl;

        iImpl = iComponentNodeImpl;

        iImpl->SetNode( *this );

        }

    }

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

// CXnNode::SetDropped

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

//

void CXnNode::SetDropped( const TInt aDropped )

    {

    iImpl->SetDropped( aDropped );

    }

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

// CXnNode::IsDropped

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

//

TInt CXnNode::IsDropped() const

    {

    return iImpl->IsDropped();

    }

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

// CXnNode::Type()

// Returns control type.

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

//

CXnType* CXnNode::Type()

    {

    return iImpl->Type();

    }

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

// CXnNode::Parent

// Get component parent

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

//

CXnNode* CXnNode::Parent() const

    {

    return iImpl->Parent();

    }

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

// CXnNode::SetParent

// Set component parent

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

//

void CXnNode::SetParent( CXnNode& aParent )

    {

    iImpl->SetParent( aParent );

    }

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

// CXnNode::AddChildL

// Adds a child to this container.

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

//

void CXnNode::AddChildL( CXnNode* aChild )

    {

    if ( aChild )

        {

        iImpl->AddChildL( aChild );

        }

    }

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

// CXnNode::Children

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

//

RPointerArray< CXnNode >& CXnNode::Children()

    {

    return iImpl->Children();

    }

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

// CXnNode::SetPCDataL

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

void CXnNode::SetPCDataL( const TDesC8& aData )

    {

    iImpl->SetPCDataL( aData );

    }

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

// CXnNode::GetPCData

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

const TDesC8& CXnNode::GetPCData() const

    {

    return iImpl->GetPCData();

    }

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

// CXnNode::SetPropertyWithoutNotificationL

// Set a property.

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

//

void CXnNode::SetPropertyWithoutNotificationL( CXnProperty* aProperty )

    {

    if ( aProperty )

        {

        iImpl->SetPropertyWithoutNotificationL( aProperty );

        }

    }

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

// CXnNode::SetPropertyL

// Set a property.

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

//

void CXnNode::SetPropertyL( CXnProperty* aProperty )

    {

    if ( aProperty )

        {

        iImpl->SetPropertyL( aProperty );

        }

    }

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

// CXnNode::SetPropertyArrayL

// Set a property array.

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

//

void CXnNode::SetPropertyArrayL( RPointerArray< CXnProperty >* aPropertyArray )

    {

    if ( aPropertyArray )

        {

        iImpl->SetPropertyArrayL( *aPropertyArray );

        }

    }

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

// CXnNode::InitializePropertyL

// Set a property.

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

//

void CXnNode::InitializePropertyL( CXnProperty* aProperty )

    {

    if ( aProperty )

        {

        iImpl->InitializePropertyL( aProperty );

        }

    }

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

// CXnNode::GetProperty

// Gets a property.

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

//

CXnProperty* CXnNode::GetPropertyL( const TDesC8& aKey ) const

    {

    return iImpl->GetPropertyL( aKey );

    }

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

// CXnNode::SetStateL

// Set a state

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

//

void CXnNode::SetStateL( const TDesC8& aState, TInt aSource )

    {

    iImpl->SetStateL( aState, aSource );

    }

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

// CXnNode::IsStateSet

// Check whether a state is set or not

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

//

TBool CXnNode::IsStateSet( const TDesC8& aState )

    {

    return iImpl->IsStateSet( aState );

    }

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

// CXnNode::SetStateWithoutNotificationL

// Set a state

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

//

void CXnNode::SetStateWithoutNotificationL( const TDesC8& aState )

    {

    iImpl->SetStateWithoutNotificationL( aState );

    }

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

// CXnNode::UnsetState

// Unset a pseudoclass

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

//

void CXnNode::UnsetStateL( const TDesC8& aState )

    {

    iImpl->UnsetStateL( aState );

    }

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

// CXnNode::SetRect

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

//

void CXnNode::SetRect( const TRect& aRect )

    {

    iImpl->SetRect( aRect );

    }

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

// CXnNode::Rect

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

//

TRect CXnNode::Rect()

    {

    return iImpl->Rect();

    }

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

// CXnNode::SetBorderRect

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

//

void CXnNode::SetBorderRect( const TRect& aRect )

    {

    iImpl->SetBorderRect( aRect );

    }

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

// CXnNode::BorderRect

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

//

TRect CXnNode::BorderRect()

    {

    return iImpl->BorderRect();

    }

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

// CXnNode::SetNormalFlowBorderRect

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

//

void CXnNode::SetNormalFlowBorderRect( const TRect& aRect )

    {

    iImpl->SetNormalFlowBorderRect( aRect );

    }

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

// CXnNode::NormalFlowBorderRect

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

//

TRect CXnNode::NormalFlowBorderRect()

    {

    return iImpl->NormalFlowBorderRect();

    }

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

// CXnNode::SetMarginRect

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

//

void CXnNode::SetMarginRect( const TRect& aRect )

    {

    iImpl->SetMarginRect( aRect );

    }

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

// CXnNode::MarginRect

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

//

TRect CXnNode::MarginRect()

    {

    return iImpl->MarginRect();

    }

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

// CXnNode::SetPaddingRect

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

//

void CXnNode::SetPaddingRect( const TRect& aRect )

    {

    iImpl->SetPaddingRect( aRect );

    }

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

// CXnNode::PaddingRect

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

//

TRect CXnNode::PaddingRect()

    {

    return iImpl->PaddingRect();

    }

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

// CXnNode::SetUiEngine

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

//

void CXnNode::SetUiEngine( CXnUiEngine& aEngine )

    {

    iImpl->SetUiEngine( aEngine );

    }

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

// CXnNode::UiEngine

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

//

CXnUiEngine* CXnNode::UiEngine()

    {

    return iImpl->UiEngine();

    }

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

// CXnNode::ReportXuikonEventL

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

//

TBool CXnNode::ReportXuikonEventL( CXnNode& aEventData, TInt aSource )

    {

    return iImpl->ReportXuikonEventL( aEventData, aSource );

    }

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

// CXnNode::OfferKeyEventL

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

//

void CXnNode::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )

    {

    iImpl->OfferKeyEventL( aKeyEvent, aType );

    }

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

// CXnNode::SetLayoutCapable

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

//

void CXnNode::SetLayoutCapable( const TBool aLayoutCapable )

    {

    iImpl->SetLayoutCapable( aLayoutCapable );

    }

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

// CXnNode::SetLayoutCapable

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

//

TBool CXnNode::IsLayoutCapable() const

    {

    return iImpl->IsLayoutCapable();

    }

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

// CXnNodeImpl::SetRenderedL

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

//

void CXnNode::SetRenderedL()