/*

* Copyright (c) 2002-2007 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 <aknlayoutscalable_avkon.cdl.h>

#include "peninputeventjp.h"

#include "peninputjapanesepredictivelistboxview.h"

#include "peninputjapanesepredictiveListboxitemdrawer.h"

#include "peninputjapanesepredictivecelllistboxdata.h"

#include "peninputjapanesepredictivelistboxmodel.h"

#include "peninputjapanesepredictivelistbox.h"

#include "peninputjapanesepredictivewnd.h"

// CONSTANTS

const TInt KScrollRightMarge = 5;

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

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

// CPeninputJapanesePredictiveListBox::ConstructL

// Symbian 2nd phase constructor can leave.

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

void CPeninputJapanesePredictiveListBox::ConstructL(

        const CCoeControl* aParent,

        TInt aFlags)

    {

    CAknFilteredTextListBoxModel* model =

            new(ELeave) CPeninputJapanesePredictiveListBoxModel;

    iModel=model;

    model->ConstructL();

    CreateItemDrawerL();

    EnableExtendedDrawingL();

    iItemDrawer->SetDrawMark(EFalse);

    CEikListBox::ConstructL(aParent,aFlags);

    iLineCount = KPENINPUT_LAYOUT_PREDICTIONPANE_ROW_COUNT;

    }

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

// CPeninputJapanesePredictiveListBox::SetCurrentCandidateNo

// Selecting a candidate number appointed with an argument

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

void CPeninputJapanesePredictiveListBox::SetCurrentCandidateNo(

        TInt aCandidateNo, TBool aDraw) const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt itemIndex = view->SetCurrentCandidateNo(aCandidateNo);

    if (itemIndex >= 0)

        {

        if (aDraw)

            {

            SetCurrentItemIndexAndDraw(itemIndex);

            }

        else

            {

            SetCurrentItemIndex(itemIndex);

            }

        }

    }

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

// CPeninputJapanesePredictiveListBox::SetCurrentCandidateNo

// Selecting a candidate number appointed with an argument

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

void CPeninputJapanesePredictiveListBox::SetCurrentCandidateNo(

        TInt aLineNo, const TPoint& aPoint, TBool aDraw) const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt itemIndex = view->SetCurrentCandidateNo(aLineNo, aPoint);

    if (aDraw)

        {

        SetCurrentItemIndexAndDraw(itemIndex);

        }

    else

        {

        SetCurrentItemIndex(itemIndex);

        }

    }

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

// CPeninputJapanesePredictiveListBox::CurrentCandidateNo

// Returning a selected number

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

TInt CPeninputJapanesePredictiveListBox::CurrentCandidateNo() const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    return view->CurrentCandidateNo();

    }

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

// CPeninputJapanesePredictiveListBox::MovePreviousItem

// selecting a previous candidate

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

TInt CPeninputJapanesePredictiveListBox::MovePreviousItem() const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt candidateNo = view->PreviousItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CPeninputJapanesePredictiveListBox::MoveNextItem

// selecting a next candidate

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

TInt CPeninputJapanesePredictiveListBox::MoveNextItem() const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt candidateNo = view->NextItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CPeninputJapanesePredictiveListBox::MovePreviousLineItem

// selecting a previous line candidate

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

TInt CPeninputJapanesePredictiveListBox::MovePreviousLineItem() const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt candidateNo = view->PreviousLineItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CPeninputJapanesePredictiveListBox::MoveNextLineItem

// selecting a next line candidate

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

TInt CPeninputJapanesePredictiveListBox::MoveNextLineItem() const

    {

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    TInt candidateNo = view->NextLineItem();

    SetCurrentCandidateNo(candidateNo, ETrue);

    return candidateNo;

    }

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

// CPeninputJapanesePredictiveListBox::HandlePointerEventL

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

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

void CPeninputJapanesePredictiveListBox::HandlePointerEventL(const TPointerEvent& aPointerEvent)

    {

    CAknSinglePopupMenuStyleListBox::HandlePointerEventL(aPointerEvent);

    }

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

// CPeninputJapanesePredictiveListBox::Draw

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

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

void CPeninputJapanesePredictiveListBox::Draw() const

    {

    CWindowGc* gcSave = CCoeEnv::Static()->SwapSystemGc(ItemDrawer()->Gc());

    DrawNow();

    CCoeEnv::Static()->SwapSystemGc(gcSave);

    }

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

// CPeninputJapanesePredictiveListBox::SetLineCount

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

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

void CPeninputJapanesePredictiveListBox::SetLineCount(TInt aLineCount)

    {

    iLineCount = aLineCount;

    }

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

// CPeninputJapanesePredictiveListBox::SizeChanged

// This function is called in case changing size

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

void CPeninputJapanesePredictiveListBox::SizeChanged()

    {

    CEikFormattedCellListBox& listBox = *this;

    CFormattedCellListBoxItemDrawer* itemDrawer = listBox.ItemDrawer();

    TAknWindowLineLayout textWindowLayout =

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

    TAknTextLineLayout textLineLayout =

        AknLayoutScalable_Avkon::fep_vkb_top_text_pane_t1().LayoutLine();

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

    textWindowLayout.iH = Rect().Size().iHeight/2;  // control itemheight

    AknListBoxLayouts::SetupStandardListBox(listBox);  // SetBorder(TGulBorder::ENone)

    AknListBoxLayouts::SetupStandardFormListbox(itemDrawer); // Set Standard Colors

    AknListBoxLayouts::SetupListboxPos(listBox, textWindowLayout);  // ItemDrawer()->SetItemCellSize()

    {

    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 );

    }

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

    // setting textbox size in listbox

    TInt baseline = itemSize.iHeight/2 + font->AscentInPixels() / 2;

    textLineLayout.iB = ELayoutP - baseline;  // control itemheight

    AknListBoxLayouts::SetupFormAntiFlickerTextCell(listBox, itemDrawer, 0,

                            textLineLayout,

                            TPoint(0, 0),

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

    CEikFormattedCellListBox::SizeChanged();

    // Scroll bar

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

    scrollLineLayout.il = ELayoutEmpty;

    scrollLineLayout.ir = KScrollRightMarge;

    scrollLineLayout.it = 0;

    scrollLineLayout.ib = 0;

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

                                  TSize(listBox.Rect().Width() + scrollLineLayout.iW + scrollLineLayout.ir,

                                        listBox.Rect().Height()));

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

    }

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

// CPeninputJapanesePredictiveListBox::MakeViewClassInstanceL

// Creating a view

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

CListBoxView* CPeninputJapanesePredictiveListBox::MakeViewClassInstanceL()

    {

    return new(ELeave) CPeninputJapanesePredictiveListBoxView;

    }

void CPeninputJapanesePredictiveListBox::HandleScrollEventL(CEikScrollBar* aScrollBar,TEikScrollEvent aEventType)

    {

    TInt oldThumbPos = (aEventType & KEikScrollEventBarMask) ? iView->HScrollOffset() : iView->TopItemIndex();

    TInt newThumbPos = oldThumbPos;

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

    switch (aEventType & KEikScrollEventBarMask)

        {

    case KEikScrollEventFromVBar:

        switch (aEventType)

            {

        case EEikScrollUp:

            if (newThumbPos > 0)

                {

                -- newThumbPos;

                }

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

                {

                newThumbPos = maxThumbPos;              

                }

            break;

        case EEikScrollDown:

            if (newThumbPos < maxThumbPos)

                {

                ++ newThumbPos;

                }

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

                {

                newThumbPos = 0;                

                }

            break;

        default:

            break;

            }

        if ( newThumbPos != oldThumbPos )

            {

            iView->VScrollTo(newThumbPos);

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

            UpdateScrollBarThumbs();

            }

        break;

    default:

        break;

        }

    }

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

// CPeninputJapanesePredictiveListBox::CreateItemDrawerL

// Creating a ItemDrawer

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

void CPeninputJapanesePredictiveListBox::CreateItemDrawerL()

    {

    CPeninputJapanesePredictiveCellListBoxData*

        cellData = CPeninputJapanesePredictiveCellListBoxData::NewL();

    CleanupStack::PushL(cellData);

    iItemDrawer =

        new(ELeave) CPeninputJapanesePredictiveListBoxItemDrawer(

                        Model(), NULL, cellData);

    CleanupStack::Pop(cellData);    // cellData

    }

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

// CPeninputJapanesePredictiveListBox::UpdateCurrentItem

// Update the current index

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

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

void CPeninputJapanesePredictiveListBox::UpdateCurrentItem(TInt aItemIndex) const

    {

    CPeninputJapanesePredictiveListBoxModel* model =

        static_cast<CPeninputJapanesePredictiveListBoxModel*>(Model());

    CPeninputJapanesePredictiveListBoxView* view =

        static_cast<CPeninputJapanesePredictiveListBoxView*>(View());

    if (!model->LineInfoArray())

        {

        return;

        }

    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();

    }

// End of File