/*

 * Copyright (c) 2010 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:  Carousel widget for Symbian Homescreen

 *

 */

#include <ecom/implementationproxy.h>

#include <aknphysics.h>

#include <gulicon.h>

#include <AknIconUtils.h>

#include <AknsDrawUtils.h>

#include <xnexteventhandler.h>

#include "carouselwidget.h"

const TSize KIconSize(70,70);

const TInt KItemPadding( 6 );

_LIT( KLaunchByIndex, "LaunchByIndex(");

template< class PtrT > inline PtrT* UnpackPtr( 

    const TDesC8& aBuf )

    {

    TAny* result( NULL );

    if ( aBuf.Size() == sizeof( TAny* ) )

        {

        // Effectively writes aBuf contents to result

        TPckg< TAny* >( result ).Copy( aBuf ); 

        }

    return static_cast< PtrT* >( result );

    }

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

CCarouselItem::CCarouselItem( CFbsBitmap* aBitmap, CFbsBitmap* aMask)

    :iBitmap( aBitmap ), iMask( aMask )

    {

    }

CCarouselItem::~CCarouselItem()

    {

    delete iBitmap;

    delete iMask;

    delete iText;

    }

void CCarouselItem::SetTextL( const TDesC& aText )

    {

    delete iText;

    iText = NULL;

    iText = aText.AllocL();    

    }

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

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

// Symbian static 1st phase constructor

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

//

