/*

* Copyright (c) 2009 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:  Predictive list

*

*/

// INCLUDE FILES

#include <AknsDrawUtils.h>

#include <aknconsts.h> // KStatusPaneBackgroundColor

#include <aknlayoutscalable_avkon.cdl.h> // AknLayoutScalable_Avkon

#include <peninputeventjp.h>  // EPeninputLayoutEventSelectItem

#include <peninputrepeatbutton.h>   // CAknFepCtrlEventButton,CAknFepCtrlRepeatButton

#include <peninputlayout.h>

#include <AknsBasicBackgroundControlContext.h> 

#include "peninputeventjp.h"

#include "peninputjapanesepredictivewnd.h"

#include "peninputjapanesepredictivelistbox.h"

#include "peninputjapanesepredictivecelllistboxdata.h"

#include "peninputjapanesepredictiveListboxitemdrawer.h"

#include "peninputlayoutwindowjp.h"

// CONSTANTS

const TInt KMaxListColumns = 24;  // for vkb

const TInt KSpaceCharCode = ' ';

/**

*  CPeninputJapanesePredictiveWnd class.

*

*/

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

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

// CPeninputJapanesePredictiveWnd::NewL

// Two-phased constructor.

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

//

EXPORT_C CPeninputJapanesePredictiveWnd* CPeninputJapanesePredictiveWnd::NewL(CFepUiLayout* aUiLayout,

                                                               TInt aControlId, const CCoeControl* aParent)

    {

    CPeninputJapanesePredictiveWnd* self =

        new(ELeave) CPeninputJapanesePredictiveWnd(aUiLayout, aControlId);

    CleanupStack::PushL(self);

    self->ConstructL(aParent);

    CleanupStack::Pop(self);

    return self;

    }

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

// CPeninputJapanesePredictiveWnd::~CPeninputJapanesePredictiveWnd

// Destructor

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

//

CPeninputJapanesePredictiveWnd::~CPeninputJapanesePredictiveWnd()

    {

    delete iListBox;

    if (iLineInfoArray)

        {

        iLineInfoArray->ResetAndDestroy();

        }

    delete iLineInfoArray;

    delete iListTextArray;

    }

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

// CPeninputJapanesePredictiveWnd::SetRect

// Set the prediction pane's rect

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

//

EXPORT_C void CPeninputJapanesePredictiveWnd::SetRect(const TRect& aRect)

    {

    if (!iUnitWidth)

        {

        return;  // not ready

        }

    iRect = aRect;

    CFepUiBaseCtrl::UpdateValidRegion(this, ETrue);  // for getting pointer event

    TRect rect(aRect);

    TAknWindowLineLayout textWindowLayout =

        AknLayoutScalable_Avkon::list_single_choice_list_pane(0).LayoutLine();

    TInt topMargin = (iUnitHeight > textWindowLayout.iH)? (iUnitHeight - textWindowLayout.iH) : KPENINPUT_LAYOUT_VALUE_2;

    rect.Shrink(KPENINPUT_LAYOUT_VALUE_4, topMargin);

    rect.iBr.iX -=iUnitWidth;

    iListBox->SetRect(rect);  // call iListBox->SizeChaged()

    if (iScrollUpBtn && iScrollDownBtn)

        {

        TRect upBtn(TPoint(iRect.iBr.iX -iUnitWidth , iRect.iTl.iY), TSize(iUnitWidth, iUnitHeight));

        TRect downBtn(TPoint(iRect.iBr.iX - iUnitWidth, iRect.iTl.iY + iUnitHeight), TSize(iUnitWidth, iUnitHeight));

        iScrollUpBtn->SetRect(upBtn);

        iScrollDownBtn->SetRect(downBtn);

        }

    // instead of MakeVisible(EFalse)

    if (iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical))

        {

        TRect sbRect(TPoint(rect.iBr.iX, Rect().iTl.iY)

            , TSize(iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical)->Rect().Size().iHeight,0));

        iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical)->SetRect(sbRect);

        }

    }

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

// CPeninputJapanesePredictiveWnd::Hide

// (other items were commented in a header).

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

//

