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

 * 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 <AknsDrawUtils.h>

#include <AknUtils.h>

#include <swtlaffacade.h>

#include <avkon.mbg>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include "swtrotateimage.h"

#include "swtslider.h"

const TInt KSwtSliderDefaultThumb(1);

#ifdef RD_TACTILE_FEEDBACK

// Id for the only feedback area

const TInt KTouchFeedbackRectId1(0);

#endif // RD_TACTILE_FEEDBACK

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

/**

 * 1st & 2nd phase constructors wrapper

 */

CSwtSlider* CSwtSlider::NewL(MSwtDisplay& aDisplay,

                             TSwtPeer aPeer,

                             MSwtComposite& aParent,

                             TInt aStyle)

{

    CSwtSlider* self = new(ELeave) CSwtSlider(aDisplay, aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

CSwtSlider::CSwtSlider(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                       MSwtComposite& aParent, TInt aStyle)

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

        , iMaximum(10)

        , iIncrement(1)

        , iPageIncrement(5)

{

    SetComponentsToInheritVisibility(ETrue);

}

CSwtSlider::~CSwtSlider()

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif // RD_TACTILE_FEEDBACK

    delete iImagesRotator;

    delete iSliderImageMask;

    delete iSliderImage;

}

/**

 * 2nd phase constructor

 */

void CSwtSlider::ConstructL()

{

    // Get parent

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

    SetContainerWindowL(coeParent);

    if (iStyle & KSwtStyleVertical)

    {

        iImagesRotator = CAORotateImage::NewL();

        iIncreaseKey = EKeyUpArrow;

        iDecreaseKey = EKeyDownArrow;

    }

    else if (iStyle & KSwtStyleHorizontal)

    {

        if (AknLayoutUtils::LayoutMirrored())

        {

            iIncreaseKey = EKeyLeftArrow;

            iDecreaseKey = EKeyRightArrow;

        }

        else

        {

            iIncreaseKey = EKeyRightArrow;

            iDecreaseKey = EKeyLeftArrow;

        }

    }

    SetPosition(TPoint(0, 0));

    SetSize(TSize(0, 0));

    // Synchronize with parent's state

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

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

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

    // Ready to be drawn

    ActivateL();

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    // Disabling feedback for CSwtSlider.

    // When enabled - first tap on any slider position creates extra

    // feedback, that is not needed.

    {

        iFeedback->EnableFeedbackForControl(this, EFalse);

    }

#endif // RD_JAVA_ADVANCED_TACTILE_FEEDBACK

#endif // RD_TACTILE_FEEDBACK

}

/**

 * Slider image is composed manually here because we want to be able to

 * scale it to fit the control's size.

 */

CGulIcon* CSwtSlider::CreateSliderIconL(TInt aValue, TInt aMinValue, TInt aMaxValue)

{

    CGulIcon* icon = CGulIcon::NewLC();

    // The function used to get the layout data

    TAknLayoutRect(&Laf)(CSwtLafFacade::TSwtLafFacadeRectId,

                         const TRect&,

                         TInt,

                         TInt,

                         TInt) = CSwtLafFacade::GetLayoutRect;

    // Get slider pane layout

    TRect dummyParentRect(TPoint(0, 0), GetPreferredSliderSize());

    // Scale the layout to the size of the control.

    // We refuse to make it smaller than the Min( layoutwidth, layoutheight ).

    TRect clientRect(ClientRect());

    if (iStyle & KSwtStyleVertical)

    {

        // We always build horizontal image, it will be rotated later.

        dummyParentRect.SetWidth(Max(clientRect.Height(), dummyParentRect.Height()));

    }

    else

    {

        dummyParentRect.SetWidth(Max(clientRect.Width(), dummyParentRect.Height()));

    }

    TRect sliderPane(Laf(CSwtLafFacade::ESliderSetPaneCP3, dummyParentRect, 0, 0, 0).Rect());

    // Get background graphic layout

    TRect topLeftRect(Laf(CSwtLafFacade::EBgSetOptPaneG2, sliderPane, 0, 0, 0).Rect());

    TRect bottomRightRect(Laf(CSwtLafFacade::EBgSetOptPaneG5, sliderPane, 0, 0, 0).Rect());

    TRect outerRect(dummyParentRect);

    TRect innerRect(topLeftRect.Width(),

                    topLeftRect.Height(),

                    outerRect.Width() - bottomRightRect.Width(),

                    outerRect.Height() - bottomRightRect.Height());

    // Get line graphic layout

    TRect lineRect(Laf(CSwtLafFacade::ESliderSetPaneG1, sliderPane, 0, 0, 0).Rect());

    // Get marker graphic layout (size only actually)

    TRect markerRect(Laf(CSwtLafFacade::ESliderSetPaneG2, sliderPane, 0, 0, 0).Rect());

    // Get marker graphic

    CFbsBitmap* marker = NULL;

    CFbsBitmap* markerMask = NULL;

    AknsUtils::CreateIconLC(AknsUtils::SkinInstance(),

                            KAknsIIDQgnIndiSliderSet,

                            marker, markerMask,

                            AknIconUtils::AvkonIconFileName(),

                            EMbmAvkonQgn_indi_slider_edit,

                            EMbmAvkonQgn_indi_slider_edit_mask);

    AknIconUtils::SetSize(marker, markerRect.Size());

    // Get line graphic

    CFbsBitmap* line = NULL;

    CFbsBitmap* lineMask = NULL;

    AknsUtils::CreateIconLC(AknsUtils::SkinInstance(),

                            KAknsIIDQgnGrafLinePrimaryHorizontal,

                            line, lineMask,

                            AknIconUtils::AvkonIconFileName(),

                            EMbmAvkonQgn_graf_line_primary_horizontal,

                            EMbmAvkonQgn_graf_line_primary_horizontal_mask);

    AknIconUtils::SetSize(line,

                          lineRect.Size(),

                          EAspectRatioNotPreserved);

    // Create a bitmap to draw the slider components on to

    CFbsBitmap* bitmap = new(ELeave) CFbsBitmap;

    CleanupStack::PushL(bitmap);

    User::LeaveIfError(bitmap->Create(

                           dummyParentRect.Size(), iDisplay.CoeEnv()->ScreenDevice()->DisplayMode()));

    // Create a gc for drawing to the bitmap

    CFbsBitGc* fbsBitGc = CFbsBitGc::NewL();

    CleanupStack::PushL(fbsBitGc);

    CFbsBitmapDevice* bmpDevice = CFbsBitmapDevice::NewL(bitmap);

    CleanupStack::PushL(bmpDevice);

    fbsBitGc->Activate(bmpDevice);

    // The actual drawing:

    // Draw the background graphic

    const TAknsItemID *frameId = &KAknsIIDQsnFrSetOptFoc;

    CAknsFrameBackgroundControlContext* cc =

        CAknsFrameBackgroundControlContext::NewL(*frameId, outerRect, innerRect, EFalse);

    AknsDrawUtils::DrawBackground(AknsUtils::SkinInstance(), cc, NULL, *fbsBitGc,

                                  outerRect.iTl, outerRect, KAknsDrawParamDefault);

    delete cc;

    // Draw the line graphic

    fbsBitGc->BitBltMasked(lineRect.iTl,

                           line,

                           lineRect.Size(),

                           lineMask,

                           EFalse);

    // Draw the marker graphic

    TInt bitmapRun = lineRect.Width() - marker->SizeInPixels().iWidth;

    TInt range = aMaxValue - aMinValue;

    TInt pos = ((bitmapRun * (aValue - aMinValue)) / range);

    TPoint markerPos = TPoint(pos + markerRect.iTl.iX, markerRect.iTl.iY);

    TRect srcRect(0, 0, markerRect.Width(), markerRect.Height());

    fbsBitGc->BitBltMasked(markerPos, marker, srcRect,

                           markerMask, EFalse);

    CleanupStack::PopAndDestroy(bmpDevice);

    CleanupStack::PopAndDestroy(fbsBitGc);

    icon->SetBitmap(bitmap);

    // Then create the mask

    CFbsBitmap* mask = new(ELeave) CFbsBitmap;

    CleanupStack::PushL(mask);

    TDisplayMode mode = lineMask->DisplayMode();

    if (mode == ENone)

    {

        mode = EGray256;

    }

    User::LeaveIfError(mask->Create(bitmap->SizeInPixels(), mode));

    // A gc for drawing the mask

    fbsBitGc = CFbsBitGc::NewL();

    CleanupStack::PushL(fbsBitGc);

    bmpDevice = CFbsBitmapDevice::NewL(mask);

    fbsBitGc->Activate(bmpDevice);

    // Write mask data

    fbsBitGc->SetPenStyle(CGraphicsContext::ENullPen);

    fbsBitGc->SetBrushStyle(CGraphicsContext::ESolidBrush);

    fbsBitGc->SetBrushColor(KRgbWhite);

    fbsBitGc->DrawRect(TRect(mask->SizeInPixels()));

    AknsDrawUtils::DrawFrame(AknsUtils::SkinInstance(), *fbsBitGc,

                             outerRect, innerRect,

                             KAknsIIDQsnFrSetOptFoc,

                             KAknsIIDQsnFrSetOptFocCenter,

                             KAknsSDMAlphaOnly);

    delete bmpDevice;

    CleanupStack::PopAndDestroy(fbsBitGc);

    icon->SetMask(mask);

    CleanupStack::Pop(mask);

    CleanupStack::Pop(bitmap);

    CleanupStack::PopAndDestroy(4);   // line, lineMask, marker, markerMask

    CleanupStack::Pop(icon);

    return icon;

}

TSize CSwtSlider::GetPreferredSliderSize() const

{

    TRect rect;

    AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);

    rect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::EListScrollGenPane, rect, 0).Rect();

    rect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::EListGenPane, rect, 0).Rect();

    rect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::EListSettingNumberPane, rect, 0).Rect();

    rect = CSwtLafFacade::GetLayoutRect(CSwtLafFacade::ESetValuePane, rect, 0).Rect();

    return rect.Size();

}

