/*

* Copyright (c) 2005-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:  Button component

*

*/

// INCLUDE FILES

#include <aknbutton.h>

#include <gulicon.h>        // CGulIcon

#include <barsread.h>       // TResourceReader

#include <avkon.hrh>

#include <StringLoader.h>   // StringLoader

#include <AknsDrawUtils.h>

#include <AknsControlContext.h>

#include <AknBidiTextUtils.h>

#include <aknlayout.cdl.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknInfoPopupNoteController.h>

#include <AknPictographInterface.h>

#include <AknPictographDrawerInterface.h>

#include <AknsFrameBackgroundControlContext.h>

#include <aknconsts.h>

#include <layoutmetadata.cdl.h>

#include <AknPriv.hrh>

#include <AknLayoutFont.h>

#include <akniconconfig.h>

#include <AknTasHook.h> // for testability hooks

#include "aknresourceprovider.h"

#include "aknbitmapresourceitem.h"

#include "akncommandbuttonstate.h"

#include <touchfeedback.h>

const TUint KPointerFlag = 3; // second bit

// CONSTANTS

enum TSkinItemIdIndex

    {

    KFrameId = 0,

    KCenterId,

    KLatchedFrameId,

    KLatchedCenterId,

    KDimmedFrameId,

    KDimmedCenterId,

    KPressedFrameId,

    KPressedCenterId,

    KLatchedDimmedFrameId,

    KLatchedDimmedCenterId

    };

// ATTENTION, if the values bellow are changed, make the changes in AknButton.h

const TInt KTimeoutBeforeHelpNote = 150; // in milliseconds

const TInt KTimeoutInViewHelpNote = 3000; // in milliseconds

const TInt KKeyRepeatDelay = 500000;   // 0,5 seconds

const TInt KKeyRepeatInterval = 500000; // 0,5 seconds

const TInt KLongPressInterval = 800000; // 0,8 seconds

const TInt KDragEventSensitivity = 1;

// Value table for 70% Transparency 

const TInt KTransparency[256] =

    { 

    0, 1, 1, 1, 2, 2, 2, 2, 3, 3, 3, 4, 4, 4, 5, 5, 5, 5, 6, 6, 6, 7, 7, 7,

    8, 8, 8, 8, 9, 9, 9, 10, 10, 10, 11, 11, 11, 11, 12, 12, 12, 13, 13, 13,

    14, 14, 14, 14, 15, 15, 15, 16, 16, 16, 17, 17, 17, 17, 18, 18, 18, 19,

    19, 19, 20, 20, 20, 20, 21, 21, 21, 22, 22, 22, 23, 23, 23, 23, 24, 24,

    24, 25, 25, 25, 26, 26, 26, 26, 27, 27, 27, 28, 28, 28, 29, 29, 29, 29,

    30, 30, 30, 31, 31, 31, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34, 35, 35,

    35, 35, 36, 36, 36, 37, 37, 37, 38, 38, 38, 38, 39, 39, 39, 40, 40, 40,

    41, 41, 41, 41, 42, 42, 42, 43, 43, 43, 44, 44, 44, 44, 45, 45, 45, 46,

    46, 46, 47, 47, 47, 47, 48, 48, 48, 49, 49, 49, 50, 50, 50, 50, 51, 51,

    51, 52, 52, 52, 53, 53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56, 56, 56,

    57, 57, 57, 58, 58, 58, 59, 59, 59, 59, 60, 60, 60, 61, 61, 61, 62, 62,

    62, 62, 63, 63, 63, 64, 64, 64, 65, 65, 65, 65, 66, 66, 66, 67, 67, 67,

    68, 68, 68, 68, 69, 69, 69, 70, 70, 70, 71, 71, 71, 71, 72, 72, 72, 73,

    73, 73, 74, 74, 74, 74, 75, 75, 75, 76, 76, 76, 77, 77 

    };

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

// ResizeIcon

// Tries to resize the given icon. If the operation fails the icon is deleted.

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

//

