/*

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

#include <AknsDrawUtils.h>

#include <AknsBasicBackgroundControlContext.h>

#include <aknfep.rsg>

#include <barsread.h>

#include <eikmop.h>

#include <AknLayout.lag>

#include <aknlayoutscalable_avkon.cdl.h>

#include "AknFepUiInterfacePanic.h"

#include "AknFepGlobalEnums.h"

#include "AknFepUIAvkonCtrlJapanesePredictiveListbox.h"

#include "AknFepUIAvkonCtrlJapanesePredictivePane.h"

#include "AknFepUIManagerJapanese.h"

// CONSTANTS

const TInt KMaxListColumns = 30;

const TInt KLAFBaseListRows = 1;

const TInt KLAFBelowTextBaseline = 2;

const TInt KLAFAboveTextBaseline = 1;

const TInt KSpaceCharCode = ' ';

const TInt KListboxFlameMarge = 4;

const TInt KScrollRightMarge = 5;

const TInt KListboxMarge = 3;

/**

*  CAknFepUICtrlJapanesePredictivePane class.

*

*/

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

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

// CAknFepUICtrlJapanesePredictivePane::NewL

// Two-phased constructor.

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

//

CAknFepUICtrlJapanesePredictivePane* CAknFepUICtrlJapanesePredictivePane::NewL(CAknFepUIManagerJapanese* aUiMng)

    {

    CAknFepUICtrlJapanesePredictivePane* self =

        new(ELeave)CAknFepUICtrlJapanesePredictivePane(aUiMng);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);    // self

    return self;

    }

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

// CAknFepUICtrlJapanesePredictivePane::~CAknFepUICtrlJapanesePredictivePane

// Destructor

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

//

CAknFepUICtrlJapanesePredictivePane::~CAknFepUICtrlJapanesePredictivePane()

    {

    if (IsVisible())

        {

        HideWindow();

        }

    if (iListBox)

        {

        delete iListBox;

        iListBox = NULL;

        }

    if (iLineInfoArray)

        {

        iLineInfoArray->ResetAndDestroy();

        delete iLineInfoArray;

        iLineInfoArray = NULL;

        }

    if (iListTextArray)

        {

        delete iListTextArray;

        iListTextArray = NULL;

        }

    }

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

// CAknFepUICtrlJapanesePredictivePane::ShowWindow

// Show Pop-up list

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

//

void CAknFepUICtrlJapanesePredictivePane::ShowWindow()

    {

    RWindow& window=Window();

    //Set ordinal position to top

    window.SetOrdinalPosition(0,ECoeWinPriorityFep);

    window.SetFaded(EFalse, RWindowTreeNode::EFadeIncludeChildren);

    window.SetPointerCapture(ETrue);

    TRAP_IGNORE( ActivateL());

    MakeVisible(ETrue);

    DrawNow();

    }

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

// CAknFepUICtrlJapanesePredictivePane::ClosePredictiveList

// Close Pop-up list

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

//

void CAknFepUICtrlJapanesePredictivePane::ClosePredictiveList()

    {

    CancelPopup();

    }

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

// CAknFepUICtrlJapanesePredictivePane::SetCurrentItemIndex

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

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

//

void CAknFepUICtrlJapanesePredictivePane::SetCurrentItemIndex(TInt aItemIndex)

    {

    CAknFepUICtrlJapanesePredictiveListBoxModel* model =

        static_cast<CAknFepUICtrlJapanesePredictiveListBoxModel*>(ListBox()->Model());

    const TInt maximumItems = model->MaximumItems();

    if (aItemIndex > maximumItems)

        {

        aItemIndex = maximumItems;

        }

    CAknFepUICtrlJapanesePredictiveListbox* listBox =

        static_cast<CAknFepUICtrlJapanesePredictiveListbox*>(ListBox());

    listBox->SetCurrentCandidateNo(aItemIndex, EFalse);

    }

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

// CAknFepUICtrlJapanesePredictivePane::SetOffsetPosition

// Specify the display position of a pop-up list

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

//

