/*

* 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/HgScroller.h>

#include <aknphysics.h>

#include <ganes/HgScrollBufferObserverIface.h>

#include <ganes/HgSelectionObserverIface.h>

#include <ganes/HgMarkingObserverIface.h>

#include <ganes/HgItem.h>

#include "HgScrollbar.h"

#include "HgScrollBufferManager.h"

#include "HgConstants.h"

#include "HgPopupDrawer.h"

#include "HgMarquee.h"

#include "HgDrawUtils.h"

#include "HgIndicatorManager.h"

#include "HgTextFind.h"

#include "HgKeyUtils.h"

#include <ganes.mbg>

#include <AknIconUtils.h>

#include <avkon.mbg>

#include <AknsDrawUtils.h>

#include <touchfeedback.h>

#include <gulicon.h>

#include <AknUtils.h>

#include <layoutmetadata.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <aknitemactionmenu.h>

#include <aknappui.h>

#include <featdiscovery.h>

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

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

// CHgScroller::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CHgScroller::ConstructL (const TRect& aRect, RWsSession* aSession )

    {

    // Create a window for this application view

    CreateWindowL ( );

    EnableDragEvents();

    ClaimPointerGrab();

    iUpperCaseTitle.CreateL( KMaxSearchLenght );

    iPopupText1.CreateL( KMaxPopupTextLength );

    iPopupText2.CreateL( KMaxPopupTextLength );

    iScrollbar = CHgScrollbar::NewL(*this);

    iPopupDrawer = new (ELeave) THgPopupDrawer();

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

    TCallBack callback(CHgScroller::MarqueeCallback, this);

    iDrawUtils = CHgDrawUtils::NewL( callback );

    iIndicatorManager = CHgIndicatorManager::NewL();

    /*

    // Enable key search only in non-touch or hybrid (touch + qwerty) devices

    if( !AknLayoutUtils::PenEnabled() ||

        CFeatureDiscovery::IsFeatureSupportedL(TUid::Uid(KFeatureIdQwertyInput)) )

        {

        iTextFind = CHgTextFind::NewL( *this );

        iKeyUtils = CHgKeyUtils::NewL(*this);

        }

    */

    // Init Stuff

    if( aSession )

        {

        InitScreenL( aRect, *aSession );

        }

    else

        {

        InitScreenL( aRect );

        }

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

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

    CAknAppUi* appUi = static_cast<CAknAppUi*>(iEikonEnv->AppUi());

    if( appUi && appUi->IsSingleClickCompatible() )

        {

        iDetector = CAknLongTapDetector::NewL(this);

        iActionMenu = CAknItemActionMenu::RegisterCollectionL( *this );

        }

    iDrawUtils->EnableMarquee(HasHighlight());

    InitItemsL();

    iCoeEnv->AddForegroundObserverL( *this );    

    }

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

// CHgScroller::InputCapabilities()

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

//

TCoeInputCapabilities CHgScroller::InputCapabilities() const

    {

    TCoeInputCapabilities cap( TCoeInputCapabilities::ENone );

    if(iTextFind)

        {

        MCoeFepAwareTextEditor* editor = NULL;

        if( iSelectionMode == ENoSelection 

                && iFlags & EHgScrollerSearchWithQWERTY )

            editor = iTextFind;

        cap = TCoeInputCapabilities( TCoeInputCapabilities::EAllText, 

                editor, 

                NULL );

        cap.SetObjectProvider( const_cast<CHgScroller*>(this) );

        }

    return cap;

    }

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

// CHgScroller::InitScreenL()

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

//

EXPORT_C void CHgScroller::InitScreenL( const TRect& /*aRect*/, RWsSession& /*aSession*/ )

    {

    // DSA not supported anymore.

    User::Leave( KErrNotSupported );

    }

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

// CHgScroller::InitScreenL()

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

//

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

    {

    // Set the windows size

    SetRect ( aRect );

    }

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

// CHgScroller::RefreshScreen()

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

//

EXPORT_C void CHgScroller::RefreshScreen( TInt aIndex )

    {

    if( IsDisplayed( aIndex ) )

        DrawDeferred();

    }

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

// CHgScroller::FirstIndexOnScreen()

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

//

EXPORT_C TInt CHgScroller::FirstIndexOnScreen()

    {

    return CurrentIndex();

    }

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

// CHgScroller::SetFirstIndexOnScreen()

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

