/*

* 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:  Xuikon control adapter source file

*

*/

// System includes

#include <AknUtils.h>

// User includes

#include "xncontroladapter.h"

#include "xncontroladapterimpl.h"

#include "xnproperty.h"

#include "xnnodepluginif.h"

#include "xnnode.h"

#include "xnuiengine.h"

#include "xncomponent.h"

#include "xncomponentnodeimpl.h"

#include "xntype.h"

#include "xnviewnodeimpl.h"

#include "xneditmode.h"

// Constants

const TInt KLongTapStartDelay( 500000 ); // 0.5s

const TInt KLongTapTimeDelay( 1500000 ); // 1.5s

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

// CreateLongTapDetectorL

// Checks wheter longtap detector is needed for this node

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

//

static TBool CreateLongTapDetectorL( CXnNode& aNode )

    {

    if ( AknLayoutUtils::PenEnabled() )

        {

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

            {

            RPointerArray< CXnNode >& children( aNode.Children() );

            for ( TInt i = 0; i < children.Count(); i++ )

                {

                CXnProperty* prop( children[i]->GetPropertyL(

                    XnPropertyNames::common::KLongTap ) );

                if ( prop && prop->StringValue() == XnPropertyNames::KTrue )

                    {

                    return ETrue;

                    }

                }

            }

        else

            {

            CXnProperty* prop( aNode.GetPropertyL(

                XnPropertyNames::common::KLongTap ) );

            if ( prop && prop->StringValue() == XnPropertyNames::KTrue )

                {

                return ETrue;

                }

            }

        }

    return EFalse;

    }

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

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

// CXnControlAdapter::NewL

// Two-phased constructor. Can leave.

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

//

EXPORT_C CXnControlAdapter* CXnControlAdapter::NewL( CXnNodePluginIf& aNode )

    {

    CXnControlAdapter* self = new ( ELeave ) CXnControlAdapter;

    CleanupStack::PushL( self );

    self->ConstructL( aNode );

    CleanupStack::Pop();

    return self;

    }

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

// CXnControlAdapter::~CXnControlAdapter

// Destructor.

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

//

EXPORT_C CXnControlAdapter::~CXnControlAdapter()

    {

    delete iImpl;

    delete iLongTapDetector;

    }

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

// CXnControlAdapter::CXnControlAdapter

// C++ default constructor. Must not leave.

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

//

EXPORT_C CXnControlAdapter::CXnControlAdapter()

    {

    }

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

// CXnControlAdapter::ConstructL

// 2nd phase constructor. Can leave.

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

//

EXPORT_C void CXnControlAdapter::ConstructL( CXnNodePluginIf& aNode )

    {    

    iImpl = CXnControlAdapterImpl::NewL( aNode, *this, SystemGc() );

    if ( CreateLongTapDetectorL( aNode.Node() ) )

        {        

        iLongTapDetector = CAknLongTapDetector::NewL( this );

        iLongTapDetector->SetTimeDelayBeforeAnimation( KLongTapStartDelay );

        iLongTapDetector->SetLongTapDelay( KLongTapTimeDelay );

        }    

    }

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

// CXnControlAdapter::SetComponent

// Sets component object to adapter.

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

//

EXPORT_C void CXnControlAdapter::SetComponent( CXnComponent* aComponent )

    {

    iImpl->SetComponent( aComponent );

    }

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

// CXnControlAdapter::Component

// Returns component attached to this adapter

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

//

CXnComponent* CXnControlAdapter::Component() const

    {

    return const_cast< CXnComponent* >( iImpl->Component() );

    }

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

// CXnControlAdapter::Component

// Gets component object from adapter.

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

//

EXPORT_C CXnComponent* CXnControlAdapter::Component()

    {

    return iImpl->Component();

    }

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

// CXnControlAdapter::OfferKeyEventL

// Handles key events.

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

//

EXPORT_C TKeyResponse CXnControlAdapter::OfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aType )

    {

    return iImpl->OfferKeyEventL( aKeyEvent, aType );

    }

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

// CXnControlAdapter::HandleControlEventL

// Handles control events.

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

//

EXPORT_C void CXnControlAdapter::HandleControlEventL(

    CCoeControl* /*aControl*/,

    TCoeEvent /*aEventType*/ )

    {

    }

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

// CXnControlAdapter::HandleLongTapEventL

// Handles the long tap events.

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

//