void CAknFepUICtrlJapanesePredictivePane::SetOffsetPosition(TPoint aOffset)

    {

    iOffsetPosition = aOffset;

    }

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

// CAknFepUICtrlJapanesePredictivePane::SetWindowPosition

// Set position to show candidate list

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

//

void CAknFepUICtrlJapanesePredictivePane::SetWindowPosition(

                                                const TPoint& aLeftSideOfBaseLine,

                                                TInt aHeight,

                                                TInt aAscent)

    {

    // getting rectangle of main pane

    TRect screen =

        TRect(0, 0, AKN_LAYOUT_WINDOW_screen.iW, AKN_LAYOUT_WINDOW_screen.iH);

    TAknLayoutRect main_pane;

    main_pane.LayoutRect(screen, AKN_LAYOUT_WINDOW_main_pane(screen, 0, 1, 1));

    iMainPaneRect = main_pane.Rect();

    TInt leftPos = aLeftSideOfBaseLine.iX;

    if (leftPos < 0)

        {

        leftPos = iOffsetPosition.iX;

        }

    TPoint windowOffset(

        leftPos,

        aLeftSideOfBaseLine.iY + aHeight - aAscent - iMainPaneRect.iTl.iY);

    SetOffsetPosition(windowOffset);

    iSrcTextHeight = aHeight;

    }

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

// CAknFepUICtrlJapanesePredictivePane::ShowCandidateListL

// Show Pop-up list

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

//

void CAknFepUICtrlJapanesePredictivePane::ShowCandidateListL(

        CDesCArrayFlat* aItems, TInt aIndex, TInt aResourceID)

    {

    __ASSERT_DEBUG(aItems->Count() > 0,

                   AknFepUiInterfacePanic(EAknFepUiInterfacePanicCandidatesEmpty));

    if (iLineInfoArray)

        {

        iLineInfoArray->ResetAndDestroy();

        }

    delete iLineInfoArray;

    delete iListTextArray;

    iLineInfoArray = NULL;

    iListTextArray = NULL;

    // getting listbox width by a pixel unit

    TAknWindowLineLayout laf =

        AKN_LAYOUT_WINDOW_popup_fep_japan_predictive_window(0, 0);

    TAknTextLineLayout textLineLayout =

        AKN_LAYOUT_TEXT_Predictive_candidate_selection_list_texts_Line_1(0,0);

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

    TAknLayoutText text;

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

    TInt allowDrawWidth = text.TextRect().Width() - scrollLineLayout.iW;

    iLineInfoArray = CreatePredictivePopupLineInfoArrayL(

        aItems, allowDrawWidth, textLineLayout.iFont);

    iListTextArray = CreateListTextArrayL(iLineInfoArray);

    // Set listitems.

    CAknFepUICtrlJapanesePredictiveListBoxModel* model =

        static_cast<CAknFepUICtrlJapanesePredictiveListBoxModel*>(ListBox()->Model());

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

    model->SetLineInfoArray(iLineInfoArray);

    model->SetItemTextArray(iListTextArray);

    model->SetOwnershipType(ELbmDoesNotOwnItemArray);

    iMaximumRows = MaximumRows(model);

    SetCurrentItemIndex(aIndex);

    SetMaximumHeight(iMaximumRows);

    // Show popup list

    TBool notShowingPopup =

        model->NumberOfItems() == 0 && iWindowType < 0x80;

    if (notShowingPopup)

        {

        const TSize screenSize=iCoeEnv->ScreenDevice()->SizeInPixels();

        iPopoutCba->SetBoundingRect(TRect(screenSize));

        }

    // Create a CBA for use with the popup

    if (aResourceID)

        {

        UpdateCbaL(aResourceID);

        }

    SetupWindowLayout(iWindowType);

    iListBox->SetListBoxObserver(this);

    if (iMarkable)

        {

        // If markable, set the popup to observe event change events.

        // Call HandleControlEvent to set the CBA appropriate to the 1st item

        iListBox->SetObserver(this);

        HandleControlEventL(iListBox, EEventStateChanged);

        }

    if (IsVisible())

        {

        DrawDeferred();

        }

    else

        {

        ShowWindow();

        ActivateL();

        ShowWindowCbaL();

        }

    }

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