static TInt ResizeIcon( CGulIcon*& aIcon, 

                        const TSize& aSize, 

                        TScaleMode aScaleMode )

    {

    TInt retval = KErrNotFound;

    if ( aIcon )

        {

        CFbsBitmap* bmp = aIcon->Bitmap();

        if ( bmp )

            {

            retval = !( aSize == bmp->SizeInPixels() );

            }

        if ( retval != KErrNone )

            {

            retval = AknIconUtils::SetSize( bmp, aSize, aScaleMode );

            }

        // Retval is checked outside of the "if ( bmp )" scope above in order

        // to detect if the given icon's bitmap is NULL. This is required since

        // AknIconUtils::SetSize returns KErrNone for NULL bitmaps and we want

        // to delete icons that couldn't be resized.

        if ( retval != KErrNone )

            {

            delete aIcon;

            aIcon = NULL;

            }

        }

    return retval;        

    }

static void ReplaceIconStatic( CGulIcon*& aIcon, CGulIcon* aNewIcon, 

                               TScaleMode aScaleMode )

    {

    TSize iconSize( 0, 0 );

    if ( aIcon && aIcon->Bitmap() )

        {

        iconSize = aIcon->Bitmap()->SizeInPixels();

        }

    delete aIcon;

    aIcon = aNewIcon;

    if ( iconSize != TSize( 0, 0 ) )

        {

        ResizeIcon( aIcon, iconSize, aScaleMode );

        }

    }

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

// CreateAndSetDimmedIconL

// Creates and sets a dimmed icon from the normal icon 

// by making a partially transparent version of it.

//

// @param aIcon The original icon

// @param aDimmedIcon The dimmed icon

// @param aScaleMode The preferred ScaleMode

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

static void CreateAndSetDimmedIconL( CGulIcon*& aDimmedIcon, 

                                     const CGulIcon* aIcon, 

                                     TScaleMode aScaleMode )

    {

    if ( aIcon )

        {

        CFbsBitmap* mask = aIcon->Mask();

        if ( mask && mask->DisplayMode() == EGray256 )

            {

            CGulIcon* newIcon = CGulIcon::NewLC();

            CFbsBitmap* newPic = new ( ELeave ) CFbsBitmap;

            CleanupStack::PushL( newPic );

            newPic->Duplicate( aIcon->Bitmap()->Handle() );

            newIcon->SetBitmap( newPic );

            CFbsBitmap* newMask = new ( ELeave ) CFbsBitmap;

            User::LeaveIfError( newMask->Create( 

                newIcon->Bitmap()->SizeInPixels(), EGray256 ) );

            CleanupStack::PushL( newMask );

            CFbsBitmapDevice* bitmapDevice = CFbsBitmapDevice::NewL( newMask );

            CleanupStack::PushL( bitmapDevice );

            CFbsBitGc* bitGc( NULL );

            User::LeaveIfError( bitmapDevice->CreateContext( bitGc ) );

            CleanupStack::PushL( bitGc );

            bitGc->SetPenStyle( CGraphicsContext::ESolidPen );

            bitGc->BitBlt( TPoint( 0, 0 ), mask );

            newMask->LockHeap();

            TInt w = mask->SizeInPixels().iWidth; 

            TInt h = mask->SizeInPixels().iHeight;

            TInt dataStride = mask->DataStride() - w; 

            unsigned char* address = (unsigned char *)newMask->DataAddress();  

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

                {

                for ( TInt j = 0; j < w; ++j )

                    {

                    *address = KTransparency[*address];

                    ++address;

                    }

                address += dataStride;         

                }

            newMask->UnlockHeap();

            newIcon->SetMask( newMask );

            ReplaceIconStatic( aDimmedIcon, newIcon, aScaleMode );

            CleanupStack::PopAndDestroy( 2 ); // bitmapDevice, bitGc

            CleanupStack::Pop( 3 ); // newIcon, newPic, newMask

            }

        }

    }

// ============================ EXTENSION CLASS ================================