void CPeninputJapanesePredictiveWnd::Hide(TBool aFlag)

    {

    if (iScrollUpBtn && iScrollDownBtn)

        {

        CPeninputLayoutWindowJp* window = static_cast<CPeninputLayoutWindowJp*>(iScrollUpBtn->ParentCtrl());

        if (window)

            {

            window->ICFDisableRegionUpdating();  // ICF::OnDeActivate()

            }

        if (aFlag || !iScrollUpBtn->IsDimmed())

            {

            iScrollUpBtn->Hide(aFlag);

            iScrollDownBtn->Hide(aFlag);

            }

        else

            {

            iScrollUpBtn->Hide(ETrue);

            iScrollDownBtn->Hide(ETrue);

            }

        }

    CFepLayoutPopupWnd::Hide(aFlag);

    }

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

// CPeninputJapanesePredictiveWnd::SetButtons

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

//

void CPeninputJapanesePredictiveWnd::SetButtons(CAknFepCtrlEventButton* aScrollUpBtn

                                              , CAknFepCtrlEventButton* aScrollDownBtn)

    {

    if (aScrollUpBtn && aScrollDownBtn)

        {

        iScrollUpBtn = aScrollUpBtn;

        iScrollDownBtn = aScrollDownBtn;

        iScrollUpBtn->AddEventObserver(this);

        iScrollDownBtn->AddEventObserver(this);

        ActivateButtons(EFalse);

        }

    }

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

// CPeninputJapanesePredictiveWnd::SetCurrentItemIndex

// Specify the cursor position of a pop-up list.

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

//

void CPeninputJapanesePredictiveWnd::SetCurrentItemIndex(TInt aItemIndex) const

    {

    CPeninputJapanesePredictiveListBoxModel* model =

        static_cast<CPeninputJapanesePredictiveListBoxModel*>(iListBox->Model());

    const TInt maximumItems = model->MaximumItems();

    if (aItemIndex > maximumItems)

        {

        aItemIndex = maximumItems;

        }

    iListBox->SetCurrentCandidateNo(aItemIndex, EFalse);

    }

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

// CPeninputJapanesePredictiveWnd::HandleControlEvent

// (other items were commented in a header).

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

//

void CPeninputJapanesePredictiveWnd::HandleControlEvent(TInt aEventType,

                                          CFepUiBaseCtrl* /*aCtrl*/,

                                          const TDesC& /*aEventData*/)

    {

    TPointerEvent pEvent;

    pEvent.iType = TPointerEvent::EButton1Down;

    pEvent.iModifiers = 0;

    pEvent.iParentPosition = TPoint(0,0);

    switch (aEventType)

        {

        case EPeninputLayoutEventScrollUp:

            if (iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical))

                {

                TRAP_IGNORE(iListBox->HandleScrollEventL(iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical),EEikScrollUp));

                ReDraw();

                }

            break;

        case EPeninputLayoutEventScrollDown:

            if (iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical))

                {

                TRAP_IGNORE(iListBox->HandleScrollEventL(iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical),EEikScrollDown));

                ReDraw();

                }

            break;

        default:

            break;

        }

    }

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

// CPeninputJapanesePredictiveWnd::ShowPredictiveListL

// popup is shown always.this method draws lists.

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

//

void CPeninputJapanesePredictiveWnd::ShowPopupL(const CDesCArrayFlat* aItems, TInt aIndex)

    {

    if(Hiden())

        {

        return;

        }

    if(aItems->Count() <= 0)

        {

        HidePopup();  // clear lists

        return;

        }

    if (iLineInfoArray)

        {

        iLineInfoArray->ResetAndDestroy();

        }

    else

        {

        iLineInfoArray = new(ELeave) CPredictivePopupLineInfoArray(1);

        }

    TAknTextLineLayout textLineLayout =

        AknLayoutScalable_Avkon::fep_vkb_top_text_pane_t1().LayoutLine();

    TInt allowDrawWidth = Rect().Size().iWidth - iUnitWidth-KPENINPUT_LAYOUT_VALUE_16;

    // Setup iLineInfoArray

    CreatePredictivePopupLineInfoArrayL(aItems, allowDrawWidth, textLineLayout.iFont);

    // Create iListTextArray

    CreateListTextArrayL(*iLineInfoArray);

    // Set listitems.

    CPeninputJapanesePredictiveListBoxModel* model =

        static_cast<CPeninputJapanesePredictiveListBoxModel*>(iListBox->Model());

    model->SetMaximumItems(aItems->Count());

    model->SetLineInfoArray(iLineInfoArray);

    model->SetItemTextArray(iListTextArray);

    model->SetOwnershipType(ELbmDoesNotOwnItemArray);

    SetCurrentItemIndex(aIndex);

    SetRect(Rect());

    iListBox->ActivateL();

    TBool dimm = EFalse;

    if (iLineInfoArray->Count() <= iListBox->BottomItemIndex() + 1)

        {

        dimm = ETrue;

        }

    if (iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical))

        {

        iListBox->ScrollBarFrame()->GetScrollBarHandle(CEikScrollBar::EVertical)->SetDimmed(dimm);

        }

    ActivateButtons(!dimm);

    if (dimm)

        {

        ClearList();

        }

    iListBox->Draw();

    if (iScrollUpBtn && iScrollDownBtn && !iScrollUpBtn->IsDimmed())

        {

        iScrollUpBtn->Draw();

        iScrollDownBtn->Draw();

        }

    UpdateArea(iRect, EFalse);

    }

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