EXPORT_C void CXnControlAdapter::HandleLongTapEventL(

    const TPoint& aPenEventLocation,

    const TPoint& aPenEventScreenLocation )

    {

    CXnNode* node( &Component()->Node()->Node() );

    CXnUiEngine* engine( node->UiEngine() );

    engine->DisableRenderUiLC();

    iImpl->HandleLongTapEventL( aPenEventLocation, aPenEventScreenLocation );

    CleanupStack::PopAndDestroy(); // DisableRenderUiLC;

    }

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

// CXnControlAdapter::EnableLongTapAnimation

// Handles the long tap events.

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

//

EXPORT_C void CXnControlAdapter::EnableLongTapAnimation( const TBool aAnimation )

    {

    if ( iLongTapDetector )

        {

        iLongTapDetector->EnableLongTapAnimation( aAnimation );

        }

    }

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

// CXnControlAdapter::HandlePointerEventL

// Handle pointer events

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

//

EXPORT_C void CXnControlAdapter::HandlePointerEventL(

    const TPointerEvent& aPointerEvent )

    {

    TBool consumed( EFalse );

    switch( aPointerEvent.iType )

        {

        case TPointerEvent::EButton1Down:

        case TPointerEvent::EButton1Up:

        case TPointerEvent::EDrag:        

            consumed = iImpl->HandlePointerEventL( aPointerEvent );

            break;

        default:

            break;

        }

    if ( !consumed )

        {

        CCoeControl::HandlePointerEventL( aPointerEvent );

        }    

    }

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

// CXnControlAdapter::Draw

// Draws the control

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

//

EXPORT_C void CXnControlAdapter::Draw( const TRect& aRect ) const

    {

    iImpl->Draw( aRect );

    }

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

// CXnControlAdapter::Draw

// Draws the control

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

//

EXPORT_C void CXnControlAdapter::Draw( const TRect& aRect, CWindowGc& aGc ) const

    {

    iImpl->Draw( aRect, aGc );

    }

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

// CXnControlAdapter::ComponentControl

// Return a child control by index

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

//

EXPORT_C CCoeControl* CXnControlAdapter::ComponentControl( TInt aIndex ) const

    {

    return iImpl->ComponentControl( aIndex );

    }

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

// CXnControlAdapter::CountComponentControls

// Return count of children

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

//

EXPORT_C TInt CXnControlAdapter::CountComponentControls() const

    {

    return iImpl->CountComponentControls();

    }

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

// CXnControlAdapter::SetVisible

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

//

EXPORT_C void CXnControlAdapter::SetVisible( TBool aVisible )

    {

    MakeVisible( aVisible );

    }

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

// CXnControlAdapter::AppendChildL

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

//

void CXnControlAdapter::AppendChildL(CXnControlAdapter& aChild, CXnNode& aNode)

    {

    iImpl->AppendChildL(aChild, aNode);

    }

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

// CXnControlAdapter::IsDrawingAllowed

// Checks whether drawing is allowed

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

//

EXPORT_C TBool CXnControlAdapter::IsDrawingAllowed() const

    {

    return iImpl->IsDrawingAllowed();

    }

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

// CXnControlAdapter::ContentBitmaps

// Gets content bitmaps

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

//

EXPORT_C void CXnControlAdapter::ContentBitmaps(

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask )

    {

    iImpl->ContentBitmaps( aBitmap, aMask );

    }

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

// CXnControlAdapter::SetContentBitmaps

// Sets content bitmaps

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

//

EXPORT_C void CXnControlAdapter::SetContentBitmaps(

    CFbsBitmap* aBitmap,

    CFbsBitmap* aMask )

    {

    iImpl->SetContentBitmaps( aBitmap, aMask );

    }

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

// CXnControlAdapter::SetContentBitmaps

// Sets content bitmaps

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

//

EXPORT_C void CXnControlAdapter::SetContentBitmaps(

    const TDesC& aBitmapUrl,

    const TDesC& aMaskUrl )

    {

    TRAP_IGNORE( iImpl->SetContentBitmapsL( aBitmapUrl, aMaskUrl ) );

    }

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

// CXnControlAdapter::DrawContentImage

// Draws content image

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

//

EXPORT_C void CXnControlAdapter::DrawContentImage() const

    {

    iImpl->DrawContentImage();

    }

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

// CXnControlAdapter::SizeChanged

// Control size change notification

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

//

EXPORT_C void CXnControlAdapter::SizeChanged()

    {

    iImpl->SizeChanged();

    }

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

