/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <gulicon.h>

#include <AknsUtils.h>

#include <aknconsts.h>

#include <avkon.mbg>

#include <swtlaffacade.h>

#include "swtcontrolhelper.h"

#include "eswtmobileextensions.h"

#include "swtbutton.h"

#include "swtbuttonproxy.h"

#include "swtfont.h"

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

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

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

// CSwtButton::NewL

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

//

CSwtButton* CSwtButton::NewL(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

{

    CSwtButton* self = new(ELeave) CSwtButton(

        aDisplay,

        aPeer,

        aParent,

        aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtButton::CSwtButton

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

//

CSwtButton::CSwtButton(

    MSwtDisplay& aDisplay,

    TSwtPeer aPeer,

    MSwtComposite& aParent,

    TInt aStyle)

        : ASwtControlBase(aDisplay, aPeer, &aParent, aStyle)

{

}

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

// CSwtButton::~CSwtButton

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

//

CSwtButton::~CSwtButton()

{

    delete iButton;

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

    }

    if (iImage != NULL)

    {

        iImage->RemoveRef();

    }

    if (iDupFont)

    {

        iDupFont->RemoveRef();

    }

#ifdef _lint

    iDefaultFont = NULL;

    iImage = NULL;

    iCustomIcon = NULL;

    iDupFont = NULL;

#endif

}

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

// CSwtButton::ConstructL

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

//

void CSwtButton::ConstructL()

{

    CCoeControl& coeParent = iParent->Control()->CoeControl();

    SetContainerWindowL(coeParent);

    CreateButtonL(KNullDesC);

    RetrieveDefaultFontL();

    CCoeControl::MakeVisible(coeParent.IsVisible());

    CCoeControl::SetDimmed(coeParent.IsDimmed());

    SetAlignment(iStyle & KSwtAlignmentMask);

    SetComponentsToInheritVisibility(ETrue);

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

    // Disabling feedback for CSwtButton.

    // When enabled - first tap on combo creates extra feedback,

    // that is not needed.

    if (iFeedback)

    {

        iFeedback->EnableFeedbackForControl(this, EFalse);

    }

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    ActivateL();

}

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

// CSwtButton::RetrieveDefaultFontL

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

//

void CSwtButton::RetrieveDefaultFontL()

{

    if (iDefaultFont)

    {

        iDefaultFont->RemoveRef();

        iDefaultFont = NULL;

    }

    // Same as Label's

    iDefaultFont = CSwtFont::NewL(iDisplay.Device(), iDisplay.Device().GetSystemFont()->Font());

    if (!iFont)

    {

        ProcessFontUpdate();

    }

}

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

// CSwtButton::ProcessFontUpdate

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

//

void CSwtButton::ProcessFontUpdate()

{

    const MSwtFont* swtFont=GetFont();

    ASSERT(swtFont);

    const CFont* font = &(swtFont->Font());

    // Workaround for that the custom font on window server side is changed unexpectedly

    if (iFont)

    {

        if (!iDupFont)

        {

            // duplicate

            TRAP_IGNORE(iDupFont = CSwtFont::NewL(iDisplay.Device(), swtFont->Font()));

        }

        if (iDupFont)

        {

            // duplicated font will pass to the button to avoid custom font being changed

            font = &(iDupFont->Font());

        }

    }

    iButton->SetTextFont(font);

}

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

// CSwtButton::CreateButtonL

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

//

void CSwtButton::CreateButtonL(const TDesC& aText)

{

    ASSERT(iButton == NULL);

    if (iStyle & (KSwtStyleCheck | KSwtStyleRadio))

    {

        CGulIcon* icon = CreateCheckOrRadioIconL(iSelected, iStyle);

        CleanupStack::PushL(icon);

        iButton = CSwtButtonProxy::NewL(this, icon, aText,

                                        KAknButtonSizeFitText | KAknButtonNoFrame | KAknButtonPressedDownFrame);

        CleanupStack::Pop(icon);

        iCustomIcon = icon;

        TSize iconSize(TSize::EUninitialized);

        GetSizeOfCheckOrRadioIcon(iconSize);

        SetIconSize(iCustomIcon, iconSize);

        iButton->SetIconSize(iconSize);

    }

    else // KSwtStyleToggle, KSwtStylePush, KSwtStyleFlat

    {

        // Do not use KAknButtonTextInsideFrame. It clips the icons when text is present.

        iButton = CSwtButtonProxy::NewL(this, NULL, aText, KAknButtonSizeFitText);

    }

    iButton->SetObserver(this);

    iButton->MakeVisible(ETrue);

    iButton->SetFocusing(ETrue);

    iButton->SetIconScaleMode(EAspectRatioPreserved);

    iButton->SetBackground(this);   // Back will be drawn by ASwtControlBase::Draw

    // Set default color

    TRgb color;

    AknsUtils::GetCachedColor(AknsUtils::SkinInstance(),

                              color,

                              KAknsIIDQsnTextColors,

                              EAknsCIQsnTextColorsCG63); // Messaging touch buttons

    iButton->OverrideColorL(EColorButtonText, color);

}

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

// CSwtButton::ChangeStateL

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

//

void CSwtButton::ChangeStateL(TBool aState)

{

    ASSERT(iButton);

    if (iStyle & KSwtStyleToggle)

    {

        if (aState)

        {

            iButton->SetFlags(iButton->Flags() | KAknButtonStateHasLatchedFrame);

        }

        else

        {

            iButton->SetFlags(iButton->Flags() & ~KAknButtonStateHasLatchedFrame);

        }

    }

    else if (iStyle & (KSwtStyleCheck | KSwtStyleRadio))

    {

        ChangeCheckOrRadioIconL(aState);

    }

}

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

// CSwtButton::CreateCheckOrRadioIconL

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

//

CGulIcon* CSwtButton::CreateCheckOrRadioIconL(

    TBool aState, TInt aStyle) const

{

    ASSERT(aStyle & (KSwtStyleCheck | KSwtStyleRadio));

    TInt bmpId(0);

    TInt maskId(0);

    TAknsItemID skinItemId;

    if (aStyle & KSwtStyleCheck)

    {

        if (aState)

        {

            skinItemId.Set(KAknsIIDQgnPropCheckboxOn);

            bmpId = EMbmAvkonQgn_prop_checkbox_on;

            maskId = EMbmAvkonQgn_prop_checkbox_on_mask;

        }

        else

        {

            skinItemId.Set(KAknsIIDQgnPropCheckboxOff);

            bmpId = EMbmAvkonQgn_prop_checkbox_off;

            maskId = EMbmAvkonQgn_prop_checkbox_off_mask;

        }

    }

    else // KSwtStyleRadio

    {

        if (aState)

        {

            skinItemId.Set(KAknsIIDQgnPropRadiobuttOn);

            bmpId = EMbmAvkonQgn_prop_radiobutt_on;

            maskId = EMbmAvkonQgn_prop_radiobutt_on_mask;

        }

        else

        {

            skinItemId.Set(KAknsIIDQgnPropRadiobuttOff);

            bmpId = EMbmAvkonQgn_prop_radiobutt_off;

            maskId = EMbmAvkonQgn_prop_radiobutt_off_mask;

        }

    }

    return AknsUtils::CreateGulIconL(

               AknsUtils::SkinInstance(),

               skinItemId,

               AknIconUtils::AvkonIconFileName(),

               bmpId,

               maskId);

}

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

// CSwtButton::ChangeCheckOrRadioIconL

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

//

void CSwtButton::ChangeCheckOrRadioIconL(TBool aState)

{

    ASSERT(iStyle & (KSwtStyleCheck | KSwtStyleRadio));

    CGulIcon* icon = CreateCheckOrRadioIconL(aState, iStyle);

    if (iButton)

    {

        iButton->SetIcon(icon);

    }

    iCustomIcon = icon;

    TSize iconSize(TSize::EUninitialized);

    GetSizeOfCheckOrRadioIcon(iconSize);

    SetIconSize(iCustomIcon, iconSize);

    iButton->SetIconSize(iconSize);

}

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

// CSwtButton::SetIconSize

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

//

void CSwtButton::SetIconSize(const CGulIcon* aIcon, const TSize& aSize,

                             TScaleMode aScaleMode) const

{

    if (aIcon)

    {

        if (aIcon->Bitmap())

        {

            AknIconUtils::SetSize(aIcon->Bitmap(), aSize, aScaleMode);

        }

        if (aIcon->Mask())

        {

            AknIconUtils::SetSize(aIcon->Mask(), aSize, aScaleMode);

        }

    }

}

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

// CSwtButton::GetSizeOfCheckOrRadioIcon

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

//

void CSwtButton::GetSizeOfCheckOrRadioIcon(TSize& aSize) const

{

    aSize = TSize(0, 0);

    if (iStyle & (KSwtStyleCheck | KSwtStyleRadio))

    {

        TInt variety((iStyle & KSwtStyleRadio) ? 1 : 0);

        aSize = CSwtLafFacade::GetLayoutRect(

                    CSwtLafFacade::EControlButtonPaneG2, TRect(), variety).Rect().Size();

    }

}

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

// CSwtButton::UpdateControlSize

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

//

void CSwtButton::UpdateControlSize()

{

    if (iButton)

    {

        iButton->SetSize(iSize);

    }

    if (iStyle & (KSwtStyleCheck | KSwtStyleRadio))

    {

        // Update check/radio icon to match the new size of the control

        TRAP_IGNORE(ChangeCheckOrRadioIconL(iSelected));

    }

    if (iButton)

    {

        iButton->SetHighlightRect(Rect());

    }

}

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

// CSwtButton::SwtHandleResourceChangeL

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

//

void CSwtButton::SwtHandleResourceChangeL(TInt aType)

{

    CCoeControl::HandleResourceChange(aType);

    if (aType == KAknsMessageSkinChange || aType == KEikDynamicLayoutVariantSwitch)

    {

        if (!iFont)

        {

            RetrieveDefaultFontL();

        }

        else

        {

            // Workaround: the custom font (iDupFont) that was passed to button

            // can be changed by switching resolutions. Here, delete the duplicated

            // font and a new will be created in ProcessFontUpdate

            if (iDupFont)

            {

                // delete duplicated font (by removing reference to it)

                iDupFont->RemoveRef();

                iDupFont = NULL;

            }

            ProcessFontUpdate();

        }

        if (aType == KAknsMessageSkinChange)

        {

            // Refresh radio or check image

            if (iStyle & (KSwtStyleCheck | KSwtStyleRadio))

            {

                ChangeCheckOrRadioIconL(iSelected);

            }

        }

    }

}

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

// CSwtButton::IsFeedbackOnTouchDown

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

//

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

TBool CSwtButton::IsFeedbackOnTouchDownNeeded(const TPointerEvent& aPointerEvent) const

{

    if (aPointerEvent.iType != TPointerEvent::EButton1Down)

    {

        return EFalse;

    }

    return ETrue;

}

#endif

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

// CSwtButton::IsFeedbackOnTouchRelease

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

//

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

TBool CSwtButton::IsFeedbackOnTouchReleaseNeeded(const TPointerEvent& aPointerEvent) const

{

    if (aPointerEvent.iType != TPointerEvent::EButton1Up)

    {

        return EFalse;

    }

    // When pointer was dragged out of the visible area of the control,

    // ther should be no feedback.

    return VisibleRect(ETrue).Contains(aPointerEvent.iPosition);

}

#endif

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

// CSwtButton::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtButton::ComponentControl(TInt /*aIndex*/) const

{

    return iButton;

}

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

// CSwtButton::CountComponentControls

// From CCoeControl

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

//

TInt CSwtButton::CountComponentControls() const

{

    return (iButton) ? 1 : 0;

}

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

// CSwtButton::MakeVisible

// From CCoeControl

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

//

void CSwtButton::MakeVisible(TBool aVisible)

{

    CCoeControl::MakeVisible(aVisible);

    FocusabilityChanged();

}

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

// CSwtButton::SetDimmed

// From CCoeControl

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

//

void CSwtButton::SetDimmed(TBool aDimmed)

{

    ASSERT(iButton);

    CCoeControl::SetDimmed(aDimmed);

    if (iButton)

    {

        iButton->SetDimmed(aDimmed);

    }

    FocusabilityChanged();

}

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

// CSwtButton::OfferKeyEventL

// From CCoeControl

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

//

TKeyResponse CSwtButton::OfferKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    TBool traversalDoIt = ETrue;

    // Enter key is used to traverse_return the Shell, which means a default

    // button can get selected. Only the Selection key is a sure thing.

    if (aKeyEvent.iCode == EKeyOK)

    {

        traversalDoIt = EFalse;

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// CSwtButton::HandleResourceChange

// From CCoeControl

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

//

void CSwtButton::HandleResourceChange(TInt aType)

{