/*

* 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 "xnnodeappif.h"

#include "xntype.h"

#include "xnuiengine.h"

#include "xndomnode.h"

#include "xncomponent.h"

#include "xncomponentnodeimpl.h"

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

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

// CXnNodeAppIf::CXnNodeAppIf()

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

// might leave.

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

//

CXnNodeAppIf::CXnNodeAppIf( CXnNode& aNode )

    {

    iNode = &aNode;

    }

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

// CXnNodeAppIf::Type()

// Returns control type.

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

//

EXPORT_C CXnType* CXnNodeAppIf::Type()

    {

    return iNode->Type();

    }

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

// CXnNodeAppIf::SetPCDataL

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

//

EXPORT_C void CXnNodeAppIf::SetPCDataL( const TDesC8& aData )

    {

    iNode->SetPCDataL( aData );

    }

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

// CXnNodeAppIf::GetPCData

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

//

EXPORT_C const TDesC8& CXnNodeAppIf::GetPCData() const

    {

    return iNode->GetPCData();

    }

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

// CXnNodeAppIf::SetPropertyL

// Set a property.

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

//

EXPORT_C void CXnNodeAppIf::SetPropertyL( CXnProperty* aProperty )

    {

    iNode->SetPropertyL( aProperty );

    }

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

// CXnNodeAppIf::SetPropertyArrayL

// Set a property array.

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

//

EXPORT_C void CXnNodeAppIf::SetPropertyArrayL(

    RPointerArray< CXnProperty >* aPropertyArray )

    {

    iNode->SetPropertyArrayL( aPropertyArray );

    }

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

// CXnNodeAppIf::GetProperty

// Gets a property.

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

//

EXPORT_C CXnProperty* CXnNodeAppIf::GetPropertyL( CXnProperty& /*aProperty*/ ) const

    {

    return NULL;//return iNode->GetPropertyL(aProperty);

    }

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

// CXnNodeAppIf::GetProperty

// Gets a property.

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

//

EXPORT_C CXnProperty* CXnNodeAppIf::GetPropertyL( const TDesC8& aKey ) const

    {

    return iNode->GetPropertyL( aKey );

    }

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

// CXnNodeAppIf::SetStateL

// Set a state

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

//

EXPORT_C void CXnNodeAppIf::SetStateL( const TDesC8& aState )

    {

    iNode->SetStateL( aState );

    }

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

// CXnNodeAppIf::IsStateSet

// Check whether a state is set or not

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

//

EXPORT_C TBool CXnNodeAppIf::IsStateSet( const TDesC8& aState )

    {

    return iNode->IsStateSet( aState );

    }

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

// CXnNodeAppIf::UnsetState

// Unset a pseudoclass

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

//

EXPORT_C void CXnNodeAppIf::UnsetStateL( const TDesC8& aState )

    {

    iNode->UnsetStateL( aState );

    }

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

// CXnNodeAppIf::Rect

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

//

EXPORT_C TRect CXnNodeAppIf::Rect()

    {

    return iNode->Rect();

    }

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

// CXnNodeAppIf::BorderRect

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

//

EXPORT_C TRect CXnNodeAppIf::BorderRect()

    {

    return iNode->BorderRect();

    }

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

// CXnNodeAppIf::MarginRect

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

//

EXPORT_C TRect CXnNodeAppIf::MarginRect()

    {

    return iNode->MarginRect();

    }

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

// CXnNodeAppIf::PaddingRect

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

//

EXPORT_C TRect CXnNodeAppIf::PaddingRect()

    {

    return iNode->PaddingRect();

    }

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

// CXnNodeAppIf::UiEngine

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

//

EXPORT_C TXnUiEngineAppIf* CXnNodeAppIf::UiEngineL()

    {

    return &(iNode->UiEngine()->AppIfL());

    }

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

// Get internal node

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

//

CXnNode& CXnNodeAppIf::Node()

    {

    return *iNode;

    }

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

// CXnNodeAppIf::MakeInterfaceL

// Create a component interface according to the given type.

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

//

EXPORT_C XnComponentInterface::MXnComponentInterface* CXnNodeAppIf::MakeInterfaceL(

    const TDesC8& aType )

    {

    return iNode->MakeInterfaceL( aType );

    }

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

// CXnNodeAppIf::Children

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

//

EXPORT_C RPointerArray< CXnNodeAppIf > CXnNodeAppIf::ChildrenL()

    {

    RPointerArray< CXnNode >& nodes = iNode->Children();

    RPointerArray< CXnNodeAppIf > appNodes;

    CleanupClosePushL( appNodes );

    TInt count = nodes.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        appNodes.AppendL( &nodes[i]->AppIfL() );

        }

    CleanupStack::Pop( &appNodes );

    // Compiler will generate bitwise copy ctor, thus

    // caller of this function must call reset or close for copied RPointerArrays,

    // which is very nasty thing to do...

    return appNodes;

    }

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

// CXnNodeAppIf::ParentL

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

//

EXPORT_C CXnNodeAppIf* CXnNodeAppIf::ParentL() const

    {

    CXnNode* parent = iNode->Parent();

    if ( !parent )

        {

        return NULL;

        }

    return &( parent->AppIfL() );

    }

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

// CXnNodeAppIf::InternalDomNodeType

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

//

EXPORT_C const TDesC8& CXnNodeAppIf::InternalDomNodeType() const

    {

    CXnDomNode* node = iNode->DomNode();

    if ( node )

        {

        return node->Name();

        }

    return KNullDesC8;

    }

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

// CXnNodeAppIf::ShowTooltipsL

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

//

EXPORT_C void CXnNodeAppIf::ShowTooltipsL()

    {

    iNode->ShowTooltipsL();

    }

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

// CXnNodeAppIf::HideTooltipsL

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

//

EXPORT_C void CXnNodeAppIf::HideTooltipsL()

    {

    iNode->HideTooltipsL();

    }

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

// CXnNodeAppIf::Namespace

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

//

EXPORT_C const TDesC8& CXnNodeAppIf::Namespace()

    {

    CXnDomNode* node = iNode->DomNode();

    if ( node )

        {

        return node->Namespace();

        }

    return KNullDesC8;

    }

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

// CXnNodeAppIf::Component

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

//

EXPORT_C CXnComponent& CXnNodeAppIf::Component()

    {

    return *iNode->ComponentNodeImpl()->Component();

    }