// CPeninputJapanesePredictiveWnd::HideWindow

// popup is shown always.this method clear lists.

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

//

void CPeninputJapanesePredictiveWnd::HidePopup()

    {

    if(!Hiden())

        {

        // Reset listitems.

        if (iLineInfoArray)

            {

            iLineInfoArray->ResetAndDestroy();

            }

        ActivateButtons(EFalse);

        ClearList();

        }

    }

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

// CPeninputJapanesePredictiveWnd::CurrentItemIndexOfCandidate

// Return a selected candidate item number currently

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

//

TInt CPeninputJapanesePredictiveWnd::CurrentItemIndexOfCandidate() const

    {

    if (iListBox->IsVisible())

        {

        return iListBox->CurrentCandidateNo();

        }

    return -1;      // Disable window

    }

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

// CPeninputJapanesePredictiveWnd::MoveTo

// Move a current item in an appointed direction

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

//

void CPeninputJapanesePredictiveWnd::MoveTo(TPeninputUICtrlScroll aDirection)

    {

    if (iListBox->IsVisible())

        {

        TBool action = ETrue;

        switch(aDirection)

            {

            case EScrollLeft:

                {

                iListBox->MovePreviousItem();

                }

                break;

            case EScrollRight:

                {

                iListBox->MoveNextItem();

                }

                break;

            case EScrollUp:

                {

                iListBox->MovePreviousLineItem();

                }

                break;

            case EScrollDown:

                {

                iListBox->MoveNextLineItem();

                }

                break;

            default:

                {

                action = EFalse;

                }

                break;

            }

        if (action)

            {

            if (!Hiden())

                {

                ReDraw();

                }

            }

        }

    }

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

// CPeninputJapanesePredictiveWnd::SizeChanged

// called by CPeninputLayoutWindowJp::SetControlsFont()

// (other items were commented in a header).

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

//

void CPeninputJapanesePredictiveWnd::SizeChanged(TInt aWidth, TInt aUnitWidth, TInt aUnitHeight)

    {

    if (aWidth > iUnitWidth)

        {

        iUnitWidth = aUnitWidth;

        iUnitHeight = aUnitHeight;

        TRect newRect(Rect().iTl ,TSize(aWidth,iUnitHeight*KPENINPUT_LAYOUT_PREDICTIONPANE_ROW_COUNT));

        SetRect(newRect);   // call iListBox->SetRect(), call iListBox->SizeChanged()

        iScrollUpBtn->SizeChanged(iScrollUpBtn->Rect(), iScrollUpBtn->Rect(), ETrue);

        iScrollDownBtn->SizeChanged(iScrollDownBtn->Rect(), iScrollDownBtn->Rect(), ETrue);

        }

    }

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

// CPeninputJapanesePredictiveWnd::HitTest

// Get item whose region contains the point.

// (other items were commented in a header).

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

//

TInt CPeninputJapanesePredictiveWnd::HitTest(const TPoint& aPoint)

    {

    if( !Rect().Contains(aPoint) )

        {

        return -1;

        }

    TRect listRect = iListBox->Rect();

    if (listRect.iBr.iX >= aPoint.iX)

        {

        return 1;  // ListBox Side

        }

        return 0;     // ScrollBar

    }

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

// CPeninputJapanesePredictiveWnd::HandlePointerDownEventL

// Handle pointer down event.

// (other items were commented in a header).

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

//

