/*
* 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
*
*/


// User includes
#include "xnnodepluginif.h"
#include "xnnode.h"
#include "xnuiengine.h"
#include "xncomponentnodeimpl.h"
#include "xnproperty.h"
#include "xntype.h"
#include "xndomdocument.h"
#include "xnodt.h"

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

// -----------------------------------------------------------------------------
// CXnNodePluginIf::CXnNodePluginIf()
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CXnNodePluginIf::CXnNodePluginIf( CXnNode& aNode )
    {
    iNode = &aNode;
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::ViewNodeImpl
// -----------------------------------------------------------------------------
//
EXPORT_C CXnViewNodeImpl* CXnNodePluginIf::ViewNodeImpl()
    {
    return iNode->ViewNodeImpl();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::ComponentNodeImpl
// -----------------------------------------------------------------------------
//
EXPORT_C CXnComponentNodeImpl* CXnNodePluginIf::ComponentNodeImpl()
    {
    return iNode->ComponentNodeImpl();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::IsDrawingAllowed
// -----------------------------------------------------------------------------
//
TBool CXnNodePluginIf::IsDrawingAllowed() const
    {
    return EFalse;
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::Type()
// Returns control type.
// -----------------------------------------------------------------------------
//
EXPORT_C CXnType* CXnNodePluginIf::Type()
    {
    return iNode->Type();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::Parent
// Get component parent
// -----------------------------------------------------------------------------
//
EXPORT_C CXnNodePluginIf* CXnNodePluginIf::ParentL() const
    {
    CXnNode* node = iNode->Parent();
    if ( !node )
        {
        return NULL;
        }
    return &( node->PluginIfL() );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::AddChildL
// Adds a child to this container.
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::AddChildL( CXnNodePluginIf* aChild )
    {
    iNode->AddChildL( &( aChild->Node() ) );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::Children
// -----------------------------------------------------------------------------
//
EXPORT_C RPointerArray< CXnNodePluginIf > CXnNodePluginIf::ChildrenL()
    {
    RPointerArray< CXnNode >& nodes = iNode->Children();
    RPointerArray< CXnNodePluginIf > pluginNodes;
    CleanupClosePushL( pluginNodes );

    TInt count = nodes.Count();
    for ( TInt i = 0; i < count; ++i )
        {
        pluginNodes.AppendL( &nodes[i]->PluginIfL() );
        }
    CleanupStack::Pop( &pluginNodes );
    // 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 pluginNodes;
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetPCDataL
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetPCDataL( const TDesC8& aData )
    {
    iNode->SetPCDataL( aData );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::GetPCData
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CXnNodePluginIf::GetPCData() const
    {
    return iNode->GetPCData();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetPropertyL
// Set a property.
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetPropertyL( CXnProperty* aProperty )
    {
    iNode->SetPropertyL( aProperty );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetPropertyL
// Set a property.
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetPropertyWithoutNotificationL( CXnProperty* aProperty )
    {
    iNode->SetPropertyWithoutNotificationL( aProperty );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::GetProperty
// Gets a property.
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::GetPropertyL( CXnProperty& /*aProperty*/ ) const
    {
    return NULL; // iNode->GetPropertyL( aProperty );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::GetProperty
// Gets a property.
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::GetPropertyL( const TDesC8& aKey ) const
    {
    return iNode->GetPropertyL( aKey );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetStateL
// Set a state
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetStateL( const TDesC8& aState )
    {
    iNode->SetStateL( aState );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::UnsetState
// Unset a pseudoclass
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::UnsetStateL( const TDesC8& aState )
    {
    iNode->UnsetStateL( aState );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::IsFocusedState
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CXnNodePluginIf::IsFocusedState()
    {
    return iNode->IsStateSet( _L8( "focus" ) );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetRect
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetRect( const TRect& aRect )
    {
    iNode->SetRect( aRect );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::Rect
// -----------------------------------------------------------------------------
//
EXPORT_C TRect CXnNodePluginIf::Rect()
    {
    return iNode->Rect();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetBorderRect
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetBorderRect( const TRect& aRect )
    {
    iNode->SetBorderRect( aRect );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::BorderRect
// -----------------------------------------------------------------------------
//
EXPORT_C TRect CXnNodePluginIf::BorderRect()
    {
    return iNode->BorderRect();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetMarginRect
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetMarginRect( const TRect& aRect )
    {
    iNode->SetMarginRect( aRect );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::MarginRect
// -----------------------------------------------------------------------------
//
EXPORT_C TRect CXnNodePluginIf::MarginRect()
    {
    return iNode->MarginRect();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetPaddingRect
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetPaddingRect( const TRect& aRect )
    {
    iNode->SetPaddingRect( aRect );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::PaddingRect
// -----------------------------------------------------------------------------
//
EXPORT_C TRect CXnNodePluginIf::PaddingRect()
    {
    return iNode->PaddingRect();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::UiEngine
// -----------------------------------------------------------------------------
//
EXPORT_C TXnUiEnginePluginIf* CXnNodePluginIf::UiEngineL()
    {
    return &( iNode->UiEngine()->PluginIfL() );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetLayoutCapable
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetLayoutCapable( const TBool aLayoutCapable )
    {
    iNode->SetLayoutCapable( aLayoutCapable );
    }

// -----------------------------------------------------------------------------
// Get internal node
// -----------------------------------------------------------------------------
//
CXnNode& CXnNodePluginIf::Node()
    {
    return *iNode;
    }

// -----------------------------------------------------------------------------
// Get app interface
// -----------------------------------------------------------------------------
//
EXPORT_C CXnNodeAppIf& CXnNodePluginIf::AppIfL()
    {
    return iNode->AppIfL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::MakeInterfaceL
// Create a component interface according to the given type.
// -----------------------------------------------------------------------------
//
EXPORT_C XnComponentInterface::MXnComponentInterface* CXnNodePluginIf::MakeInterfaceL(
    const TDesC8& aType )
    {
    return iNode->MakeInterfaceL( aType );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::DisplayL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::DisplayL()
    {
    return iNode->DisplayL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::VisibilityL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::VisibilityL()
    {
    return iNode->VisibilityL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::LabelL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::LabelL()
    {
    return iNode->LabelL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::IdL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::IdL()
    {
    return iNode->IdL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetHandleTooltip
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetHandleTooltip( TBool aFlag )
    {
    iNode->SetHandleTooltip( aFlag );
    }

// -----------------------------------------------------------------------------
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::ReportTriggerEventL(
    const TDesC8& aTriggerName,
    const TDesC8& aValueName,
    const TDesC8& aValue )
    {
    CXnNode* trigger = CXnNode::NewL();
    CleanupStack::PushL( trigger );
    CXnType* type = CXnType::NewL( XnPropertyNames::action::KTrigger );
    CleanupStack::PushL( type );
    CXnNodeImpl* impl = CXnNodeImpl::NewL( type );
    CleanupStack::Pop( type );
    trigger->SetImpl( impl );
    trigger->SetUiEngine( *iNode->UiEngine() );

    CXnDomPropertyValue* nameValue = CXnDomPropertyValue::NewL(
        iNode->UiEngine()->ODT()->DomDocument().StringPool() );
    CleanupStack::PushL( nameValue );
    nameValue->SetStringValueL( CXnDomPropertyValue::EString, aTriggerName );

    CXnProperty* name = CXnProperty::NewL(
        XnPropertyNames::action::trigger::KName,
        nameValue,
        *iNode->UiEngine()->ODT()->DomDocument().StringPool() );

    CleanupStack::Pop( nameValue );
    CleanupStack::PushL( name );
    trigger->SetPropertyL( name );
    CleanupStack::Pop( name );

    CXnDomPropertyValue* indexValue = CXnDomPropertyValue::NewL(
        iNode->UiEngine()->ODT()->DomDocument().StringPool() );
    CleanupStack::PushL( indexValue );
    indexValue->SetStringValueL( CXnDomPropertyValue::EString, aValue );

    CXnProperty* index = CXnProperty::NewL(
        aValueName,
        indexValue,
        *iNode->UiEngine()->ODT()->DomDocument().StringPool() );

    CleanupStack::Pop( indexValue );
    CleanupStack::PushL( index );
    trigger->SetPropertyL( index );
    CleanupStack::Pop( index );

    iNode->ReportXuikonEventL( *trigger, 0 );

    CleanupStack::PopAndDestroy( trigger );
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::PathL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::PathL()
    {
    return iNode->PathL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::MaskPathL
// -----------------------------------------------------------------------------
//
EXPORT_C CXnProperty* CXnNodePluginIf::MaskPathL()
    {
    return iNode->MaskPathL();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::SetDirtyL
// -----------------------------------------------------------------------------
//
EXPORT_C void CXnNodePluginIf::SetDirtyL()
    {
    const TDesC8& type( iNode->Type()->Type() );

    if ( iNode->IsAdaptive( ETrue ) )
        {
        iNode->SetDirtyL( XnDirtyLevel::ELayoutAndRender );
        }
    else
        {
        iNode->SetDirtyL( XnDirtyLevel::ERender );
        }

    // If node's parent is tooltip, it must be relayouted because it will
    // grow based on childs
    CXnNode* parent( iNode->Parent() );

    if ( parent && parent->Type()->Type() == _L8( "tooltip" ) )
        {
        parent->SetDirtyL( XnDirtyLevel::ELayoutAndRender );
        }
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::Namespace
// -----------------------------------------------------------------------------
//
EXPORT_C const TDesC8& CXnNodePluginIf::Namespace()
    {
    return iNode->Namespace();
    }

// -----------------------------------------------------------------------------
// CXnNodePluginIf::ControlL
// Gets the control associated to this node
// -----------------------------------------------------------------------------
//
EXPORT_C CXnControlAdapter* CXnNodePluginIf::Control() const
    {
    return iNode->Control();
    }