void CSwtSlider::UpdateTouchFeedbackRect() const

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->SetFeedbackArea(this, KTouchFeedbackRectId1, Rect(),

                                   ETouchFeedbackBasic, ETouchEventStylusDown);

    }

#endif //RD_TACTILE_FEEDBACK

}

void CSwtSlider::UpdateSliderImageL()

{

    if (iStyle & KSwtStyleVertical)

    {

        iImagesRotator->RemoveAllImages();

    }

    if (iSliderImage)

    {

        delete iSliderImage;

    }

    if (iSliderImageMask)

    {

        delete iSliderImageMask;

    }

    TInt nativeSliderMax = iMaximum - KSwtSliderDefaultThumb;

    // If native slider maximum value is the same as minimum value, increment the

    // value by one to prevent icon creation from failing.

    if (iMinimum == nativeSliderMax)

    {

        nativeSliderMax++;

    }

    CGulIcon* icon = CreateSliderIconL(iSelection, iMinimum, nativeSliderMax);

    CleanupStack::PushL(icon);

    icon->SetBitmapsOwnedExternally(ETrue);

    iSliderImage = icon->Bitmap();

    iSliderImageMask = icon->Mask();

    CleanupStack::PopAndDestroy(); // icon

    iImageSize = iSliderImage->SizeInPixels();

    if (iStyle & KSwtStyleVertical)

    {

        // Update the image size before the rotation of the image.

        iImageSize.SetSize(iImageSize.iHeight, iImageSize.iWidth);

        iImagesRotator->Start(this);

    }

    else

    {

        if (!(iCtrlFlags  & MSwtControl::EFlagDoNotDraw))

        {

            if (IsPaintingUrgently())

            {

                PaintUrgently(Rect()) ;

            }

            else

            {

                RWindow* window = static_cast<RWindow*>(DrawableWindow());

                TRect dirtyRect(Rect());

                dirtyRect.Move(window->Position());

                Paint(dirtyRect);

            }

        }

    }

}