//

EXPORT_C void CHgScroller::SetFirstIndexOnScreen( TInt aFirstIndexOnScreen )

    {

    FitTopItemToView( aFirstIndexOnScreen );

    }

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

// CHgScroller::ItemsOnScreen()

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

//

EXPORT_C TInt CHgScroller::ItemsOnScreen()

    {

    return iItemsOnScreen;

    }

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

// CHgScroller::SelectedIndex()

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

//

EXPORT_C TInt CHgScroller::SelectedIndex()

    {

    return iSelectedIndex;

    }

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

// CHgScroller::SetSelectedIndex()

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

//

EXPORT_C void CHgScroller::SetSelectedIndex( TInt aIndex )

    {

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

        {

        if( !IsDisplayed( aIndex ) )

            {

            iSelectedIndex = iItems.Count() - 1;

            FitSelectionToView();

            }

        iSelectedIndex = aIndex;

        // Move view position so that it is fully visible.

        FitSelectionToView();

        SelectionChanged();

        }

    }

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

// CHgScroller::Mark()

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

//

EXPORT_C void CHgScroller::Mark( TInt aIndex )

    {

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

        {

        if( !(iItems[aIndex]->Flags() & CHgItem::EHgItemFlagMarked) )

            {

            iItems[aIndex]->SetFlags( CHgItem::EHgItemFlagMarked );

            if( iMarkingObserver )

                {

                TRAP_IGNORE( iMarkingObserver->HandleMarkingL( aIndex, ETrue ) );

                }            

            }

        }    

    }

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

// CHgScroller::UnMark()

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

//

EXPORT_C void CHgScroller::UnMark( TInt aIndex )

    {

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

        {

        if( iItems[aIndex]->Flags() & CHgItem::EHgItemFlagMarked )

            {

            iItems[aIndex]->ClearFlags( CHgItem::EHgItemFlagMarked );

            if( iMarkingObserver )

                {

                TRAP_IGNORE( iMarkingObserver->HandleMarkingL( aIndex, EFalse ) );

                }            

            }

        }    

    }

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

// CHgScroller::MarkAll()

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

//

EXPORT_C void CHgScroller::MarkAll()

    {

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

        {

        iItems[i]->SetFlags( CHgItem::EHgItemFlagMarked );

        }

    DrawDeferred();

    }

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

// CHgScroller::UnMarkAll()

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

//

EXPORT_C void CHgScroller::UnMarkAll()

    {

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

        {

        iItems[i]->ClearFlags(CHgItem::EHgItemFlagMarked);

        }

    DrawDeferred();

    }

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

// CHgScroller::GetMarkedItemsL()

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

//

EXPORT_C void CHgScroller::GetMarkedItemsL( RArray<TInt>& aIndexes )

    {

    ::CleanupClosePushL(aIndexes);

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

        {

        if(iItems[i]->Flags() & CHgItem::EHgItemFlagMarked )

            {

            aIndexes.AppendL( i );

            }

        }

    CleanupStack::Pop(&aIndexes);

    }

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

// CHgScroller::EnableScrollBufferL()

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

//

EXPORT_C void CHgScroller::EnableScrollBufferL( 

        MHgScrollBufferObserver& aObserver, 

        TInt aBufferSize,

        TInt aBufferTreshold  )

    {

    delete iManager; iManager = NULL;

    iManager = CHgScrollBufferManager::NewL(

            aObserver, 

            aBufferSize, 

            aBufferTreshold, 

            CurrentIndex(), 

            iItemCount);

    iManager->SetBufferOwner( *this );

    }

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

// CHgScroller::EnableNaviStripL()

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

//

EXPORT_C void CHgScroller::SetScrollBarTypeL( THgScrollBarType aType )

    {

    iScrollBarType = aType;

    DrawDeferred();

    }

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

// CHgScroller::SetSelectionObserver()

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

//

EXPORT_C void CHgScroller::SetSelectionObserver( MHgSelectionObserver& aObserver )

    {

    iSelectionObserver = &aObserver;

    }

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

// CHgScroller::SetMarkingObserver()

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

//

EXPORT_C void CHgScroller::SetMarkingObserver( MHgMarkingObserver& aObserver )

    {

    iMarkingObserver = &aObserver;

    }

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

// CHgScroller::CHgScroller()

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

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

//