NONSHARABLE_CLASS( CAknButtonExtension ) : public CBase, MCoeControlHitTest

    {

    friend class CAknButton;    

public:

    // bitflags used to keep track of several button's internal features

    enum TFlags

        {

        EUseAdditionalMask,

        ECheckHitArea,

        EDimmed,

        ELongPressReported,

        EUseDefaultIconSize,

        EKeyRepeatEventReported,

        EUseDefaultMargins

        };

    static CAknButtonExtension* NewL( CAknButton& aButton );

    ~CAknButtonExtension();

    // Starts the long press timer.

    void StartLongPressTimerL();

    TBool HitRegionContains( const TPoint &aPoint, 

                             const CCoeControl &aControl ) const;

    void HandleFeedbackAreaChange();

private:

    CAknButtonExtension( CAknButton& aButton );

    void ConstructL();

    // Callback method for long press timer.

    static TInt ReportLongPressL( TAny* aThis );

    // Handles long press.

    void DoReportLongPressL();

    // Deletes pressed down bitmaps

    void DeletePressedBmps();

    // Fetches bitmaps from resource provider (if one exists)

    TBool FetchProviderPressedBmpsL();

    // Sets bitmaps to resource provider (if one exists)

    void SetProviderPressedBmpsL();

private: // Data

    CAknButton& iButton;

    CAknButton::TTooltipPosition iTooltipPosition;

    CAknPictographInterface* iPictographInterface; // not owned

    CPeriodic* iLongPressTimer;

    TInt iLongPressInterval;

    TFontUnderline iUnderlineStyle;

    RArray<TAknsItemID> iFrameAndCenterIds;

    CAknButton::TAlignment iVerticalIconAlignment; 

    CAknButton::TAlignment iHorizontalIconAlignment;

    TMargins8 iMargins;

    TSize iIconSize;

    CAknButton::TTextAndIconAlignment iTextAndIconAlignment;

    TBitFlags iFlags;

    MTouchFeedback* iFeedback;

    CFbsBitmap* iPressedDownBmp;

    CFbsBitmap* iPressedDownBmpMask;

    CAknResourceProvider* iResourceProvider;

    //Previous touch down or drag position, valid only with pressed state. 

    TPoint iPrePointerPos;

    CAknsFrameBackgroundControlContext* iHighlightContext;  

    // buffer for visually ordered text

    TBuf<255 + KAknBidiExtraSpacePerLine> iVisualText; 

    TBool iFeedbackEnabled;

    TAknsItemID iBackgroundSkinIID;

    TRect iBgFrameRect;

    };

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

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

// CAknButtonExtension::CAknButtonExtension

// C++ default constructor.

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

//

CAknButtonExtension::CAknButtonExtension( CAknButton& aButton )

    : iButton( aButton ),

      iTooltipPosition( CAknButton::EPositionTop ),

      iLongPressTimer( NULL ),

      iLongPressInterval( KLongPressInterval ),

      iUnderlineStyle( EUnderlineOff ),

      iFrameAndCenterIds( 2 ),

      iVerticalIconAlignment( CAknButton::ECenter ),

      iHorizontalIconAlignment( CAknButton::ECenter ),

      iTextAndIconAlignment( CAknButton::EIconBeforeText ),

      iResourceProvider( 0 ),

      iFeedbackEnabled( ETrue )

    {

    // default margins, these are applied to both text and icon

    iMargins.SetAllValuesTo( 

        AknLayoutScalable_Avkon::aid_value_unit2().LayoutLine().iW / 10 );

    // default icon size

    TRect rect( TSize( 100, 100 ) );

    TAknLayoutRect layoutRect;

    layoutRect.LayoutRect( rect, 

        AknLayoutScalable_Avkon::toolbar_button_pane_g10().LayoutLine() );

    iIconSize = layoutRect.Rect().Size();

    iFlags.Set( EUseDefaultIconSize );

    iFlags.Set( EUseDefaultMargins );

    }

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

// CAknButtonExtension::~CAknButtonExtension

// Destructor.

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

//

CAknButtonExtension::~CAknButtonExtension()

    {

    delete iLongPressTimer;

    iPictographInterface = NULL; // not owned

    iFrameAndCenterIds.Close();

    DeletePressedBmps();

    delete iHighlightContext; 

    }

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

// CAknButtonExtension::NewL

// Symbian two-phased constructor.

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

//

CAknButtonExtension* CAknButtonExtension::NewL( CAknButton& aButton )

    {

    CAknButtonExtension* ext = new ( ELeave ) CAknButtonExtension( aButton );

    CleanupStack::PushL( ext );

    ext->ConstructL();

    CleanupStack::Pop( ext );

    return ext;

    }

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

// CAknButtonExtension::ConstructL

// Symbian 2nd stage constructor.

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

//