// CAknFepUICtrlJapanesePredictivePane::HideWindow

// Hide Pop-up list

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

//

void CAknFepUICtrlJapanesePredictivePane::HideWindow()

    {

    MakeVisible(EFalse);

    Window().SetPointerCapture(EFalse);

    iEikonEnv->RemoveFromStack(iPopoutCba);

    iPopoutCba->MakeVisible(EFalse);

    iCurrentResource = 0;

    }

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

// CAknFepUICtrlJapanesePredictivePane::CurrentItemIndexOfCandidate

// Return a selected candidate item number currently

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

//

TInt CAknFepUICtrlJapanesePredictivePane::CurrentItemIndexOfCandidate()

    {

    if (IsVisible())

        {

        CAknFepUICtrlJapanesePredictiveListbox* listBox =

            static_cast<CAknFepUICtrlJapanesePredictiveListbox*>(ListBox());

        return listBox->CurrentCandidateNo();

        }

    return -1;      // Disable window

    }

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

// CAknFepUICtrlJapanesePredictivePane::MoveItem

// Move a current item in an appointed direction

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

//

TInt CAknFepUICtrlJapanesePredictivePane::MoveItem(

        TAknFepUICtrlScroll aDirection)

    {

    __ASSERT_DEBUG(iListBox->IsVisible(),

                   AknFepUiInterfacePanic(EAknFepUiInterfacePanicNoCandidatePane));

    TInt ret = 0;

    switch(aDirection)

        {

        case EScrollLeft:

            ret = MovePreviousItem();

            break;

        case EScrollRight:

            ret = MoveNextItem();

            break;

        case EScrollUp:

            ret = MovePreviousLineItem();

            break;

        case EScrollDown:

            ret = MoveNextLineItem();

            break;

        default:

        //Panic

            AknFepUiInterfacePanic(EAknFepUiInterfacePanicCandidatePaneNotSupportScrollDirection);

            break;

        }

    return ret;

    }

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

// CAknFepUICtrlJapanesePredictivePane::SetupWindowLayout

// Set up a window layout type

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

//

void CAknFepUICtrlJapanesePredictivePane::SetupWindowLayout(

        AknPopupLayouts::TAknPopupLayouts /*aType*/)

    {

    HandleSizeChanged(Layout(), NULL, ListBox(), this);

    }

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

// CAknFepUICtrlJapanesePredictivePane::AttemptExitL

// Set the title for the selection list

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

//

void CAknFepUICtrlJapanesePredictivePane::AttemptExitL(TBool aAccept)

    {

    if (iReturn) //Always not null unless ExecuteLD leaves

        *iReturn = aAccept;

    }

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

// CAknFepUICtrlJapanesePredictivePane::MopSupplyObject

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

//

TTypeUid::Ptr CAknFepUICtrlJapanesePredictivePane::MopSupplyObject(TTypeUid aId)

    {

    SetMopParent( iEikonEnv->EikAppUi() );

    return CAknPopupList::MopSupplyObject(aId);

    }

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

// CAknFepUICtrlJapanesePredictivePane::CAknFepUICtrlJapanesePredictivePane

// Constructor

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

//

CAknFepUICtrlJapanesePredictivePane::CAknFepUICtrlJapanesePredictivePane(CAknFepUIManagerJapanese* aUiMng)

    : iUiMng(aUiMng)

    {

    }

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

// CAknFepUICtrlJapanesePredictivePane::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknFepUICtrlJapanesePredictivePane::ConstructL()

    {

    // Create listbox

    CAknFepUICtrlJapanesePredictiveListbox* list =

                new(ELeave) CAknFepUICtrlJapanesePredictiveListbox;

    // "iListBox" member variable is defined in CAknPopupList class.

    iListBox = list;

    CAknPopupList::ConstructL(

        list, R_AKNFEP_SOFTKEYS_CONVERT_OTHER_SELECT, AknPopupLayouts::EMenuWindow);

    list->ConstructL(this, CEikListBox::ELeftDownInViewRect);

    list->CreateScrollBarFrameL(ETrue);

    list->ScrollBarFrame()->SetScrollBarVisibilityL(

                                CEikScrollBarFrame::EOff,

                                CEikScrollBarFrame::EAuto);

    SetNonFocusing();

    MakeVisible(EFalse);

    iLineInfoArray = NULL;

    iListTextArray = NULL;

    }

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

