/*

* Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  The Toolbar button class

*

*/

// INCLUDE FILES

#include <e32std.h>

#include <AknUtils.h>

#include <stringloader.h>

#include "ToolBarButton.h"

#include "ToolBar.h"

#include "W32STD.H"

#include <recenturlstore.h>

#include <Uri16.h>

#include <GULICON.H>

#include <AknBidiTextUtils.h>

#include <brctlinterface.h>

#include <favouritesitem.h>

#include <favouritesitemlist.h>

#include <favouritessession.h>

#include <favouritesdb.h>

#include "eikon.hrh"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

const TInt KListItemMargin = 9;

const TInt KListMargin = 10;

const TInt KBorderSize = 5;

const TInt KCursorOffset = 8;

const TInt KDropdownSlidePixel = 20;

_LIT(KTitle,"title");

_LIT(KUrl,"url");

const TInt KMaxBorderAlpha = 128; // how dark is the shadow around the sprite

const TInt KDefaultTransparency = 10; // % transparent

const TInt KToolTipBorder = 4;

const TInt KTextMargin = 3;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

// ============================= LOCAL FUNCTIONS ===============================

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

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

// CDropDownList::CDropDownList

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

// might leave.

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

//

CDropDownList::CDropDownList(

    CDropDownButton& aParent,

    CArrayPtrFlat<HBufC>* aItemText,

    CArrayPtrFlat<CGulIcon>* aItemIcon )

    : iParent( &aParent ), iItemText( aItemText ), iItemIcon( aItemIcon ), iSize( -1, -1 )

    {

    }

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

// CDropDownList::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CDropDownList::ConstructL()

    {

    iAnimTimer = CPeriodic::NewL( CActive::EPriorityHigh );

    }

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

// CDropDownList::NewL

// Two-phased constructor.

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

//

