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

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

#include <AknsDrawUtils.h>

#include <AknLayoutFont.h>

#ifdef RD_TACTILE_FEEDBACK

#include <touchfeedback.h>

#endif // RD_TACTILE_FEEDBACK

#include <swtlaffacade.h>

#include <swtcomboproxy.h>

#include "swtcombo.h"

// NOTE: Due to several issues in operating a CAknChoiceList while open,

// workarounds have been put in place troughout this implementation,

// which consist of closing the combo, before operating on it.

const TInt KMaxVisibleItemCount(6);

_LIT(KTxtSpace, " ");

#ifdef RD_TACTILE_FEEDBACK

const TInt KTouchFeedbackRectId1(0);

#endif // RD_TACTILE_FEEDBACK

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

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

// CSwtCombo::NewL

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

//

CSwtCombo* CSwtCombo::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                           MSwtComposite& aParent, TInt aStyle)

{

    CSwtCombo* self = new(ELeave) CSwtCombo(aDisplay, aPeer,

                                            aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

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

// CSwtCombo::CSwtCombo

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

//

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

                     MSwtComposite& aParent, TInt aStyle)

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

{

}

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

// CSwtCombo::~CSwtCombo

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

//

CSwtCombo::~CSwtCombo()

{

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->RemoveFeedbackForControl(this);

    }

#endif // RD_TACTILE_FEEDBACK

    // Choice list, own.

    delete iCombo;

    iCombo = NULL;

    // String item array, not own

    iItems = NULL;

}

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

// CSwtCombo::ConstructL

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

//

void CSwtCombo::ConstructL()

{

    // Handle parent

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

    SetContainerWindowL(coeParent);

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

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

    // Create Avkon choice list and its item array.

    iItems = new(ELeave) CDesCArrayFlat(1);

    iCombo = CSwtComboProxy::NewL(this, iItems);

    // Construct choice list.

    iCombo->SetContainerWindowL(*this);

    iCombo->SetObserver(this);

    iCombo->SetFlags(iCombo->Flags() | CSwtComboProxy::EComboPositionBottom);

    iCombo->SetSelectedIndex(-1);

    iPrevSelIdx = -1;

#ifdef RD_TACTILE_FEEDBACK

    iFeedback = MTouchFeedback::Instance();

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    // Disabling feedback for CSwtCombo.

    // 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

#endif // RD_TACTILE_FEEDBACK

    // Ready to draw

    SetComponentsToInheritVisibility(ETrue);

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

    ActivateL();

}

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

// CSwtCombo::CountComponentControls

// From CCoeControl

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

//

TInt CSwtCombo::CountComponentControls() const

{

    return 1;

}

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

// CSwtCombo::ComponentControl

// From CCoeControl

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

//

CCoeControl* CSwtCombo::ComponentControl(TInt /*aIdx*/) const

{

    return iCombo;

}

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

// CSwtCombo::PositionChanged

// From CCoeControl

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

//

void CSwtCombo::PositionChanged()

{

    CenterContainedCombo();

    UpdateTouchFeedbackRect();

    HandlePositionChanged();

}

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

// CSwtCombo::SizeChanged

// From CCoeControl

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

//

void CSwtCombo::SizeChanged()

{

    TRect rect(BorderInnerRect());

    iCombo->SetSize(TSize(rect.Size().iWidth, iCombo->MinimumSize().iHeight));

    CenterContainedCombo();

    UpdateTouchFeedbackRect();

    HandleSizeChanged();

}

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

// CSwtCombo::FocusChanged

// From CCoeControl

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

//

void CSwtCombo::FocusChanged(TDrawNow aDrawNow)

{

    // The Combo looses focus to the open popup list due to stack change.

    if (iOpening)

    {

        if (!IsFocused())

        {

            SetFocus(ETrue);

        }

        return;

    }

    TBool isFocused = IsFocusControl();

    iCombo->SetFocus(isFocused, aDrawNow);

    HandleFocusChanged(aDrawNow);

}

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