void CSwtSlider::AdjustSelectionValue()

{

    TInt value = iSelection;

    if (value > (iMaximum-KSwtSliderDefaultThumb))

    {

        value = iMaximum - KSwtSliderDefaultThumb;

    }

    else if (value < iMinimum)

    {

        value = iMinimum;

    }

    iSelection = value;

}

void CSwtSlider::ClipAndDrawImage(CWindowGc& aGC, const TRect& /*aRect*/) const

{

    aGC.SetOpaque(EFalse);

    TRect clientRect(ClientRect());

    TPoint imagePosition(clientRect.iTl);

    TRect rectImageSrc(0, 0, iImageSize.iWidth, iImageSize.iHeight);

    if (clientRect.Width() >= iImageSize.iWidth)

    {

        imagePosition.iX += (clientRect.Width() - iImageSize.iWidth) / 2;

    }

    else

    {

        rectImageSrc.iTl.iX = iImageSize.iWidth / 2 - clientRect.Width() / 2;

        rectImageSrc.SetWidth(clientRect.Width());

    }

    if (clientRect.Height() >= iImageSize.iHeight)

    {

        imagePosition.iY += (clientRect.Height() - iImageSize.iHeight) / 2;

    }

    else

    {

        rectImageSrc.iTl.iY = iImageSize.iHeight / 2 - clientRect.Height() / 2;

        rectImageSrc.SetHeight(clientRect.Height());

    }

    aGC.BitBltMasked(imagePosition, iSliderImage, rectImageSrc, iSliderImageMask, EFalse);

}