CFepUiBaseCtrl* CPeninputJapanesePredictiveWnd::HandlePointerDownEventL(const TPoint& aPoint)

    {

    CFepLayoutPopupWnd::HandlePointerDownEventL(aPoint);  // set pointer down

    if (iLineInfoArray && iLineInfoArray->Count() > 0)

        {

        TInt index = HitTest(aPoint);

        TPointerEvent pEvent;

        pEvent.iType = TPointerEvent::EButton1Down;

        pEvent.iPosition = aPoint;

        pEvent.iModifiers = 0;

        pEvent.iParentPosition = TPoint(0,0);

        if (1 == index)  // on ListBox

            {

            TInt oldItem = iListBox->CurrentItemIndex();

            iListBox->HandlePointerEventL(pEvent);

            TInt currentItem = iListBox->CurrentItemIndex();

            if (0 <= currentItem)

                {

                iListBox->SetCurrentCandidateNo(currentItem, aPoint-iListBox->Rect().iTl, ETrue);

                if (oldItem != currentItem)

                    {

                    TInt topItem = iListBox->TopItemIndex();

                    if (topItem <= oldItem && topItem + KPENINPUT_LAYOUT_PREDICTIONPANE_ROW_COUNT> oldItem)

                        {

                        iListBox->SetCurrentItemIndexAndDraw(oldItem);

                        iListBox->SetCurrentItemIndex(currentItem);

                        }

                    }

                ReDraw();

                }

            }

        }

    return this;

    }

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

// CPeninputJapanesePredictiveWnd::HandlePointerMoveEventL

// Handle pointer move event.

// (other items were commented in a header).

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

//

CFepUiBaseCtrl* CPeninputJapanesePredictiveWnd::HandlePointerMoveEventL(const TPoint& aPoint)

    {

    CFepLayoutPopupWnd::HandlePointerMoveEventL(aPoint);  // nop

    if( PointerDown() && iLineInfoArray && iLineInfoArray->Count() > 0)

        {

        TInt index = HitTest(aPoint);

        TPointerEvent pEvent;

        pEvent.iType = TPointerEvent::EDrag;

        pEvent.iPosition = aPoint;

        pEvent.iModifiers = 0;

        pEvent.iParentPosition = TPoint(0,0);

        if (1 == index)

            {

            TInt oldItem = iListBox->CurrentItemIndex();

            iListBox->HandlePointerEventL(pEvent);

            TInt currentItem = iListBox->CurrentItemIndex();

            if (0 <= currentItem)

                {

                iListBox->SetCurrentCandidateNo(currentItem, aPoint-iListBox->Rect().iTl, ETrue);

                if (oldItem != currentItem)

                    {

                    iListBox->SetCurrentItemIndexAndDraw(oldItem);

                    iListBox->SetCurrentItemIndex(currentItem);

                    }

                ReDraw();

                }

            }

        }

    return this;

    }

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

// CPeninputJapanesePredictiveWnd::HandlePointerUpEventL

// Handle pointer up event.

// (other items were commented in a header).

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

//

CFepUiBaseCtrl* CPeninputJapanesePredictiveWnd::HandlePointerUpEventL(const TPoint& aPoint)

    {

    TBool down = PointerDown();

    CFepLayoutPopupWnd::HandlePointerUpEventL(aPoint);  // pointer down off

    TInt index = HitTest(aPoint);

    if (down && iLineInfoArray && iLineInfoArray->Count() > 0)

        {

        TPointerEvent pEvent;

        pEvent.iType = TPointerEvent::EButton1Up;

        pEvent.iPosition = aPoint;

        pEvent.iModifiers = 0;

        pEvent.iParentPosition = TPoint(0,0);

        if (1 == index)  // onListBox

            {

            iListBox->HandlePointerEventL(pEvent);

            TInt currentItem = iListBox->CurrentItemIndex();

            if (0 <= currentItem)

                {

                iListBox->SetCurrentCandidateNo(currentItem, aPoint-iListBox->Rect().iTl, ETrue);

                }

            ReportEvent(EPeninputLayoutEventSelectItem);

            }

        }

    return this;

    }

// CallBack from ListBox

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

// CPeninputJapanesePredictiveWnd::HandleListBoxEventL

// (other items were commented in a header).

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

//

void CPeninputJapanesePredictiveWnd::HandleListBoxEventL(

    CEikListBox* /*aListBox*/, TListBoxEvent /*aEventType*/)

    {

    }