// CXnControlAdapter::SkinChanged

// Skin change notification

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

//

EXPORT_C void CXnControlAdapter::SkinChanged()

    {

    TRAP_IGNORE( Component()->Node()->SetDirtyL() );

    iImpl->SkinChanged();

    }

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

// CXnControlAdapter::FocusChanged

// Focus change notification

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

//

EXPORT_C void CXnControlAdapter::FocusChanged( TDrawNow /*aDrawNow*/ )

    {

    TRAP_IGNORE( iImpl->FocusChangedL( IsFocused() ) );

    }

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

// CXnControlAdapter::LoadBitmap

// Load a bitmap from the server. Ownership is transferred.

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

//

EXPORT_C CFbsBitmap* CXnControlAdapter::LoadBitmap( const TDesC& aBitmapUrl )

    {

    return iImpl->LoadBitmap( aBitmapUrl );

    }

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

// CXnControlAdapter::GetBitmapAndMask

// Load a bitmap and mask from the server. Ownership is transferred.

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

//

EXPORT_C void CXnControlAdapter::GetBitmapAndMask(

    const TDesC& aBitmapUrl,

    const TDesC& aMaskUrl,

    CFbsBitmap*& aBitmap,

    CFbsBitmap*& aMask )

    {

    iImpl->GetBitmapAndMask( aBitmapUrl, aMaskUrl, aBitmap, aMask );

    }

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

// CXnControlAdapter::EnterPowerSaveModeL

// Enter power save mode

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

//

EXPORT_C void CXnControlAdapter::EnterPowerSaveModeL( TModeEvent aEvent )

    {

    iImpl->StopHighlightAnimation();

    DoEnterPowerSaveModeL( aEvent );

    }

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

// CXnControlAdapter::DoEnterPowerSaveModeL

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

//

EXPORT_C void CXnControlAdapter::DoEnterPowerSaveModeL( TModeEvent /* aEvent */ )

    {

    }

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

// CXnControlAdapter::ExitPowerSaveModeL

// Exit power save mode

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

//

EXPORT_C void CXnControlAdapter::ExitPowerSaveModeL( TModeEvent aEvent )

    {

    iImpl->StartHighlightAnimation();

    DoExitPowerSaveModeL( aEvent );

    }

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

// CXnControlAdapter::DoExitPowerSaveModeL

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

//

EXPORT_C void CXnControlAdapter::DoExitPowerSaveModeL( TModeEvent /*aEvent*/ )

    {

    }

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

// CXnControlAdapter::SetLocalUiZoomL

// Set local UI zoom level

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

//

EXPORT_C void CXnControlAdapter::SetLocalUiZoomL( TAknUiZoom /*aZoom*/ )

    {

    }

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

// CXnControlAdapter::HandleScreenDeviceChangedL

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

//

EXPORT_C void CXnControlAdapter::HandleScreenDeviceChangedL()

    {

    CXnNode& node( Component()->Node()->Node() );

    if ( CreateLongTapDetectorL( node ) )

        {

        if ( !iLongTapDetector )

            {

            iLongTapDetector = CAknLongTapDetector::NewL( this );

            }

        }

    else

        {

        delete iLongTapDetector;

        iLongTapDetector = NULL;

        }

    Component()->Node()->SetDirtyL();

    iImpl->HandleScreenDeviceChangedL();

    }

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

// CXnControlAdapter::HandlePropertyChangeL

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

//

EXPORT_C void CXnControlAdapter::HandlePropertyChangeL( CXnProperty* aProperty )

    {

    // Check component focus.

    CXnComponent* component( iImpl->Component() );

    if ( component )

        {

        CXnNodePluginIf* node( component->Node() );

        if ( node )

            {

            if ( node->IsFocusedState() )

                {

                iImpl->StartHighlightAnimation();

                }

            else

                {

                iImpl->StopHighlightAnimation();

                }

            }

        }

    if ( iImpl->UpdateBackgroundImageL( aProperty) ==

         CXnControlAdapterImpl::EPropertyChangeNotConsumed )

        {

        DoHandlePropertyChangeL( aProperty );

        }

    }

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

// CXnControlAdapter::DoHandlePropertyChangeL

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

//

EXPORT_C void CXnControlAdapter::DoHandlePropertyChangeL( CXnProperty* aProperty )

    {

    iImpl->DoHandlePropertyChangeL( aProperty );