/*

* Copyright (c) 2002-2004 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 candidate list

*

*/

// INCLUDE FILES

#include <eikdef.h>

#include <aknViewAppUi.h>

#include <avkon.hrh>

#include <aknPopup.h>

#include <aknlists.h>

#include <AknLayout.lag>

#include <aknlayoutscalable_avkon.cdl.h>

#include <AknFontId.h>

#include "AknFepUiInterfacePanic.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveListboxView.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveListboxItemDrawer.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveCellListBoxData.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveListBoxModel.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveListbox.h"

#include "AknFepUIAvkonCtrlJapanesePredictivePane.h"

// CONSTANTS

const TInt KListboxMarge = 4;

const TInt KScrollRightMarge = 5;

const TInt KListBoxVisibleRow = 3;

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

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

// CAknFepUICtrlJapanesePredictiveListbox::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknFepUICtrlJapanesePredictiveListbox::ConstructL(

        const CCoeControl* aParent,

        TInt aFlags)

    {

    CAknFilteredTextListBoxModel* model =

            new(ELeave) CAknFepUICtrlJapanesePredictiveListBoxModel;

    iModel=model;

    model->ConstructL();

    CreateItemDrawerL();

    EnableExtendedDrawingL();

    iItemDrawer->SetDrawMark(EFalse);

    CEikListBox::ConstructL(aParent,aFlags);

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::SetCurrentCandidateNo

// Selecting a candidate number appointed with an argument

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

//

void CAknFepUICtrlJapanesePredictiveListbox::SetCurrentCandidateNo(

        TInt aCandidateNo, TBool aDraw)

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TInt itemIndex = view->SetCurrentCandidateNo(aCandidateNo);

    if (aDraw)

        {

        SetCurrentItemIndexAndDraw(itemIndex);

        }

    else

        {

        SetCurrentItemIndex(itemIndex);

        }

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::CurrentCandidateNo

// Returning a selected number

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

//

TInt CAknFepUICtrlJapanesePredictiveListbox::CurrentCandidateNo()

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    return view->CurrentCandidateNo();

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::MovePreviousItem

// selecting a previous candidate

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

//

TInt CAknFepUICtrlJapanesePredictiveListbox::MovePreviousItem()

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TInt candidateNo = view->PreviousItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::MoveNextItem

// selecting a next candidate

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

//

TInt CAknFepUICtrlJapanesePredictiveListbox::MoveNextItem()

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TInt candidateNo = view->NextItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::MovePreviousLineItem

// selecting a previous line candidate

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

//

TInt CAknFepUICtrlJapanesePredictiveListbox::MovePreviousLineItem()

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TInt candidateNo = view->PreviousLineItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::MoveNextLineItem

// selecting a next line candidate

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

//

TInt CAknFepUICtrlJapanesePredictiveListbox::MoveNextLineItem()

    {

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TInt candidateNo = view->NextLineItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::SizeChanged

// This function is called in case changing size

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

//

void CAknFepUICtrlJapanesePredictiveListbox::SizeChanged()

    {

    CEikFormattedCellListBox& listBox = *this;

    CFormattedCellListBoxItemDrawer* itemDrawer = listBox.ItemDrawer();

    TAknWindowLineLayout textWindowLayout =

        AKN_LAYOUT_WINDOW_popup_fep_japan_predictive_window(0,0);

    // setting textbox size in listbox

    TAknTextLineLayout textLineLayout =

        AKN_LAYOUT_TEXT_Predictive_candidate_selection_list_texts_Line_1(0,0);

    TAknTextComponentLayout scal = AknLayoutScalable_Avkon::popup_fep_japan_predictive_window_t1(0);

    TAknWindowLineLayout scrollLineLayout = AknLayoutScalable_Avkon::scroll_pane_cp29().LayoutLine();

    TAknLayoutText text;

    text.LayoutText(textWindowLayout.Rect(), textLineLayout);

    textWindowLayout.iW = text.TextRect().Width();

    CAknFepUICtrlJapanesePredictiveListBoxModel* model =

        static_cast<CAknFepUICtrlJapanesePredictiveListBoxModel*>(Model());

    TInt maxRows = model->LineInfoArray()->Count();

    TInt maxVisibleRows = Min(KJapPredictiveVisibleListRowsMax, maxRows);

    maxVisibleRows = Max(KJapPredictiveVisibleListRowsMin, maxVisibleRows);

    textWindowLayout.iH = listBox.Size().iHeight / maxVisibleRows;

    AknListBoxLayouts::SetupStandardListBox(listBox);

    AknListBoxLayouts::SetupStandardFormListbox(itemDrawer);

    AknListBoxLayouts::SetupListboxPos(listBox, textWindowLayout);

    {

    TRgb color( KRgbBlack );

    // this does not modify color unless it gets a correct one

    // no real need to check errors

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

                              color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG10 );

    itemDrawer->SetHighlightedTextColor( color );

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

                               color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG7 );

    iItemDrawer->SetTextColor( color );

    }

    textLineLayout.il -= KListboxMarge;

    textLineLayout.ir = 0;

    // Baseline must be set to textLineLayout.iB.

    const CFont* font = AknLayoutUtils::FontFromId(textLineLayout.iFont);

    TInt baseLineOffset = (textWindowLayout.iH - font->HeightInPixels())/2 + font->AscentInPixels();

    if( TAknFontId::IsEncodedFont(textLineLayout.FontId()) )

        {

        textLineLayout.iB = textWindowLayout.iH - font->DescentInPixels() -1 - baseLineOffset;

        }

    else

        {

        textLineLayout.iB = baseLineOffset;

        }

    TSize itemSize = View()->ItemSize();

    AknListBoxLayouts::SetupFormAntiFlickerTextCell(listBox, itemDrawer, 0,

                            textLineLayout,

                            TPoint(0, 0),

                            TPoint(itemSize.iWidth, itemSize.iHeight));

    CEikFormattedCellListBox::SizeChanged();

    // Scroll bar

    scrollLineLayout.il = ELayoutEmpty;

    scrollLineLayout.ir = KScrollRightMarge;

    scrollLineLayout.it = 0;

    scrollLineLayout.ib = 0;

    if (maxRows <= KJapPredictiveVisibleListRowsMax)

        {

        scrollLineLayout.iW = 0;

        }

    TAknWindowLineLayout laf =

        AKN_LAYOUT_WINDOW_popup_fep_japan_predictive_window(0,0);

    TRect scrollBarParent = TRect(TPoint(0, listBox.Rect().iTl.iY),

                                  TPoint(laf.iW, listBox.Rect().iBr.iY));

    AknLayoutUtils::LayoutVerticalScrollBar(iSBFrame, scrollBarParent, scrollLineLayout);

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::MakeViewClassInstanceL

// Creating a view

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

//

CListBoxView* CAknFepUICtrlJapanesePredictiveListbox::MakeViewClassInstanceL()

    {

    return new(ELeave) CAknFepUICtrlJapanesePredictiveListboxView;

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::CreateItemDrawerL

// Creating a ItemDrawer

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

//

void CAknFepUICtrlJapanesePredictiveListbox::CreateItemDrawerL()

    {

    CAknFepUICtrlJapanesePredictiveCellListBoxData*

        cellData = CAknFepUICtrlJapanesePredictiveCellListBoxData::NewL();

    CleanupStack::PushL(cellData);

    // getting font object

    TAknTextLineLayout textLineLayout =

        AKN_LAYOUT_TEXT_Predictive_candidate_selection_list_texts_Line_1(

            0, 0);

    const CFont* font = AknLayoutUtils::FontFromId(textLineLayout.iFont);

    iItemDrawer =

        new(ELeave) CAknFepUICtrlJapanesePredictiveListboxItemDrawer(

                        Model(), font, cellData);

    CleanupStack::Pop(cellData);

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::UpdateCurrentItem

// Update the current index

// Notes: The argument of aItemIndex means the current line. (not current candidate index)

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

//

void CAknFepUICtrlJapanesePredictiveListbox::UpdateCurrentItem(TInt aItemIndex) const

    {

    CAknFepUICtrlJapanesePredictiveListBoxModel* model =

        static_cast<CAknFepUICtrlJapanesePredictiveListBoxModel*>(Model());

    CAknFepUICtrlJapanesePredictiveListboxView* view =

        static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

    TPredictivePopupElement element;

    TInt curCandi = view->CurrentCandidateNo();

    TInt oldCandi = view->OldCandidateNo();

    TInt maxLine = model->LineInfoArray()->Count();

    TInt oldCurrentItemIndex = view->CurrentItemIndex();

    if (oldCurrentItemIndex != aItemIndex)

        {

        // Set the current line

        view->SetCurrentItemIndex(aItemIndex);

        if ( IsReadyToDraw() )

            {

            // Draw the old line

            view->DrawItem(oldCurrentItemIndex);

            }

        if (oldCurrentItemIndex+1 < maxLine

         && oldCurrentItemIndex+1 != aItemIndex)

            {

            if (model->SearchElement(oldCurrentItemIndex+1,

                                     oldCandi, element))

                {

                view->DrawItem(oldCurrentItemIndex+1);

                }

            }

        // Set the top position

        if (!(view->ItemIsVisible(aItemIndex)))

            {

            SetTopItemIndex(view->CalcNewTopItemIndexSoItemIsVisible(aItemIndex));

            DrawNow();

            }

        }

    // Draw the current line

    DrawItem(aItemIndex);

    // Check next line including the same candidate

    TInt nextLine = aItemIndex+1;

    if (nextLine < maxLine

     && model->SearchElement(nextLine, curCandi, element))

        {

        if (!(view->ItemIsVisible(nextLine)))

            {

            SetTopItemIndex(view->CalcNewTopItemIndexSoItemIsVisible(nextLine));

            DrawNow();

            }

        DrawItem(nextLine);

        }

    UpdateScrollBarThumbs();

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::HandlePointerEventL

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

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

void CAknFepUICtrlJapanesePredictiveListbox::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    const TInt old = CurrentItemIndex();

    CAknSinglePopupMenuStyleListBox::HandlePointerEventL(aPointerEvent);

    switch (aPointerEvent.iType)

        {

        case TPointerEvent::EButton1Up:

            break;

        case TPointerEvent::EButton1Down:

            {

            CAknFepUICtrlJapanesePredictiveListboxView* view =

                static_cast<CAknFepUICtrlJapanesePredictiveListboxView*>(View());

            TInt oldCandidateNo = view->CurrentCandidateNo();

            TPoint pos = aPointerEvent.iPosition - Rect().iTl;

            TInt itemIndex = view->SetCurrentCandidateNo(CurrentItemIndex(), pos);

            SetCurrentItemIndex(itemIndex);

            TInt newCandidateNo = view->CurrentCandidateNo();

            if (oldCandidateNo != newCandidateNo)

                {

                ReportListBoxEventL(MEikListBoxObserver::EEventItemDraggingActioned);// need draw.

                }

            }

            break;

        default:

            break;

        }

    }

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

// CAknFepUICtrlJapanesePredictiveListbox::HandleScrollEventL

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

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

void CAknFepUICtrlJapanesePredictiveListbox::HandleScrollEventL(

                                                    CEikScrollBar* aScrollBar,

                                                    TEikScrollEvent aEventType)

    {

    TInt oldThumbPos = (aEventType & KEikScrollEventBarMask) ?

                                iView->HScrollOffset() : iView->TopItemIndex();

    TInt newThumbPos = aScrollBar->ThumbPosition();

    TInt maxThumbPos = static_cast<CTextListBoxModel*>(Model())->NumberOfItems()

                                - KListBoxVisibleRow;

    TBool update = ETrue;

    TInt newThumbPosBeforeCorrecting = newThumbPos;

    if ((aEventType & KEikScrollEventBarMask) == KEikScrollEventFromVBar)

        {

        switch (aEventType)

            {

            case EEikScrollUp:

                if ( oldThumbPos == 0  && (iListBoxFlags & ELoopScrolling))

                    {

                    newThumbPos = maxThumbPos;

                    }

                break;

            case EEikScrollDown:

                if ( oldThumbPos == maxThumbPos && (iListBoxFlags & ELoopScrolling) )

                    {

                    newThumbPos = 0;

                    }

                break;

            case EEikScrollPageUp:

            case EEikScrollPageDown:

            case EEikScrollThumbDragVert:

                break;

            case EEikScrollThumbReleaseVert:

                // in the case of drag events, the scrollbar automatically updates its thumb pos...

                if(AknLayoutUtils::PenEnabled())

                    {

                    update = EFalse;

                    }

                break;

            default:

                break;

            }

        if ( (!AknLayoutUtils::PenEnabled()) || update )

            {

            iView->VScrollTo(newThumbPos);

            if (aEventType != EEikScrollThumbDragVert)

                {

                aScrollBar->SetModelThumbPosition(iView->TopItemIndex());

                }

            }

        // if event has changed thumb position, then update scroll bar

        if ( AknLayoutUtils::PenEnabled() && newThumbPos != newThumbPosBeforeCorrecting )

            {

            UpdateScrollBarThumbs();

            }

        }

    }

// End of File