/*

* 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 class

*

*/

// INCLUDE FILES

#include <AknUtils.h>

#include <StringLoader.h>

#include <AknsConstants.h>

#include <AknsUtils.h>

#include <AknsItemID.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <eikbtgpc.h>

#include <webkitutils.rsg>

#include <webkitutilsicons.mbg>

#include "ToolBar.h"

#include "ToolBarButton.h"

#include "BrCtlDefs.h"

#include "eikon.hrh"

// EXTERNAL DATA STRUCTURES

// EXTERNAL FUNCTION PROTOTYPES

// CONSTANTS

_LIT( KToolBarSvgFile, "webkitutilsicons.mif" );

_LIT( KToolBarBitmapsFile, "webkitutils.mbm" );

const TInt KMargin = 5;

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

const TInt KButtonCount = 7;

const TInt KAnimDeltaX = 25;

const TInt KAnimDeltaY = 12;

const TInt KShadow = 4;

const TInt KToolTipDelay = 1500000;

// MACROS

// LOCAL CONSTANTS AND MACROS

// MODULE DATA STRUCTURES

// LOCAL FUNCTION PROTOTYPES

// FORWARD DECLARATIONS

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

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

// DoToolTipCb

// C-style TCallback function

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

TInt DoToolTipCb(

    TAny* aPtr )

    {

    CToolBar* t = static_cast<CToolBar*>(aPtr);

    t->MakeToolTipVisible();

    return EFalse;

    }

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

// Animate

// C-style TCallback function

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

TBool Animate(

    TAny* aAny )

    {

    CToolBar* toolBar = static_cast<CToolBar*> (aAny);

    TBool result = toolBar->ToolBarAnimation();

    return result;

    }

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

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

// CToolBar* CToolBar::NewL(MToolBarCallBack& aToolBarCallBack)

// Two phase construction

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