CHgScroller::CHgScroller( 

        TInt aItemCount, 

        CGulIcon* aDefaultIcon )

 :  iDefaultIcon( aDefaultIcon ),

    iItemCount(aItemCount), 

    iCurrentRow(-1),

    iSelectedIndex(KErrNotFound),

    iScrollBarType( EHgScrollerScrollBar ),

    iResetViewPosition(ETrue),

    iOldWinPos(KErrNotFound)

    {

    // No implementation required

    }

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

// CHgScroller::~CHgScroller()

// Destructor.

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

//

EXPORT_C CHgScroller::~CHgScroller ( )

    {

    iCoeEnv->RemoveForegroundObserver( *this );

    ReleasePopupFont();

    iItems.ResetAndDestroy();

    delete iManager;

    delete iPhysics;

    delete iScrollbar;

    delete iEmptyText;    

    delete iDefaultIcon;

    delete iPopupDrawer;

    delete iDrawUtils;

    delete iHighlightTimer;

    delete iIndicatorManager;

    delete iKeyUtils;

	delete iTextFind;

	delete iKeyScrollingTimer;

	delete iDetector;

	if(iActionMenu)

	    iActionMenu->RemoveCollection(*this);

    iUpperCaseTitle.Close();

    iPopupText1.Close();

    iPopupText2.Close();

    }

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

// CHgScroller::InitPhysicsL()

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

//

void CHgScroller::InitPhysicsL()

    {

    // For to be able to pan on a empty area. 

    // The world is set to be at least the size of the view.

    TSize worldSize = TotalSize();

    if( !iLandscapeScrolling && (worldSize.iHeight <= iHeight) )

        {

        worldSize.iHeight = iHeight;

        iResetViewPosition = ETrue;

        }

    if( iLandscapeScrolling && (worldSize.iWidth <= iWidth) )

        {

        worldSize.iWidth = iWidth;

        iResetViewPosition = ETrue;

        }

    iPhysics->InitPhysicsL( worldSize, 

                            TSize(iWidth, iHeight), 

                            iLandscapeScrolling);

    }

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

// CHgScroller::Draw()

// Draws the display.

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

//

void CHgScroller::Draw ( const TRect& aRect ) const

    {

    CWindowGc& gc = SystemGc();

    // Flush screen buffer

    InitDrawBuffer();

    DoDraw( aRect );

    if( iScrollbar && iItemCount )

        {

        iScrollbar->Draw( gc );

        }

    if( iPopupDrawer )

        {

        if(iPopupText2.Length() > 0)

            {

            iPopupDrawer->Draw( gc, 

                    iPopupText1,

                    iPopupText2

                    );

            }

        else if( iPopupText1.Length( ) > 0 )

            {

            if( iScrollBarType == EHgScrollerLetterStrip

                    || iScrollBarType == EHgScrollerLetterStripLite )

                {

                iPopupDrawer->DrawNaviChar( gc, iPopupText1 );

                }

            else

                {

                iPopupDrawer->Draw( gc, iPopupText1 );

                }

            }

        else if( iTextFind && iTextFind->Text().Length() > 0 )

            {

            iPopupDrawer->Draw( gc, iTextFind->Text() );

            }

        }

    }

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

// CHgScroller::InitDrawBuffer()

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

//

void CHgScroller::InitDrawBuffer() const

    {

    MAknsSkinInstance* skin = AknsUtils::SkinInstance();

    MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );

    AknsDrawUtils::DrawBackground( skin, cc, this, SystemGc(),

            TPoint(0,0), Rect(), KAknsDrawParamDefault );

    }

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

// CHgScroller::SizeChanged()

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

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

//

void CHgScroller::SizeChanged ( )

    {

    iWidth = Rect().Width();

    iHeight = Rect().Height();

    HandleItemCountChanged();

    if( iPopupDrawer )

        {

        ReleasePopupFont();

        TFontSpec fontSpecTitle = AknLayoutUtils::FontFromId(EAknLogicalFontPrimaryFont)->FontSpecInTwips();

        fontSpecTitle.iHeight = KFocusTextFontSize; // set height

        iCoeEnv->ScreenDevice()->GetNearestFontInTwips(iPopupFont, fontSpecTitle);

        iPopupDrawer->Init( Rect(), iPopupFont );

        }

    if(iResetViewPosition)

        {

        iViewPosition = TPoint(iWidth/2, iHeight/2);

        iResetViewPosition = EFalse;