/*

* Copyright (c) 2009 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:    

*

*/

// INCLUDE FILES

#include <ganes/HgVgMediaWall.h>

#include <ganes/HgVgMediaWallObserverIface.h>

#include <ganes/HgScroller.h>

#include "HgVgDrawBuffer.h"

#include "HgVgScrollBar.h"

#include "HgVgHelper.h"

#include "HgVgMediaWallRenderer.h"

#include "HgVgSkinRenderer.h"

#include "HgVgTimer.h"

#include "HgVgLetterPopup.h"

#include "HgVgButton.h"

#include "HgVgLabel.h"

#include "HgVgEGL.h"

#include "HgVgSpring.h"

#include "HgVgImageCreator.h"

#include "HgPopupDrawer.h"

#include <ganes/HgScrollBufferObserverIface.h>

#include <ganes/HgSelectionObserverIface.h>

#include <ganes/HgMarkingObserverIface.h>

#include <ganes/HgVgItem.h>

#include "HgScrollbar.h"

#include "HgScrollBufferManager.h"

#include "HgConstants.h"

#include "HgVgConstants.h"

#include <ganes.mbg>

//#include <aknappui.h>

#include <touchfeedback.h>

#include <gulicon.h>

#include <e32math.h>

#include <gulcolor.h>

#include <e32cmn.h> // Abs

#include <alf/alfcompositionutility.h>

#include <AknIconUtils.h>

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <AknUtils.h>

#include <layoutmetadata.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_apps.cdl.h>

using namespace AknTouchGestureFw;

using namespace HgVgConstants;

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

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

// CHgMediaWall::NewL()

// Two-phased constructor.

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

//

EXPORT_C CHgVgMediaWall* CHgVgMediaWall::NewL(

        const TRect& aRect, 

        TInt aItemCount,

        THgVgMediaWallStyle aStyle,

        TBool aScrollBarEnabled,

        MObjectProvider* aParent,

        CGulIcon* aDefaultIcon )

    {

    CHgVgMediaWall* self = new ( ELeave ) CHgVgMediaWall( 

            aItemCount, 

            aDefaultIcon, aStyle, aScrollBarEnabled );

    CleanupStack::PushL (self );

    self->ConstructL( aRect, aParent );

    CleanupStack::Pop (self );

    return self;

    }

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

// CHgVgMediaWall::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CHgVgMediaWall::ConstructL (const TRect& aRect, MObjectProvider* aParent )

    {

    iPopupText1.CreateL( KMaxPopupTextLength );

    iPopupText2.CreateL( KMaxPopupTextLength );    

    iSpring = new (ELeave) THgVgSpring(KSpringK, KSpringDamping, 

            KMaxSpringVelocity, KPositionSnap, KMinSpringVelocity);

    iSpring->Reset(0,0);

    iAnimationTimer = CHgVgTimer::NewL();

    iDelayedInit = CPeriodic::NewL( CActive::EPriorityStandard );

    iKeyScrollingTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    SetEmptyTextL(KNullDesC);

    // Create a window for this application view

    CreateWindowL ( );

    EnableDragEvents();

    ClaimPointerGrab();

    IgnoreEventsUntilNextPointerUp();

    InitScreenL( aRect );

    InitItemsL();

    HandleViewPositionChanged(ETrue);

    iCoeEnv->AddForegroundObserverL( *this );

    // setup Avkon gesture framework.

    iTouchFw = AknTouchGestureFw::CAknTouchGestureFw::NewL(*this, *this);

    iTouchFw->SetGestureInterestL(AknTouchGestureFw::EAknTouchGestureFwGroupDrag |

            AknTouchGestureFw::EAknTouchGestureFwGroupTap | 

            AknTouchGestureFw::EAknTouchGestureFwGroupFlick);

    ActivateL ( );

    SetMopParent( aParent );

    SetFlags( EHgVgMediaWallDrawToWindowGC | EHgVgMediaWallUninitialized );

    }

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

// CHgVgMediaWall::InitScreenL()

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

//

EXPORT_C void CHgVgMediaWall::InitScreenL( const TRect& aRect )

    // Set the windows size       

    SetRect ( aRect );

    }

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

// CHgVgMediaWall::RefreshScreen()

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

//