//

// Virtual methods from CCoeControl

//

TSize CSwtSlider::MinimumSize()

{

    return BorderOuterRect(iImageSize).Size();

}

void CSwtSlider::MakeVisible(TBool aVisible)

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->EnableFeedbackForControl(this, aVisible);

    }

#endif // RD_TACTILE_FEEDBACK

    CAknControl::MakeVisible(aVisible);

    FocusabilityChanged();

}

void CSwtSlider::SetDimmed(TBool aDimmed)

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->EnableFeedbackForControl(this, !aDimmed);

    }

#endif // RD_TACTILE_FEEDBACK

    CAknControl::SetDimmed(aDimmed);

    FocusabilityChanged();

}

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

{

    TKeyResponse keyReponse = EKeyWasNotConsumed;

    if (aType == EEventKey)

    {

        if ((aKeyEvent.iCode == iIncreaseKey) || (aKeyEvent.iCode == iDecreaseKey))

            keyReponse = EKeyWasConsumed;

    }

    if (keyReponse == EKeyWasNotConsumed)

        return HandleKeyL(aKeyEvent, aType, ETrue);

    else

        return HandleKeyL(aKeyEvent, aType, EFalse);

}

void CSwtSlider::HandleResourceChange(TInt aType)

{

    TRAP_IGNORE(SwtHandleResourceChangeL(aType));

}

void CSwtSlider::SwtHandleResourceChangeL(TInt aType)

{

    CAknControl::HandleResourceChange(aType);

    // Check all type which can modify the Slider

    //

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

    {

        UpdateSliderImageL();

    }

}

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

{

    if (iStyle & KSwtStyleVertical)

    {

        if (!iImagesRotator->IsFinish())

        {

            iImagesRotator->SetRedrawAfterRotation(ETrue);

            return;

        }

    }

    ClipAndDrawImage(SystemGc(), aRect);

}

void CSwtSlider::FocusChanged(TDrawNow aDrawNow)

{

    CAknControl::FocusChanged(ENoDrawNow);

    // Spread focus information

    HandleFocusChanged(aDrawNow);

}

void CSwtSlider::SizeChanged()

{

    CAknControl::SizeChanged();

    UpdateTouchFeedbackRect();

    TRAP_IGNORE(UpdateSliderImageL());

    HandleSizeChanged();

}

void CSwtSlider::PositionChanged()

{

    UpdateTouchFeedbackRect();

    HandlePositionChanged();

}

TTypeUid::Ptr CSwtSlider::MopSupplyObject(TTypeUid aId)

{

    TTypeUid::Ptr id = ASwtControlBase::SwtMopSupplyObject(aId);

    if (id.Pointer() == NULL)