CDropDownList* CDropDownList::NewL(

    CDropDownButton& aParent,

    CArrayPtrFlat<HBufC>* aItemText,

    CArrayPtrFlat<CGulIcon>* aItemIcon )

    {

    CDropDownList *self = new CDropDownList( aParent, aItemText, aItemIcon );

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// Destructor

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

CDropDownList::~CDropDownList()

    {

    if ( iItemText )

        {

        iItemText->ResetAndDestroy();

        delete iItemText;

        }

    if ( iItemIcon )

        {

        iItemIcon->ResetAndDestroy();

        delete iItemIcon;

        }

    if ( iAnimTimer )

        {

        iAnimTimer->Cancel();

        delete iAnimTimer;

        }

    delete iDropDownBitmapDevice;

    delete iDropDownBitmapContext;

    delete iDropDownBitmap;

    delete iSpriteBitmapDevice;

    delete iSpriteBitmapContext;

    delete iSpriteBitmap;

    delete iSpriteMaskBitmapDevice;

    delete iSpriteMaskBitmapContext;

    delete iSpriteMaskBitmap;

    delete iMaskBitmapDevice;

    delete iMaskBitmapContext;

    delete iMaskBitmap;

    iDropSprite.Close();

    }

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

// CDropDownList::MakeVisible

//

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

//

void CDropDownList::MakeVisible(

    TBool aVisible )

    {

    if ( iVisible == aVisible || iItemText->Count() == 0 )

        {

        return;

        }

    // We have toggled visibility for this dropdown list

    iVisible = aVisible;

    if ( !iVisible )

        {

        // If requesting to close dropdown list, close it without animation

        iAnimTimer->Cancel();

        //iDropSlide = 0;

        iDropSprite.Close();

           iSpriteInitialised = EFalse;

        return;

        }

    if ( !iAnimTimer->IsActive() )

        {

        // If not currently animating, animate dropdown list open

        iAnimTimer->Start( 0, 1000, TCallBack( &DropDownCb, this ) );

        }

    if ( iVisible )

        {

        TBool build( EFalse );

        // get position

        iPosition.iX = iParent->ToolBar().Position().iX + iParent->Position().iX;

        iPosition.iY = iParent->ToolBar().Position().iY + iParent->ToolBar().Size().iHeight - KBorderSize;

        if ( iSize == TSize( -1, -1 ) )

            {

            iSize = CalculateListSize();

            TRAP_IGNORE(CreateBitmapL());

            }

        // adjust position

        CCoeControl& view = iParent->ToolBar().ToolBarCallback().View();

        // out of the view case

        if ( iPosition.iX + iSize.iWidth > view.Size().iWidth )

            {

            iPosition.iX -= ( ( iPosition.iX + iSize.iWidth ) - view.Size().iWidth );

            }

        // y

        if ( iPosition.iY + iSize.iHeight > view.Size().iHeight )

            {

            build = !iDropUp;

            iDropUp = ETrue;

            iPosition.iY = iParent->ToolBar().Position().iY - iSize.iHeight + KBorderSize;

            }

        else

            {

            build = iDropUp;

            iDropUp = EFalse;

            }

        if ( build || iSelectedItem != -1 )

            {

            iSelectedItem = -1;

            TRAP_IGNORE(DrawDropDownListL());

            }

        ConstructSprite();

        }

    }

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

// CDropDownList::HandleOfferKeyEventL

//

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

//

TKeyResponse CDropDownList::HandleOfferKeyEventL(

    const TKeyEvent& aKeyEvent,

    TEventCode aEventCode )

    {

    if ( !iVisible )

        {

        return EKeyWasNotConsumed;

        }

    // The arrow key events

    if ( aEventCode == EEventKey )

        {

        if (    aKeyEvent.iCode == EKeyLeftUpArrow          // Northwest

             || aKeyEvent.iCode == EStdKeyDevice10          //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyUpArrow              // North

             || aKeyEvent.iCode == EKeyRightUpArrow         // Northeast

             || aKeyEvent.iCode == EStdKeyDevice11          //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyLeftDownArrow        // Southwest

             || aKeyEvent.iCode == EStdKeyDevice13          //   : Extra KeyEvent supports diagonal event simulator wedge

             || aKeyEvent.iCode == EKeyDownArrow            // South

             || aKeyEvent.iCode == EKeyRightDownArrow       // Southeast

             || aKeyEvent.iCode == EStdKeyDevice12 )        //   : Extra KeyEvent supports diagonal event simulator wedge

            {

            iParent->ToolBar().MakeToolTipVisible(EFalse);

            if (    ( !iDropUp && (    aKeyEvent.iCode == EKeyLeftUpArrow       // Northwest

                                    || aKeyEvent.iCode == EStdKeyDevice10       //   : Extra KeyEvent supports diagonal event sim

                                    || aKeyEvent.iCode == EKeyUpArrow           // North

                                    || aKeyEvent.iCode == EKeyRightUpArrow      // Northeast

                                    || aKeyEvent.iCode == EStdKeyDevice11 ) )   //   : Extra KeyEvent supports diagonal event sim

                 || (  iDropUp && (    aKeyEvent.iCode == EKeyLeftDownArrow     // Southwest

                                    || aKeyEvent.iCode == EStdKeyDevice13       //   : Extra KeyEvent supports diagonal event sim

                                    || aKeyEvent.iCode == EKeyDownArrow         // South

                                    || aKeyEvent.iCode == EKeyRightDownArrow    // Southeast

                                    || aKeyEvent.iCode == EStdKeyDevice12 ) ) ) //   : Extra KeyEvent supports diagonal event sim

                {

                // can go down to -1

                iSelectedItem = --iSelectedItem >= -1 ? iSelectedItem : -1;

                }

            else

                {

                iSelectedItem = ++iSelectedItem > iItemText->Count() - 1 ? 0 : iSelectedItem;

                }

            DrawDropDownListL();

            // update cursor unless we move out of the dropdown

            if ( iSelectedItem != -1 )

                {

                TSize bmSize( iDropDownBitmap->SizeInPixels() );

                const CFont* font = LatinBold16();

                TInt height( font->AscentInPixels() + KListItemMargin );

                TPoint curPos( bmSize.iWidth/2, KListMargin + iSelectedItem * height + KCursorOffset );

                if ( iDropUp )

                    {

                    curPos.iY = bmSize.iHeight - curPos.iY - height + KCursorOffset;

                    }

                curPos+= iPosition;

                iParent->ToolBar().ToolBarCallback().SetAndUpdateCursorPosition( curPos );

                //iParent->ToolBar().Draw(*(CWindowGc*)NULL);

                iParent->ToolBar().Draw();

                iParent->ToolBar().SelectableItemHighlighted();

                }

             else

                {

                iParent->ToolBar().UpdateCursorPosition();

                iParent->ToolBar().ToolBarCallback().View().DrawDeferred();

                }

            }

        else if ( aKeyEvent.iCode == EKeyDevice3 && SelectedItem() != -1 )

            {

            // The activate

            iParent->ActivatedL( SelectedItem() );

            return EKeyWasConsumed;

            }

        }

    return EKeyWasNotConsumed;

    }

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

// CDropDownList::HandlePointerEventL

//

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

//

TBool CDropDownList::HandlePointerEventL( const TPointerEvent& aPointerEvent )

    {

    TPointerEvent::TType pEventType = aPointerEvent.iType;

    if ( pEventType == TPointerEvent::EButton1Up )

        {

        TRect listRect(iPosition, iSize);

        if (listRect.Contains(aPointerEvent.iPosition))

            {

            TInt itemCount = iItemText->Count();

            TInt itemHight = (listRect.Height()-KBorderSize)/itemCount;

            TSize itemSize(listRect.Width(), itemHight);

            TPoint cPosition = iPosition;

            iOldSelectedItem = SelectedItem();

            TInt n;

            for ( n = iDropUp ? (itemCount - 1):0; iDropUp ? n >= 0:n <= itemCount ; iDropUp ? n--:n++)

                {

                TRect itemRect(cPosition, itemSize);

                if (itemRect.Contains(aPointerEvent.iPosition))

                    {

                    iSelectedItem = n;

                    DrawDropDownListL();

                    iParent->ToolBar().ToolBarCallback().View().DrawNow();

                    if (SelectedItem() == iOldSelectedItem && iSelectedItem != -1)

                        {

                        iParent->ActivatedL( SelectedItem() );

                        }

                    return EFalse;

                    }

                cPosition.iY += itemHight;

                }

            }

        }

    return ETrue;

    }

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

// CDropDownList::Draw

//

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

//

//void CDropDownList::Draw(

  //  CWindowGc& /*aGc*/ )

void CDropDownList::Draw()

    {

    if ( iVisible || iAnimTimer->IsActive() )

        {

        TSpriteMember spriteMem;

        TSize bmSize( iSpriteBitmap->SizeInPixels() );

        //

        iSpriteBitmapContext->Clear();

        iSpriteMaskBitmapContext->Clear();

        if ( iDropUp )

            {

            iSpriteBitmapContext->BitBlt( TPoint( 0, bmSize.iHeight - iDropSlide/* - yOffset*/ ), *iDropDownBitmapContext,

                TRect( TPoint( 0, 0 ), TSize( bmSize.iWidth, iDropSlide )  ) );

            iSpriteMaskBitmapContext->BitBlt( TPoint( 0, bmSize.iHeight - iDropSlide /*- yOffset*/ ), iMaskBitmap,

                TRect( TPoint( 0, 0 ), TSize( bmSize.iWidth, iDropSlide )  ) );

            }

        else

            {

            iSpriteBitmapContext->BitBlt( TPoint( 0, 0 ), *iDropDownBitmapContext,

                TRect( TPoint( 0, bmSize.iHeight - iDropSlide  ), TSize( bmSize.iWidth, iDropSlide )  ) );

            iSpriteMaskBitmapContext->BitBlt( TPoint( 0, 0 ), iMaskBitmap,

                TRect( TPoint( 0, bmSize.iHeight - iDropSlide ), TSize( bmSize.iWidth, iDropSlide )  ) );

            }

        spriteMem.iBitmap = iSpriteBitmap;

        spriteMem.iMaskBitmap = iSpriteMaskBitmap;

        if (iSpriteInitialised)

            {

            iDropSprite.UpdateMember(0, spriteMem);

            }

        else

            {

            iSpriteInitialised = ETrue;

            iDropSprite.AppendMember(spriteMem);

            iDropSprite.SetPosition(iPosition);

            iDropSprite.Activate();

            }

        }

    iParent->RefreshToolTip();

    }

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

// CDropDownList::UpdateIconsL

//

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

//

void CDropDownList::UpdateIconsL(

    CArrayPtrFlat<CGulIcon>* aItemIcon )

    {

    delete iItemIcon;

    iItemIcon = aItemIcon;

    //

    CCoeControl& view = iParent->ToolBar().ToolBarCallback().View();

    TSize size( CalculateListSize() );

    if ( iSize != size )

        {

        TInt diff( size.iWidth - iSize.iWidth );

        iSize = size;

        CreateBitmapL();

        // adjust dropdown x pos

        if ( iPosition.iX - diff > 0 )

            {

            iPosition.iX -= diff;

            }

        }

    DrawDropDownListL();

   iParent->ToolBar().Draw();

    }

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

// CDropDownList::DropDownCb

//

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

//

void CDropDownList::AnimateDropDown()

    {

    TSize bmSize( iDropDownBitmap->SizeInPixels() );

    if ( iVisible )

        {

        iDropSlide+=KDropdownSlidePixel;

        if ( iDropSlide >= bmSize.iHeight )

            {

            iDropSlide = Min( iDropSlide, bmSize.iHeight );

            iAnimTimer->Cancel();

            }

        }

    else

        {

        iDropSlide-=KDropdownSlidePixel;

        if ( iDropSlide <= 0 )

            {

            iDropSlide = Max( iDropSlide, 0 );

            iAnimTimer->Cancel();

            }

        }

        iParent->ToolBar().Draw();

    }

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

// CDropDownList::DropDownCb

//

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

//

TInt CDropDownList::DropDownCb(

    TAny* aPtr )

    {

    static_cast<CDropDownList*>(aPtr)->AnimateDropDown();

    return ETrue;

    }

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

// CDropDownList::CreateBitmapL

//

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

//

void CDropDownList::CreateBitmapL()

    {

    delete iDropDownBitmapDevice;

    iDropDownBitmapDevice = NULL;

    delete iDropDownBitmapContext;

    iDropDownBitmapContext = NULL;

    delete iDropDownBitmap;

    iDropDownBitmap = NULL;

    iDropDownBitmap = new (ELeave) CFbsBitmap;

    User::LeaveIfError( iDropDownBitmap->Create( iSize, EColor16MA ) );

    iDropDownBitmapDevice = CFbsBitmapDevice::NewL( iDropDownBitmap );

    User::LeaveIfError( iDropDownBitmapDevice->CreateContext( iDropDownBitmapContext ) );

    // draw shadows only once

    TRect r( TPoint( 0, 0 ), iDropDownBitmap->SizeInPixels() );

    iDropDownBitmapContext->SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

    iDropDownBitmapContext->SetBrushStyle( CGraphicsContext::ESolidBrush );

    iDropDownBitmapContext->SetPenStyle( CGraphicsContext::ENullPen );

    iDropDownBitmapContext->SetBrushColor( TRgb( 242, 244, 242, 20 ) );

    iDropDownBitmapContext->DrawRect( r );

    iDropDownBitmapContext->SetDrawMode( CGraphicsContext::EDrawModeWriteAlpha );

    iDropDownBitmapContext->SetPenStyle( CGraphicsContext::ESolidPen );

    iDropDownBitmapContext->SetBrushStyle( CGraphicsContext::ENullBrush );

    // wider shadow to bottom, no shadow to top

    TInt bw = KBorderSize;

    for (TInt n=1;n<=2*bw-1;n++)

        {

        iDropDownBitmapContext->SetPenColor(TRgb(0,0,0,n*n*KMaxBorderAlpha/(2*2*bw*bw)));

        iDropDownBitmapContext->DrawRect( r );

        r.iTl.iX += n%2;

        r.iBr.iX -= n%2;

        r.iBr.iY -= 1;

        }

    delete iSpriteBitmapDevice;

    iSpriteBitmapDevice = NULL;

    delete iSpriteBitmapContext;

    iSpriteBitmapContext = NULL;

    delete iSpriteBitmap;

    iSpriteBitmap = NULL;

    iSpriteBitmap = new (ELeave) CFbsBitmap;

    User::LeaveIfError( iSpriteBitmap->Create( iSize, EColor16MA ) );

    iSpriteBitmapDevice = CFbsBitmapDevice::NewL( iSpriteBitmap );

    User::LeaveIfError( iSpriteBitmapDevice->CreateContext( iSpriteBitmapContext ) );

    iSpriteBitmapContext->CopySettings(*iDropDownBitmapContext);

    //mask

    delete iSpriteMaskBitmapDevice;

    iSpriteMaskBitmapDevice = NULL;

    delete iSpriteMaskBitmapContext;

    iSpriteMaskBitmapContext = NULL;

    delete iSpriteMaskBitmap;

    iSpriteMaskBitmap = NULL;

    iSpriteMaskBitmap = new (ELeave) CFbsBitmap;