EXPORT_C void CHgVgMediaWall::RefreshScreen( TInt aIndex )

    {

    if( !iIsForeground  )

        {

        return;

        }

    if( !iAnimationTimer->IsActive() )

        {    

        if( /*iMediaWallStyle == EHgVgMediaWallStyleGrid ||*/ 

                (aIndex >= FirstIndexOnScreen() && aIndex <= FirstIndexOnScreen() + ItemsOnScreen()) )

            {

            UpdateLabelsAndPopup();

            if(iFlags & EHgVgMediaWallDrawToWindowGC)

                {

                DrawNow();

                }

            else

                {

                DrawOpenVG();

                }

            }

        }

    }

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

// CHgVgMediaWall::FirstIndexOnScreen()

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

//

EXPORT_C TInt CHgVgMediaWall::FirstIndexOnScreen()

    {

    return iBufferPosition - iItemsOnScreen / 2;

    }

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

// CHgVgMediaWall::RefreshScreen()

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

//

EXPORT_C TInt CHgVgMediaWall::ItemsOnScreen()

    {

    return iItemsOnScreen;

    }

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

// CHgVgMediaWall::RefreshScreen()

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

//

EXPORT_C TInt CHgVgMediaWall::SelectedIndex()

    {

    return iSelectedIndex * iRowCount;

    }

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

// CHgVgMediaWall::RefreshScreen()

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

//

EXPORT_C void CHgVgMediaWall::SetSelectedIndex( TInt aIndex )

    {

    if( aIndex >= 0 && aIndex < iItems.Count() )

        {

        iUpdateScrollBar = ETrue;

        iSpring->Reset(aIndex / iRowCount, iSpring->EndY());

        HandleViewPositionChanged(ETrue);

        }

    }

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

// CHgVgMediaWall::EnableScrollBufferL()

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

//

EXPORT_C void CHgVgMediaWall::EnableScrollBufferL( 

        MHgScrollBufferObserver& aObserver, 

        TInt aBufferSize,

        TInt aBufferTreshold  )

    {

    delete iManager; 

    iManager = NULL;

    iManager = CHgScrollBufferManager::NewL(

            aObserver, 

            aBufferSize, 

            aBufferTreshold, 

            (TInt)iSpring->GetX() * iRowCount, 

            iItemCount);

    iManager->SetBufferOwner( *this );

    }

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

// CHgVgMediaWall::SetSelectionObserver()

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

//

EXPORT_C void CHgVgMediaWall::SetSelectionObserver( MHgSelectionObserver& aObserver )

    {

    iSelectionObserver = &aObserver;

    }

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

// CHgVgMediaWall::CHgVgMediaWall()

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

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

//

CHgVgMediaWall::CHgVgMediaWall( 

        TInt aItemCount, 

        CGulIcon* aDefaultIcon, 

        THgVgMediaWallStyle aStyle, 

        TBool aEnableScrollBar) :

    iItemCount(aItemCount),

    iItemsOnScreen(KMaxCoversVisible),

    iDefaultIcon( aDefaultIcon ),

    iAnimationState(EHgVgMediaWallAnimationStateIdle),

    iScrollBarEnabled(aEnableScrollBar),

    iMediaWallStyle(aStyle),

    iOpeningAnimationType(CHgVgMediaWall::EHgVgOpeningAnimationNone),

    iIsForeground(ETrue),

    iUsingDefaultIcon(ETrue),

    iRowCount(1),

    iCameraRotationFactor(KCameraRotationFactor),

    iCameraZoomFactor(KCameraZoomFactor),

    iSpringVelocityToAnimationFactor(KSpringVelocityToAnimationFactor),

    iPrevGridItem(KErrNotFound),

    iSelGridItem(KErrNotFound)

    // other intialized to 0 or EFalse

    {

    }

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

// CHgVgMediaWall::~CHgVgMediaWall()

// Destructor.

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

//

EXPORT_C CHgVgMediaWall::~CHgVgMediaWall ( )

    {

    if (iAnimationTimer->IsActive())

        iAnimationTimer->Cancel();

    iItems.ResetAndDestroy();

    iCoeEnv->RemoveForegroundObserver( *this );

    if(MTouchFeedback::Instance())

        {

        MTouchFeedback::Instance()->RemoveFeedbackArea(this, 0);     

        }

    DestroyRendering();

    delete iTouchFw;    

    delete iEmptyText;

    delete iDefaultIcon;

    delete iManager;

    delete iKeyScrollingTimer;

    delete iAnimationTimer;

    delete iDelayedInit;

    //delete iCompositionSource;

    delete iEGL;

    delete iSpring;

    delete iSurfaceBitmap;

    iPopupText1.Close();

    iPopupText2.Close();

    }

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