CCarouselWidget* CCarouselWidget::NewL()

    {

    CCarouselWidget* self = new( ELeave ) CCarouselWidget();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// C++ destructor

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

//

CCarouselWidget::~CCarouselWidget()

    {

    delete iPhysics;

    iStripeItems.ResetAndDestroy();

    //delete iCover;

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CCarouselWidget::ConstructL()

    {

    }

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

// Handles key events.

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

//

TKeyResponse CCarouselWidget::OfferKeyEventL( const TKeyEvent& /*aKeyEvent*/,

    TEventCode /*aType*/ )

    {

    return EKeyWasConsumed;

    }

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

// Set window for this control

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

//

void CCarouselWidget::SetContainerWindowL( const CCoeControl &aContainer )

    {

    CCoeControl::SetContainerWindowL( aContainer );

    }

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

// (other items were commented in a header).

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

//

void CCarouselWidget::HandlePointerEventL( const TPointerEvent& aPointerEvent )

    {

    if( !iPhysics )

        {

        return;

        }

    TPoint stylusPos( aPointerEvent.iPosition );   

    switch( aPointerEvent.iType )

        {

        case TPointerEvent::EButton1Down:

            {

            iPhysics->StopPhysics();

            iPhysics->ResetFriction();

            iStartPosition = stylusPos;

            iStartTime.HomeTime();

            iStylusPosition = stylusPos;

            iDrawHighlight = ETrue;

            }

            break; 

        case TPointerEvent::EButton1Up:

            {

            iDrawHighlight = EFalse;

            TInt distance = iStartPosition.iX - stylusPos.iX;

            if( Abs(distance) <= iPhysics->DragThreshold() )

                {

                LaunchItemL( stylusPos );

                }

            else

                {

                TPoint drag( distance, 0 );

                iPhysics->StartPhysics( drag, iStartTime );

                }            }

            break; 

        case TPointerEvent::EDrag:

        case TPointerEvent::EMove:

            {

            TPoint dragTh(  iStartPosition - stylusPos );

            if( Abs(dragTh.iX) > iPhysics->DragThreshold() || 

                Abs(dragTh.iY) > iPhysics->DragThreshold())

                {

                iDrawHighlight = EFalse;

                }

            TInt deltaX( iStylusPosition.iX - stylusPos.iX );

            iStylusPosition = stylusPos;

            TPoint deltaPoint( deltaX, 0 );

            iPhysics->RegisterPanningPosition( deltaPoint );

            }

            break;

        default:                

            break;                

        }

    CCoeControl::HandlePointerEventL( aPointerEvent );

    }

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

// Returns the number of component controls

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

//

TInt CCarouselWidget::CountComponentControls() const

    {

    return 0;

    }    

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

// Returns the specified control

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

//

CCoeControl* CCarouselWidget::ComponentControl( TInt /*aIndex*/ ) const

    {

      return NULL;

    }

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

// Skin change notification.

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

//

void CCarouselWidget::SkinChanged()

    {

    }

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

// CCarouselWidget::EnterPowerSaveModeL

//

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

//

void CCarouselWidget::EnterPowerSaveModeL()

    {

    }

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

// CCarouselWidget::ExitPowerSaveModeL

//

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

//

void CCarouselWidget::ExitPowerSaveModeL()

    {

    }

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

// Called if focus changes

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

//

void CCarouselWidget::FocusChanged( TDrawNow /*aDrawNow*/ )

    {

    }

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

// Called if position or size changes

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

//

void CCarouselWidget::SizeChanged()

    {

    iViewPort = Rect();

    TRAP_IGNORE( InitPhysicEngineL() );

    DrawNow();

    }

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

// Sets the external event handler interface.

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

//

void CCarouselWidget::SetEventHandler( MXnExtEventHandler* aEventHandler )

    {

    iEventHandler = aEventHandler;

    }

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

// Data stream from the publisher

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

//

void CCarouselWidget::SetDataL( const TDesC8& aData, const TDesC& aType, TInt aIndex )

    {

    /// Unpack the data stream, works because publisher is in same process.

    CGulIcon* icon( UnpackPtr<CGulIcon>( aData ) );

    CleanupStack::PushL( icon );

    AknIconUtils::SetSize( icon->Bitmap(), KIconSize);

    CCarouselItem* item = new ( ELeave ) CCarouselItem(/* *iEditor,*/ icon->Bitmap(), icon->Mask() );

    CleanupStack::PopAndDestroy( icon );

    if( aType == _L("Appstripe/widget"))

        {

        if( iStripeItems.Count() <= aIndex )

            {

            iStripeItems.AppendL( item );

            InitPhysicEngineL();

            }

        else

            {

            CCarouselItem* citem = iStripeItems[ aIndex ];

            delete citem;

            iStripeItems.Remove( aIndex );

            iStripeItems.Insert( item, aIndex );

            }

        DrawNow();

        }

    }

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

// Draws the carousel component

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

//

void CCarouselWidget::Draw( const TRect& /*aRect*/ ) const

    {

    CWindowGc& gc( SystemGc() );

    gc.SetClippingRect( iViewPort );    

    TRect bitmapRect( TPoint(0,0), KIconSize );

    TPoint point( iViewPort.iTl );

    point.iX -= iViewPosition.iX;

    TInt count = iStripeItems.Count();

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

        {

        CFbsBitmap* bitmap = iStripeItems[i]->iBitmap;

        CFbsBitmap* mask = iStripeItems[i]->iMask;

        TRect drawRect( point, KIconSize );

        if( iDrawHighlight && drawRect.Contains( iStylusPosition ))

            {

            TRect innerRect( drawRect );

            innerRect.Shrink( 5, 5 );

            MAknsSkinInstance* skin( AknsUtils::SkinInstance() );

            AknsDrawUtils::DrawFrame( skin, gc, drawRect, innerRect,

                KAknsIIDQsnFrHomePressed, KAknsIIDDefault );

            }

        if( iViewPort.Contains( drawRect.iBr )||

            iViewPort.Contains( drawRect.iTl ))

            {

            gc.BitBltMasked( point, bitmap, bitmapRect, mask, EFalse);

            }

        point.iX += KIconSize.iWidth + KItemPadding;

        }

    }

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

// ViewPositionChanged

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

//

void CCarouselWidget::ViewPositionChanged( 

    const TPoint& aNewPosition, TBool aDrawNow, TUint /*aFlags*/ )

    {

    iCurrentPosition = aNewPosition;

    iViewPosition.iX = aNewPosition.iX - iViewPort.Width()/2;

    if( aDrawNow )

        {

        DrawNow( iViewPort );

        }

    }

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

// PhysicEmulationEnded

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

//    

void CCarouselWidget::PhysicEmulationEnded()

    {

    }

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

// ViewPosition

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

//    

TPoint CCarouselWidget::ViewPosition() const

    {

    return iCurrentPosition;

    }

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

// InitPhysicEngineL

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

//    

void CCarouselWidget::InitPhysicEngineL()

    {

    // Init physic engine

    if ( !iPhysics && CAknPhysics::FeatureEnabled() )

        {

        iPhysics = CAknPhysics::NewL( *this, this );

        }

    if( !iPhysics )

        {

        return;

        }

    TSize viewPortSize = iViewPort.Size();

    TInt totalWidth( iStripeItems.Count() * (KIconSize.iWidth + KItemPadding ));

    TSize totalSize( totalWidth, viewPortSize.iHeight );

    iPhysics->InitPhysicsL( totalSize, viewPortSize, ETrue );

    iCurrentPosition = TPoint( viewPortSize.iWidth / 2, viewPortSize.iHeight / 2 );

    }

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

// 

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

//

TInt CCarouselWidget::ItemIndex( TPoint& aPoint )

    {

    TPoint itemStartPoint( iViewPort.iTl );

    itemStartPoint.iX -= iViewPosition.iX;

    TRect dropRect( itemStartPoint, KIconSize );

    dropRect.Resize( KItemPadding, 0 );

    TInt index( 0 );

    do

        {

        if( dropRect.Contains( aPoint ))

            {

            return index;

            }

        dropRect.Move( KIconSize.iWidth+KItemPadding, 0);

        index++;

        }

    while( index < iStripeItems.Count() );

    return KErrNotFound;

    }

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

// Launches the item, which is in aPosition

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

//

void CCarouselWidget::LaunchItemL( TPoint& aPosition )

    {

    TInt index = ItemIndex( aPosition );

    // carousel plugin expects indexes to start from 1

    index++;

    TInt len( KLaunchByIndex().Length()+3 );

    TBuf<17> event;

    event.Append( KLaunchByIndex );

    event.AppendNum( index );

    event.Append( _L(")"));

    iEventHandler->HandleEventL( event, _L8("Appstripe"));

    }

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

// C++ default constructor

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

//

CCarouselWidget::CCarouselWidget()

    {

    }

// ============================ PUBLIC FUNCTIONS ===============================

const TImplementationProxy KImplementationTable[] =

    {

#ifdef __EABI__

    IMPLEMENTATION_PROXY_ENTRY( 0xEabba433, CCarouselWidget::NewL )

#else

    { { 0xEabba433 }, CCarouselWidget::NewL }

#endif

    };

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

// Returns the list of implementations provided by the plugin

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

//

EXPORT_C const TImplementationProxy* ImplementationGroupProxy(

    TInt& aTableCount )

    {

    aTableCount = sizeof( KImplementationTable ) / sizeof( TImplementationProxy );

    return KImplementationTable;

    }