// CAknFepUICtrlJapanesePredictivePane::CreatePredictivePopupLineInfoArrayL

// Create a array with line information in candidate list

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

CPredictivePopupLineInfoArray*

CAknFepUICtrlJapanesePredictivePane::CreatePredictivePopupLineInfoArrayL(

        CDesCArrayFlat* aItems,

        const TInt aMaxDisplayWidthInPixel,

        const TInt aFontId)

    {

    CPredictivePopupLineInfoArray* lineArray =

        new(ELeave) CPredictivePopupLineInfoArray(1);

    CleanupStack::PushL(lineArray);

    // getting font object from font id

    const CFont* font = AknLayoutUtils::FontFromId(aFontId);

    TInt displayWidthInPixel = aMaxDisplayWidthInPixel;

    TInt elementStartXPos = 0;

    TBuf<KMaxListColumns*2> bufferOfLine;

    CPredictivePopupElementArray* elementArray = NULL;

    const TInt widthOfSpaceInPixel = font->CharWidthInPixels(KSpaceCharCode);

    const TInt numberOfItem = aItems->Count();

    TInt i;

    for (i = 0; i < numberOfItem; i++)

        {

        TPtrC itemText = aItems->MdcaPoint(i);

        TInt itemTextLength = itemText.Length();

        // getting a number of characters within width

        TInt count = font->TextCount(itemText, displayWidthInPixel);

        // If a candidate cannot occupy a line, it is

        // continued in next line

        if (count < itemTextLength && elementArray)

            {

            PredictivePopupAppendLineL(lineArray, bufferOfLine, elementArray);

            CleanupStack::Pop(elementArray);    // elementArray

            elementArray = NULL;

            bufferOfLine.SetLength(0);

            displayWidthInPixel = aMaxDisplayWidthInPixel;

            elementStartXPos = 0;

            count = font->TextCount(itemText, displayWidthInPixel);

            }

        FOREVER

            {

            if (!elementArray)

                {

                elementArray = new(ELeave) CPredictivePopupElementArray(1);

                CleanupStack::PushL(elementArray);

                }

            TPtrC elementText = itemText.Left(count);

            TInt  elementWidthInPixels = font->TextWidthInPixels(elementText);

            // setting a item string to line string

            bufferOfLine.Append(elementText);

            displayWidthInPixel -= elementWidthInPixels;

            TPredictivePopupElement& element = elementArray->ExtendL();

            element.iStartXPos = elementStartXPos;

            elementStartXPos += elementWidthInPixels;

            element.iEndXPos   = elementStartXPos;

            element.iCandidateNo = i;

            // creating a string which removes a item string

            itemTextLength -= count;

            if (itemTextLength > 0)

                {

                // If this line is full, add this line and create a new line.

                PredictivePopupAppendLineL(lineArray, bufferOfLine, elementArray);

                CleanupStack::Pop(elementArray);    // elementArray

                elementArray = NULL;

                bufferOfLine.SetLength(0);

                itemText.Set(itemText.Right(itemTextLength));

                displayWidthInPixel = aMaxDisplayWidthInPixel;

                elementStartXPos = 0;

                // Calculating a number of characters which be able to shown in the width and

                // cutting the string

                count = font->TextCount(itemText, displayWidthInPixel);

                }

            else

                {

                break;

                }

            }

        if (displayWidthInPixel > widthOfSpaceInPixel)

            {

            // adding space if it is possible to add space

            bufferOfLine.Append(KSpaceCharCode);

            displayWidthInPixel -= widthOfSpaceInPixel;

            elementStartXPos    += widthOfSpaceInPixel;