void CAknButtonExtension::ConstructL()

    {

    // Normal frame and center

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonNormal );

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonCenterNormal );

    // Latched frame and center

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonPressed );

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonCenterPressed );

    // Dimmed frame and center

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonInactive );

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonCenterInactive );

    // Pressed frame and center

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonPressed );

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonCenterPressed );

    // Latched dimmed frame and center

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonInactive );

    iFrameAndCenterIds.AppendL( KAknsIIDQsnFrButtonCenterInactive );

    if ( !iHighlightContext )

        {

        iHighlightContext = CAknsFrameBackgroundControlContext::NewL(

            KAknsIIDNone, TRect(), TRect(), EFalse );

        iHighlightContext->SetFrame( KAknsIIDQsnFrButtonHighlight ); 

        iHighlightContext->SetCenter( KAknsIIDQsnFrButtonHighlightCenter ); 

        }

    }

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

// CAknButtonExtension::StartLongPressTimerL

// Starts the long press timer. The timer is constructed when used for the

// first time.

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

//

void CAknButtonExtension::StartLongPressTimerL()

    {

    if ( !iLongPressTimer )

        {

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

        }

    else if ( iLongPressTimer->IsActive() )

        {

        iLongPressTimer->Cancel();

        }

    if ( iLongPressInterval > 0 )

        {

        iLongPressTimer->Start( iLongPressInterval, iLongPressInterval,

            TCallBack( ReportLongPressL, this ) );

        }

    }

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

// CAknButtonExtension::ReportLongPressL

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

//

TInt CAknButtonExtension::ReportLongPressL( TAny* aThis )

    {

    static_cast<CAknButtonExtension*>( aThis )->DoReportLongPressL();

    return 0;

    }

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

// CAknButtonExtension::DoReportLongPressL

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

//

void CAknButtonExtension::DoReportLongPressL()

    {

    if ( iLongPressTimer && iLongPressTimer->IsActive() )

        {

        iLongPressTimer->Cancel();

        }

    if ( iButton.Observer() )

        {

        iButton.Observer()->HandleControlEventL( &iButton,

            static_cast<MCoeControlObserver::TCoeEvent>(

                 CAknButton::ELongPressEvent ) );

        iFlags.Set( ELongPressReported );

        }

    }

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

// CAknButtonExtension::DeletePressedBmps

// Deletes pressed down bitmaps

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

//

void CAknButtonExtension::DeletePressedBmps()

    {

    delete iPressedDownBmp;

    delete iPressedDownBmpMask;

    iPressedDownBmp = 0;

    iPressedDownBmpMask = 0;

    }

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

// CAknButtonExtension::FetchProviderPressedBmpsL

// Fetches bitmaps from provider (if one exists). Returns ETrue if bitmaps were

// found.

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

//

TBool CAknButtonExtension::FetchProviderPressedBmpsL()

    {

    TBool bmpsFetched = EFalse;

    if ( iResourceProvider )

        {

        MAknResourceItem* resourceItem = 0;

        // Check if resource provider has item for KPressedFrameId

        if ( iResourceProvider->GetResourceL( 

                KPressedFrameId, resourceItem ) != KErrNotFound 

            && resourceItem )

            {

            DeletePressedBmps();

            static_cast<CAknBitmapResourceItem*>( resourceItem )->GetBitmaps( 

                iPressedDownBmp, iPressedDownBmpMask );

            delete resourceItem;

            // Check if found bitmap size matches with button size

            if ( iPressedDownBmp 

                && iPressedDownBmpMask

                && iPressedDownBmp->SizeInPixels() == iButton.Size() )

                {

                bmpsFetched = ETrue;

                }

            // If not, delete the fetched bitmaps

            else

                {

                DeletePressedBmps();

                }

            }

        }

    return bmpsFetched;

    }

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

// CAknButtonExtension::SetProviderPressedBmpsL

// Sets bitmaps to provider (if one exists).

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

//

void CAknButtonExtension::SetProviderPressedBmpsL()

    {

    if ( iResourceProvider )

        {

        CAknBitmapResourceItem* resourceItem = 

            CAknBitmapResourceItem::NewL( KPressedFrameId );

        resourceItem->SetBitmapsL( iPressedDownBmp, iPressedDownBmpMask );

        iResourceProvider->SetResourceL( 

            KPressedFrameId, 

            static_cast<MAknResourceItem*>( resourceItem ) );

        }

    }

//

TBool CAknButtonExtension::HitRegionContains( const TPoint &aPoint, 

    const CCoeControl& /*aControl*/ ) const

    {

    TBool retval = EFalse;