EXPORT_C CToolBar* CToolBar::NewL(

    MToolBarCallback& aToolBarCallback)

    {

    CToolBar *self = new CToolBar(aToolBarCallback);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CToolBar::CToolBar(MToolBarCallBack& aToolBarCallBack)

// Two phase construction

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

CToolBar::CToolBar(MToolBarCallback& aToolBarCallback)

    : iToolBarCallback(&aToolBarCallback),

    iOrigCursorPos(iToolBarCallback->CursorPosition()),

    iCba(NULL)

    {

    }

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

// CToolBar::ConstructL()

// Two phase construction

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

void CToolBar::ConstructL()

    {

    // move cursor off screen to hide it

    iToolBarCallback->SetAndUpdateCursorPosition(TPoint(-20,-20));

    LoadResourceFileL();

    CreateCbaL();

    iMbmFile = GetCannedImageDirL();

    iMbmFile->Des().Append( KToolBarBitmapsFile );

    iSvgMbmFile = GetCannedImageDirL();

    iSvgMbmFile->Des().Append( KToolBarSvgFile );

    iButtonArray = new (ELeave) CArrayPtrFlat<CToolBarButton>(KButtonCount);

    iButtonConfigArray = new (ELeave) CArrayFixFlat<TUint>(KButtonCount);

    InitToolbarL();

    iOffScreenBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( iOffScreenBitmap->Create( iToolBarSize,  EColor16MA) );

    iBitmapDevice = CFbsBitmapDevice::NewL(iOffScreenBitmap);

    User::LeaveIfError(iBitmapDevice->CreateContext(iBitmapGc));

    iMaskBitmap = new (ELeave) CFbsBitmap();

    User::LeaveIfError( iMaskBitmap->Create( iToolBarSize,  EColor256) );

    iMaskBitmapDevice = CFbsBitmapDevice::NewL(iMaskBitmap);

    User::LeaveIfError(iMaskBitmapDevice->CreateContext(iMaskBitmapGc));

    DrawToolbarToBitmap();

    DrawButtonsToBitmap();

    TInt x = iOrigCursorPos.iX;

    TInt y = iOrigCursorPos.iY;

    CCoeControl& view = iToolBarCallback->View();

    TRect r(TPoint(0,0),view.Size());

    TInt dx = Min(x , r.iBr.iX - x);

    TInt dy = Min(y , r.iBr.iY - y);

    iAnimDirX = dx >= dy ? 0: (r.iBr.iX - x > x) ? 1 : -1;

    iAnimDirY = dy > dx ? 0: (r.iBr.iY - y > y) ? 1 : -1;

    TInt count = iButtonArray->Count();

    if (count <= 0)

        User::Leave(KErrUnderflow);

    iPosition.iX = iAnimDirX == 0 ? Min(x - iToolBarSize.iWidth/(2*count), r.iBr.iX - iToolBarSize.iWidth)

                   : iAnimDirX == 1 ? - iToolBarSize.iWidth : r.iBr.iX;

    iPosition.iY = iAnimDirY == 0 ? Min(y - iToolBarSize.iHeight/2, r.iBr.iY - iToolBarSize.iHeight)

                   : iAnimDirY == 1 ? - iToolBarSize.iHeight : r.iBr.iY;

    iAnimationTimer = CIdle::NewL( CActive::EPriorityHigh );

    iAnimationTimer->Start(TCallBack(&Animate,this));

    iToolTipTimer = CPeriodic::NewL( CActive::EPriorityLow );

    ConstructSprite();

    UpdateCursorPosition();

    }

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

// void CToolBar::InitToolbarL()

// Method to init and layout toolbar buttons

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

void CToolBar::InitToolbarL()

    {

    TInt x = KMargin + KShadow;

    TInt y = KMargin;

    TInt h = 0;

    for (TUint i= TBrCtlDefs::ESettingsToolbarButton1Cmd ; i<= TBrCtlDefs::ESettingsToolbarButton7Cmd ; i++ )

        {

        TUint buttonsettingval = iToolBarCallback->GetBrowserSettingL( i );

        TInt buttoncmd = ToolbarCommandDecodeMatrix[buttonsettingval][KToolbarCommandDecodeMatrixCmdVal];

        TInt buttonstring = ToolbarCommandDecodeMatrix[buttonsettingval][KToolbarCommandDecodeMatrixStringId];

        switch (buttoncmd)

            {

            case EToolBarNone:

                {

                break;

                }

            case EToolBarRecenUrls:

                {

                HBufC* visitedToolTip = StringLoader::LoadLC(buttonstring);

                CVisitedButton*visitedButton = CVisitedButton::NewL(*this, buttoncmd,*visitedToolTip);

                CleanupStack::PopAndDestroy();

                visitedButton->SetPosition(TPoint(x,y));

                x += visitedButton->Size().iWidth + KMargin;

                h = Max(h,visitedButton->Size().iHeight);

                iButtonArray->AppendL(visitedButton);

                iButtonConfigArray->AppendL(buttoncmd);

                break;

                }

            case EToolBarListBookmarks:

                {

                HBufC* BookmarksToolTip = StringLoader::LoadLC(buttonstring);

                CBookmarksButton*bookmarksButton = CBookmarksButton::NewL(*this, buttoncmd,*BookmarksToolTip);

                CleanupStack::PopAndDestroy();

                bookmarksButton->SetPosition(TPoint(x,y));

                x += bookmarksButton->Size().iWidth + KMargin;

                h = Max(h,bookmarksButton->Size().iHeight);

                iButtonArray->AppendL(bookmarksButton);

                iButtonConfigArray->AppendL(buttoncmd);

                break;

                }

            case EToolBarSubscribeToFeeds:

                {

                const RPointerArray<TBrCtlSubscribeTo>& feedsArray = iToolBarCallback->SubscribeToMenuItemsL();

                HBufC* feedsToolTip = StringLoader::LoadLC(buttonstring);

                CRssButton* rssButton = CRssButton::NewL(*this, buttoncmd,*feedsToolTip,feedsArray);

                CleanupStack::PopAndDestroy();

                rssButton->SetPosition(TPoint(x,y));

                x += rssButton->Size().iWidth + KMargin;

                h = Max(h,rssButton->Size().iHeight);

                iButtonArray->AppendL(rssButton);

                iButtonConfigArray->AppendL(buttoncmd);

                break;

                }

            case EToolBarMiniatureShow:

            case EToolBarReload:

            case EToolBarFindKeyword:

            case EToolBarSettings:

            case EToolBarGoToWebAddress:

            case EToolBarManageBookmarks:

            case EToolBarSaveAsBookmark:

            case EToolBarPreviousPage:

            case EToolBarVisualHistory:

            case EToolBarGoToHompage:

            case EToolBarZoomIn:

            case EToolBarZoomOut:

            case EToolBarRotateScreen:

            case EToolBarViewImages:

            case EToolBarSavePage:

            case EToolBarSwitchWindow:

            case EToolBarShowKeymap:

            case EToolBarShowHelp:

            case EToolBarFullScreen:

                {

                HBufC* str = StringLoader::LoadLC(buttonstring);

                CToolBarButton* b = CToolBarButton::NewL(*this, buttoncmd, *str);

                CleanupStack::PopAndDestroy();

                b->SetPosition(TPoint(x,y));

                x += b->Size().iWidth + KMargin;

                h = Max(h,b->Size().iHeight);

                iButtonArray->AppendL(b);

                iButtonConfigArray->AppendL(buttoncmd);

                break;

                }

            /* Zoom Mode not currently in use

            case EToolBarZoomMode:

                {

                if ( !iToolBarCallback->wmlMode() )

                    {

                    HBufC* str = StringLoader::LoadLC(buttonstring);

                    CToolBarButton* b = CToolBarButton::NewL(*this, buttoncmd, *str);

                    CleanupStack::PopAndDestroy();

                    b->SetPosition(TPoint(x,y));

                    x += b->Size().iWidth + KMargin;

                    h = Max(h,b->Size().iHeight);

                    iButtonArray->AppendL(b);

                    iButtonConfigArray->AppendL(buttoncmd);

                    }

                break;

                }

            */

            default:

                break;  // shouldn't get here

            }

        } // for loop end

    iToolBarSize = TSize(x + KShadow,h + 2*KMargin + KShadow);

    }

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

// CToolBar::DrawToolbarToBitmap()

// Method to draw the empty toolbar to the offscreen bitmap

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

void CToolBar::DrawToolbarToBitmap()

    {

    iMaskBitmapGc->SetPenStyle( CGraphicsContext::ESolidPen );

    iMaskBitmapGc->SetPenColor( TRgb( 0, 0, 0 ) );

    iMaskBitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    iMaskBitmapGc->SetBrushColor( TRgb( 0, 0, 0 ) );

    iMaskBitmapGc->DrawRect( TRect( TPoint( 0, 0 ), iToolBarSize ) );

    TRect r1(iPosition,iToolBarSize);

    iMaskBitmapGc->SetPenStyle(CGraphicsContext::ESolidPen);

    iMaskBitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

    // wider shadow to bottom, no shadow to top

    TInt bw = KShadow;

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

        {

        TInt grade = 85*n/(2*bw);

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

        iMaskBitmapGc->SetPenColor(TRgb(255-grade, 255-grade, 255-grade));

        iMaskBitmapGc->DrawRect(r1);

        r1.iTl.iX += n%2;

        r1.iBr.iX -= n%2;

        r1.iBr.iY -= 1;

        }

    iBitmapGc->SetPenStyle( CGraphicsContext::ESolidPen );

    iBitmapGc->SetPenColor( TRgb( 242, 244, 242 ) );

    iBitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

    iBitmapGc->SetBrushColor( TRgb( 242, 244, 242 ) );

    iBitmapGc->DrawRect( TRect( TPoint( 0, 0 ), iToolBarSize ) );

    TRect r(iPosition,iToolBarSize);

    iBitmapGc->SetDrawMode(CGraphicsContext::EDrawModeWriteAlpha);

    iBitmapGc->SetPenStyle(CGraphicsContext::ESolidPen);

    iBitmapGc->SetBrushStyle(CGraphicsContext::ENullBrush);

    // wider shadow to bottom, no shadow to top

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

        {

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

        iBitmapGc->DrawRect(r);

        r.iTl.iX += n%2;

        r.iBr.iX -= n%2;

        r.iBr.iY -= 1;

        }

    }

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

// CToolBar::DrawButtonsToBitmap()

// Method to draw the toolbar buttons to the offscreen bitmap

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

void CToolBar::DrawButtonsToBitmap()

    {

    iBitmapGc->SetDrawMode(CGraphicsContext::EDrawModePEN);

    for (TInt i = 0; i < iButtonArray->Count() ;i++)

        {

        CToolBarButton * b = (*iButtonArray)[i];

        TRect bmpPieceRect(b->Position(),b->Size());

        CFbsBitmap& bmp = b->ButtonImage();

        CFbsBitmap& mask = b->ButtonMaskImage();

        if (i == iFocusedButtonIndex)

            {

            iBitmapGc->SetPenStyle( CGraphicsContext::ESolidPen );

            iBitmapGc->SetPenColor( TRgb( 194, 195, 194 ) );

            iBitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

            iBitmapGc->SetBrushColor( TRgb( 194, 195, 194 ) );

            iBitmapGc->DrawRect( bmpPieceRect );

            }

        else

            {

            iBitmapGc->SetPenStyle( CGraphicsContext::ESolidPen );

            iBitmapGc->SetPenColor( TRgb( 242, 244, 242 ) );

            iBitmapGc->SetBrushStyle( CGraphicsContext::ESolidBrush );

            iBitmapGc->SetBrushColor( TRgb( 242, 244, 242 ) );

            iBitmapGc->DrawRect( bmpPieceRect );

            }

        iBitmapGc->BitBltMasked(b->Position(),&bmp, TRect(TPoint(0,0),b->Size()),&mask, ETrue);

        }

    }

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

// CToolBar::UpdateCursorPosition()

// Method to update cursor position

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

void CToolBar::UpdateCursorPosition()

{

    if (iButtonArray->Count() > iFocusedButtonIndex) {

        CToolBarButton* b = iButtonArray->At(iFocusedButtonIndex);

        if (b) {

            TPoint pt = iPosition + b->Position() + TPoint(b->Size().iWidth/2,b->Size().iHeight/2);

            iCursorPosition = pt;

            SelectableItemHighlighted(CanActivateButton());

        }

    }

}

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

// CToolBar::MakeToolTipVisible()

// Method called by the timer to make the tooltip visible

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

void CToolBar::MakeToolTipVisible(TBool aVisible)

    {

    iToolTipTimer->Cancel();

    //Show tooltip only if the animation is not running

    if ( !iAnimationTimer->IsActive() )

        {

        CToolBarButton* b = (*iButtonArray)[iFocusedButtonIndex];

        b->ShowToolTip(aVisible);

        }

    }

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

// CToolBar::StartToolTipTimer()

// Method to start the tooltip timer

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

void CToolBar::StartToolTipTimer()

    {

    iToolTipTimer->Cancel();

    iToolTipTimer->Start( KToolTipDelay, 0, TCallBack( &DoToolTipCb, this ) );

    }

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

// CToolBar::ToolBarAnimation()

// Method to do toolbar animation

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

TBool CToolBar::ToolBarAnimation()

    {

    TPoint cp = iOrigCursorPos;

    TInt dir = iCanCloseToolBar ? -1 : 1;

    iPosition += TPoint(dir*iAnimDirX*KAnimDeltaX,dir*iAnimDirY*KAnimDeltaY);

    CCoeControl& view = iToolBarCallback->View();

    TBool ret = ETrue;

    if (iCanCloseToolBar)

        {

        TRect r(TPoint(0,0),view.Size());

        TRect tbRect = TRect(iPosition,iToolBarSize);

        ret = r.Intersects(tbRect);

        if (ret)

            {

            iSprite.SetPosition( iPosition );

            }

        else

            {

            if (iActivateButton)

                {

                //Now handle the toolbar activation

                HandleButtonActivation();

                }

            else{

                iSprite.Close();

                TRAP_IGNORE(iToolBarCallback->CloseToolBarL());

                }

            }

        }

    else

        {

        TPoint p = iPosition;

        if (iAnimDirY == 0)

            {

            TInt count = iButtonArray->Count();

            TInt dx = count != 0 ? iToolBarSize.iWidth/(2*count) : 0;

            p.iX = iAnimDirX == 1 ? Min(p.iX,Max(0,cp.iX - dx))

                       : Max(p.iX,Min(cp.iX + dx,view.Size().iWidth - iToolBarSize.iWidth));

            ret = p.iX == iPosition.iX;

            }

        else

            {

            p.iY= iAnimDirY == 1 ? Min(p.iY,Max(0,cp.iY - iToolBarSize.iHeight/2))

                       : Max(p.iY,Min(cp.iY - iToolBarSize.iHeight/2,view.Size().iHeight - iToolBarSize.iHeight));

            ret = p.iY == iPosition.iY;

            }

        if (!ret)

            {

            if (((cp.iX + iToolBarSize.iWidth) > view.Size().iWidth) && 

                (iAnimDirX == 1))

                {

                p.iX = view.Size().iWidth - iToolBarSize.iWidth;

                }

            iPosition = p;

            iSprite.SetPosition( iPosition );

            UpdateCursorPosition();

            CToolBarButton * b = (*iButtonArray)[iFocusedButtonIndex];

            b->SetFocus(ETrue);

            StartToolTipTimer();

            view.DrawNow();

            }

        else

            {

            iSprite.SetPosition( iPosition );

            }

        }

    return ret;

    }

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

// CToolBar::AnimateToolBarClosing()

// Method to do toolbar animation when closing it

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

EXPORT_C void CToolBar::AnimateToolBarClosing(

    TBool aActivateButton )

    {

    iAnimationTimer->Cancel();

    CToolBarButton* b = (*iButtonArray)[iFocusedButtonIndex];

    b->SetFocus(EFalse);

    iCanCloseToolBar = ETrue;

    iActivateButton = aActivateButton;

    iAnimationTimer->Start(TCallBack(&Animate,this));

    }

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

// CToolBar::CToolBar()

// Destructor

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

CToolBar::~CToolBar()

    {

    if( iToolBarCallback )

        {