// CSwtCombo::MakeVisible

// From CCoeControl

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

//

void CSwtCombo::MakeVisible(TBool aVisible)

{

    DoClose();

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->EnableFeedbackForControl(this, aVisible);

    }

#endif // RD_TACTILE_FEEDBACK

    CAknControl::MakeVisible(aVisible);

    FocusabilityChanged();

}

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

// CSwtCombo::SetDimmed

// From CCoeControl

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

//

void CSwtCombo::SetDimmed(TBool aDimmed)

{

    DoClose();

#ifdef RD_TACTILE_FEEDBACK

    if (iFeedback)

    {

        iFeedback->EnableFeedbackForControl(this, !aDimmed);

    }

#endif // RD_TACTILE_FEEDBACK

    CAknControl::SetDimmed(aDimmed);

    iCombo->SetDimmed(aDimmed);

    FocusabilityChanged();

}

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

// CSwtCombo::OfferKeyEventL

// From CCoeControl

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

//

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

{

    if (iOpen)

    {

        // The popup list already handled the key event at this point.

        // Without this return, the popup list would open again.

        // Therefore, while open, the Combo does not generate key events.

        return EKeyWasConsumed;

    }

    TBool traversalDoIt = ETrue;

    if (aKeyEvent.iCode == EKeyEnter || aKeyEvent.iCode == EKeyOK)

    {

        traversalDoIt = EFalse;

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// CSwtCombo::HandlePointerEventL

// From CCoeControl

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

//

#ifdef RD_SCALABLE_UI_V2

void CSwtCombo::HandlePointerEventL(const TPointerEvent& aPointerEvent)

{

    TBool pressed = iPressed;

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

    {

        iPressed = ETrue;

#ifdef RD_JAVA_ADVANCED_TACTILE_FEEDBACK

        // When clicking on area outside combo (e.g. on Caption of captioned

        // control), no native feedback (from CAknChoiceList) is generated.

        // So eSWT has to generate the feedback.

        if (iFeedback && !iCombo->Rect().Contains(aPointerEvent.iPosition))

        {

            iFeedback->InstantFeedback(ETouchFeedbackList);

        }

#endif //RD_JAVA_ADVANCED_TACTILE_FEEDBACK

    }

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

    {

        if (!iDisplay.RevertPointerEvent())

        {

            // Opening the popup choice list must be always done manually.

            DoOpenL();

        }

        else

        {

            iPressed = EFalse;

        }

    }

    else

    {

        CCoeControl::HandlePointerEventL(aPointerEvent);

    }

    if (pressed != iPressed)

        Redraw();

}

#endif //RD_SCALABLE_UI_V2

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

// CSwtCombo::HandleResourceChange

// From CCoeControl

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

//

void CSwtCombo::HandleResourceChange(TInt aType)

{

    TRAP_IGNORE(SwtHandleResourceChangeL(aType));

}

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

// CSwtCombo::Draw

// From CCoeControl

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

//

void CSwtCombo::Draw(const TRect& /*aRect*/) const

{

}

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

// CSwtCombo::MopSupplyObject

// From CCoeControl

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

//

TTypeUid::Ptr CSwtCombo::MopSupplyObject(TTypeUid aId)

{

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

    if (!id.Pointer())

    {

        return CAknControl::MopSupplyObject(aId);

    }

    else

    {

        return id;

    }

}

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

// CSwtCombo::SbFrame

// From ASwtScrollableBase

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

//

CEikScrollBarFrame* CSwtCombo::SbFrame() const

{

    return NULL;

}

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

// CSwtCombo::CoeControl

// From MSwtControl

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

//

CCoeControl& CSwtCombo::CoeControl()

{

    return *this;

}

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

// CSwtCombo::CoeControl

// From MSwtControl

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

//

const CCoeControl& CSwtCombo::CoeControl() const

{

    return *this;

}

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

// CSwtCombo::ComputeSizeL

// From MSwtControl

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

//

TSize CSwtCombo::ComputeSizeL(TInt aWhint, TInt aHhint)

{

    TSize prefSize(aWhint, aHhint);

    if (aWhint != KSwtDefault && aHhint != KSwtDefault)

    {

        return prefSize;

    }

    // WORKAROUND: The platform API does not provide functions that could

    // return ideal dimensions based on content. Therefore, default values

    // from CAknChoiceList layouts and text measuring give the computed size.

    // WARNING: We asume here that CAknChoiceList will not change layouts.

    TInt w = aWhint;

    TInt h = aHhint;

    CSwtLafFacade::TSwtLafFacadeWindowLineLayout layoutPane =

        CSwtLafFacade::GetChoiceListPaneLayout();

    CSwtLafFacade::TSwtLafFacadeTextLineLayout layoutLabel =

        CSwtLafFacade::GetChoiceListPaneT1Layout();

    if (aHhint == KSwtDefault)

    {

        // Calculate height based on choice list pane and border.

        h = layoutPane.iH;

        MSwtUiUtils& utils = iDisplay.UiUtils();

        TMargins8 padding = iDisplay.UiUtils().InlineReferencePadding();

        TInt height = utils.InlineReferenceFontHeight();

        height += padding.iTop + padding.iBottom;

        if (h < height) h = height;

        h += BorderSizeDelta().iHeight;

    }

    if (aWhint == KSwtDefault)

    {

        // Go trough all the items and get the with of the widest one.

        TInt txtMaxW = 0;

        const CAknLayoutFont* font = AknLayoutUtils::LayoutFontFromId(

                                         layoutLabel.iFont);

        if (font)

        {

            TInt count = iItems->Count();

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

            {

                txtMaxW = Max(txtMaxW,

                              font->TextWidthInPixels((*iItems)[i]));

            }

            // WORKAROUND: Add space for one more char to avoid clipping :)

            txtMaxW += font->TextWidthInPixels(KTxtSpace);

        }

        // Calculate width based on widest item, label pane and border.

        w += txtMaxW;

        w += layoutLabel.il;

        w += layoutLabel.ir;

        w += BorderSizeDelta().iWidth;

    }

    prefSize.iHeight = h;

    prefSize.iWidth = w;

    return prefSize;

}

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

// CSwtCombo::ProcessKeyEventL

// From MSwtControl

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

//

void CSwtCombo::ProcessKeyEventL(const TKeyEvent& aKeyEvent, TEventCode aType)

{

    if (aType == EEventKey)

    {

        if (aKeyEvent.iCode == EKeyEnter || aKeyEvent.iCode == EKeyOK)

        {

            if (!iOpen)

            {

                DoOpenL();

                iDisplay.PostDefaultSelectionEventL(iPeer);

            }

        }

    }

}

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

// CSwtCombo::IsKeyUsed

// From MSwtControl

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

//

TBool CSwtCombo::IsKeyUsed(TUint aKeyCode) const

{

    TBool used = ETrue;

    switch (aKeyCode)

    {

    case EKeyBackspace:

        used = EFalse;

        break;

    default:

        break;

    }

    return used;

}

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

// CSwtCombo::SwtHandleResourceChangeL

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

//

void CSwtCombo::SwtHandleResourceChangeL(TInt aType)

{

    if (aType == KEikDynamicLayoutVariantSwitch)

    {

        DoClose();

    }

    CAknControl::HandleResourceChange(aType);

}

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

// CSwtCombo::MSKLabelL

// From MSwtControl

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

//

HBufC* CSwtCombo::MSKLabelL() const

{

    return iEikonEnv->AllocReadResourceL(R_QTN_MSK_OPEN);

}

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

// CSwtCombo::ComputeTrim

// From MSwtScrollable

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

//