// CHgVgMediaWall::Style()

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

//

EXPORT_C CHgVgMediaWall::THgVgMediaWallStyle CHgVgMediaWall::Style() const

    {

    return iMediaWallStyle;

    }

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

// CHgVgMediaWall::OpeningAnimationType()

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

//

EXPORT_C CHgVgMediaWall::THgVgOpeningAnimationType CHgVgMediaWall::OpeningAnimationType() const

    {

    return iOpeningAnimationType;

    }

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

// CHgVgMediaWall::Draw()

// Draws the display.

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

//

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

    {

    if(iFlags & EHgVgMediaWallUninitialized)

        {

        return;

        }

    CHgVgMediaWall* self = const_cast<CHgVgMediaWall*>(this);           

    if (iIsForeground)

        {

        if( iFlags & EHgVgMediaWallDrawToWindowGC )

            {

            CFbsBitmap* screenshot = NULL;

            screenshot = self->DrawToBitmap();

            if (screenshot)

                {

                SystemGc().BitBlt( Rect().iTl,screenshot );

                delete screenshot;

                }

            else

                {

                }

            }

        else

            {

            // draw with alpha to make a hole to composition layer

            SystemGc().SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

            SystemGc().SetBrushColor(TRgb(0,0,0,0));

            SystemGc().Clear();

            DrawOpenVG();        

            }

        }

    else

        {

        if (iSurfaceBitmap)

            {

            SystemGc().BitBlt( Rect().iTl, iSurfaceBitmap );

            }

        else

            {

            }

        }

    }

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

// CHgVgMediaWall::SizeChanged()

// Called by framework when the view size is changed.

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

//

void CHgVgMediaWall::SizeChanged ( )

    {

    iRect = Rect();

    if(iDelayedInit && !iDelayedInit->IsActive())

        iDelayedInit->Start(0, 1000000, TCallBack(DelayedInit, this));

    if(MTouchFeedback::Instance())

        {

        MTouchFeedback::Instance()->SetFeedbackArea(this, 

                0, 

                iRect, 

                ETouchFeedbackBasic, 

                ETouchEventStylusDown);        

        }

    }

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

// CHgVgMediaWall::ChangeStyleL()

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

//

EXPORT_C void CHgVgMediaWall::ChangeStyleL( THgVgMediaWallStyle aStyle, const TRect& aRect, TBool /*aReuseSurface*/ )

    {

    // If animation is on, stop it before changing style.    

    HandleTransitionAnimationStop();

    iMediaWallStyle = aStyle;

    iAnimationState = EHgVgMediaWallAnimationStateIdle;

    // TODO: if (!aReUseSurface...)

    InitScreenL( aRect );

    }

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

// CHgVgMediaWall::HandleItemCountChaged()

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

//

void CHgVgMediaWall::HandleItemCountChanged()

    {

    TRAP_IGNORE( InitScrollBarL(ETrue); )

    if( iSelectedIndex >= MaxViewPosition() )

        {

        iSpring->Reset((TReal)(MaxViewPosition()-1), 0);

        HandleViewPositionChanged();

        iSelectedIndex = MaxViewPosition() - 1;

        }

    }

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

// CHgVgMediaWall::HandlePointerEventL()

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

//

void CHgVgMediaWall::HandlePointerEventL( const TPointerEvent& aEvent )

    {

    // Not faded and initialized and the drawing is set to be done to WinGc

    if( !( iFlags & EHgVgMediaWallFaded )

            && !( iFlags & EHgVgMediaWallUninitialized )

            && iFlags & EHgVgMediaWallDrawToWindowGC )

        {

        // Draw with OpenVg to our surface.

        ClearFlags( EHgVgMediaWallDrawToWindowGC );

        DrawNow();

        }

    if (iAnimationState != EHgVgMediaWallAnimationStateItemOpened)

        {

        // handle buttons

        iButtonsHit = HandleButtons(aEvent);

        if (iScrollBar && iScrollBar->HandlePointerEventL(aEvent))

            {

            iScrollBarHit = ETrue;

            }        

        if (aEvent.iType == TPointerEvent::EButton1Up)

            {

            iScrollBarHit = EFalse;

            // need to draw once at this point if animation is not going

            // on because the state has changed (when finger is lifted popup must disappear)

            if (!iAnimationTimer->IsActive())

                {

                DrawOpenVG();

                }

            }

        }