/*

* 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:            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 <AknLayout.lag>

#include <skinlayout.cdl.h>

#include <AknLayout2ScalableDef.h>

#include <aknlayoutscalable_avkon.cdl.h>

#include <layoutmetadata.cdl.h>

#include "AknFepUiInterfacePanic.h"

#include "AknFepUIAvkonCtrlJapaneseCandidateListbox.h"

#include "AknFepUIAvkonCtrlJapaneseCandidateHeadingPane.h"

#include "AknFepUIAvkonCtrlJapaneseCandidatePane.h"

#include "AknFepUIManagerJapanese.h"

// CONSTANTS

const TInt KMaxTitleLength = 32;

const TInt KMaxListRows = 7;

const TInt KMinListRows = 5;

const TInt KMaxListColumns = 9;

const TInt KMinListColumns = 3;

const TInt KLAFBaseListColumns = 3;

const TInt KLAFBaseListRows = 1;

const TInt KLAFBelowTextBaseline = 2;

const TInt KLAFAboveTextBaseline = 1;

const TInt KListboxMarge = 4;

/**

*  CAknFepUICtrlJapaneseCandidatePane class.

*

*/

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

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

// CAknFepUICtrlJapaneseCandidatePane::NewL

// Two-phased constructor.

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

//

CAknFepUICtrlJapaneseCandidatePane* CAknFepUICtrlJapaneseCandidatePane::NewL(CAknFepUIManagerJapanese* aUiMng)

    {

    CAknFepUICtrlJapaneseCandidatePane* self =

        new(ELeave) CAknFepUICtrlJapaneseCandidatePane(aUiMng);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);    // self

    return self;

    }

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

// CAknFepUICtrlJapaneseCandidatePane::~CAknFepUICtrlJapaneseCandidatePane

// Destructor

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

//

CAknFepUICtrlJapaneseCandidatePane::~CAknFepUICtrlJapaneseCandidatePane()

    {

    if (IsVisible())

        {

        HideWindow();

        }

    if (iListBox)

        {

        delete iListBox;

        iListBox = NULL;

        }

    }

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

// CAknFepUICtrlJapaneseCandidatePane::ShowWindow

// Show Pop-up list

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

//

void CAknFepUICtrlJapaneseCandidatePane::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();

    }

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

// CAknFepUICtrlJapaneseCandidatePane::CloseCandidateList

// Close Pop-up list

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

//

void CAknFepUICtrlJapaneseCandidatePane::CloseCandidateList()

    {

    CancelPopup();

    }

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

// CAknFepUICtrlJapaneseCandidatePane::SetCurrentItemIndex

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

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

//

void CAknFepUICtrlJapaneseCandidatePane::SetCurrentItemIndexL(

        TInt aItemIndex,

        TBool aDraw)

    {

    CTextListBoxModel* model =

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

    TInt numOfItem = model->NumberOfItems();

    TBuf<KMaxTitleLength> title;

    title.Format(_L("%d / %d"), aItemIndex + 1, numOfItem);

    SetTitleL(title);

    if (aDraw)

        {

        iListBox->SetCurrentItemIndexAndDraw(aItemIndex);

        iTitle->DrawNow();

        }

    else

        {

        iListBox->SetCurrentItemIndex(aItemIndex);

        }

    }

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

// CAknFepUICtrlJapaneseCandidatePane::SetOffsetPosition

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

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

//

void CAknFepUICtrlJapaneseCandidatePane::SetOffsetPosition(TPoint aOffset)

    {

    iOffsetPosition = aOffset;

    }

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

// CAknFepUICtrlJapaneseCandidatePane::SetWindowPosition

// Set the drawing position for candidate list popup window

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

//

void CAknFepUICtrlJapaneseCandidatePane::SetWindowPosition(

        const TPoint& aLeftSideOfBaseLine, TInt aHeight, TInt aAscent)

    {

    // getting rectangle for 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;

    }

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

// CAknFepUICtrlJapaneseCandidatePane::ShowCandidateListL

// Show Pop-up list

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

//

void CAknFepUICtrlJapaneseCandidatePane::ShowCandidateListL(

        CDesCArrayFlat* aItems, TInt aIndex, TInt aResourceID)

    {

    __ASSERT_DEBUG(aItems->Count() > 0,

                   AknFepUiInterfacePanic(EAknFepUiInterfacePanicCandidatesEmpty));

    // Set listitems.

    CTextListBoxModel* model =

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

    model->SetItemTextArray(aItems);

    model->SetOwnershipType(ELbmDoesNotOwnItemArray);

    iMaximumColumns = MaximumColumns(model);

    iMaximumRows    = MaximumRows(model);

    SetCurrentItemIndexL(aIndex, EFalse);

    SetMaximumHeight(iMaximumRows);

    CAknFepUICtrlJapaneseCandidateListbox* listBox =

        static_cast<CAknFepUICtrlJapaneseCandidateListbox*>(ListBox());

    listBox->SetMaximumColumns(iMaximumColumns);

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

    iPopoutCba->MakeVisible(ETrue);

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

        }

    }

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

// CAknFepUICtrlJapaneseCandidatePane::HideWindow

// Hide Pop-up list

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

//

void CAknFepUICtrlJapaneseCandidatePane::HideWindow()

    {

    MakeVisible(EFalse);

    Window().SetPointerCapture(EFalse);

    iEikonEnv->RemoveFromStack(iPopoutCba);

    iPopoutCba->MakeVisible(EFalse);

    }

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

// CAknFepUICtrlJapaneseCandidatePane::CurrentItemIndexOfCandidate

// Return a selected candidate item number currently

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

//

TInt CAknFepUICtrlJapaneseCandidatePane::CurrentItemIndexOfCandidate()

    {

    return iListBox->CurrentItemIndex();

    }

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

// CAknFepUICtrlJapaneseCandidatePane::MoveItem

// Move a current item in an appointed direction

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

//

TInt CAknFepUICtrlJapaneseCandidatePane::MoveItem(

        TAknFepUICtrlScroll aDirection)

    {

    __ASSERT_DEBUG(iListBox->IsVisible(),

                   AknFepUiInterfacePanic(EAknFepUiInterfacePanicNoCandidatePane));

    TInt index = iListBox->CurrentItemIndex();

    CTextListBoxModel* model =

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

    const TInt numberOfItems = model->NumberOfItems();

    switch(aDirection)

        {

        case EScrollUp:

            {

            --index;

            if (index < 0)

                index = numberOfItems - 1;

            }

        break;

        case EScrollDown:

            {

            ++index;

            if (index >= numberOfItems)

                index = 0;

            }

        break;

        default:

            {

            //Panic

            AknFepUiInterfacePanic(EAknFepUiInterfacePanicCandidatePaneNotSupportScrollDirection);

            }

        break;

        }

    TRAPD(err, SetCurrentItemIndexL(index, ETrue));

    if (err != KErrNone)

        {

        HideWindow();

        index = 0;

        }

    return index;

    }

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

// CAknFepUICtrlJapaneseCandidatePane::SetupWindowLayout

// Set up a window layout type

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

//

void CAknFepUICtrlJapaneseCandidatePane::SetupWindowLayout(

        AknPopupLayouts::TAknPopupLayouts /*aType*/)

    {

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

    }

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

// CAknFepUICtrlJapaneseCandidatePane::AttemptExitL

// Set the title for the selection list

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

//

void CAknFepUICtrlJapaneseCandidatePane::AttemptExitL(TBool aAccept)

    {

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

        *iReturn = aAccept;

    }

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

// CAknFepUICtrlJapaneseCandidatePane::MopSupplyObject

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

//

TTypeUid::Ptr CAknFepUICtrlJapaneseCandidatePane::MopSupplyObject(TTypeUid aId)

    {

    SetMopParent( iEikonEnv->EikAppUi() );

    return CAknPopupList::MopSupplyObject(aId);

    }

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

// CAknFepUICtrlJapanesePredictivePane::CAknFepUICtrlJapanesePredictivePane

// Constructor

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

//

CAknFepUICtrlJapaneseCandidatePane::CAknFepUICtrlJapaneseCandidatePane(CAknFepUIManagerJapanese* aUiMng)

    : iUiMng(aUiMng)

    {

    }

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

// CAknFepUICtrlJapaneseCandidatePane::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CAknFepUICtrlJapaneseCandidatePane::ConstructL()

    {

    // Create listbox.

    CAknFepUICtrlJapaneseCandidateListbox* list =

                new(ELeave) CAknFepUICtrlJapaneseCandidateListbox;

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

    iListBox = list;

    CAknPopupList::ConstructL(

        iListBox, R_AKNFEP_SOFTKEYS_EMPTY_EMPTY_COMMIT, AknPopupLayouts::EMenuWindow);

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

    list->CreateScrollBarFrameL(ETrue);

    list->ScrollBarFrame()->SetScrollBarVisibilityL(

                                CEikScrollBarFrame::EOff,

                                CEikScrollBarFrame::EAuto);

    iEikonEnv->RemoveFromStack(this);

    SetNonFocusing();

    MakeVisible(EFalse);

    }

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

// CAknFepUICtrlJapaneseCandidatePane::SetTitleL

// Set the title for the selection list

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

//

void CAknFepUICtrlJapaneseCandidatePane::SetTitleL(const TDesC& aTitle)

    {

    if (!iTitle)

        {

        iTitle = new(ELeave) CAknFepUICtrlJapaneseCandidateHeadingPane;

        iTitle->SetContainerWindowL(*this);

        iTitle->ConstructL(aTitle);

        iTitle->SetMopParent(iListBox);

        }

    else

        {

        iTitle->SetTextL(aTitle);

        }

    }

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

// CAknFepUICtrlJapaneseCandidatePane::HandleSizeChanged

// The handler function for size change

// Original function is AknPopupLayouts::HandleSizeChanged()

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

//

void CAknFepUICtrlJapaneseCandidatePane::HandleSizeChanged(

        TAknPopupWindowLayoutDef &aDef,

        CAknPopupHeadingPane *aHeading,

        CEikListBox *aListBox,

        CCoeControl *aWindowOwningControl)

    {

    if ( aHeading )

        {

        aHeading->SetLayout( CAknPopupHeadingPane::EListHeadingPane );

        aHeading->SetSkinFrameId(TAknsItemID());

        aHeading->SetSkinFrameCenterId(TAknsItemID());

        }

    TInt numofitems = aListBox->Model()->NumberOfItems();

    TInt minItems = iMaximumRows;

    TInt maxItems = KMaxListRows;

    if (aDef.iMaximumHeight)

        {

        maxItems = aDef.iMaximumHeight;

        }

    AknPopupLayouts::CheckRange(numofitems, minItems, maxItems);

    CalcPopupMenuWindow(aDef, iMainPaneRect, numofitems);

    SetupMenuPopupWindow(aDef, numofitems, aHeading != 0);

    CAknFepUICtrlJapaneseCandidateListbox* listbox =

        static_cast<CAknFepUICtrlJapaneseCandidateListbox*>(aListBox);

    listbox->SetMaximumColumns(iMaximumColumns);

    listbox->SetMaximumRows(iMaximumRows);

    SetMaximumHeight(iMaximumRows);

    aWindowOwningControl->SetRect(AknPopupLayouts::WindowRect(aDef));

    HandleSizeAndPositionOfComponents(aDef, aListBox, aHeading);

    TRect windowRect = AknPopupLayouts::WindowRect(aDef);

    MAknsControlContext *cc = AknsDrawUtils::ControlContext( aListBox );

    TBool defaultContext = EFalse;

    if (!cc)

        {

        cc = aListBox->View()->ItemDrawer()->SkinBackgroundControlContext();

        defaultContext = ETrue;

        }

    if (cc)

        {

        CAknsBasicBackgroundControlContext *bcc =

            (CAknsBasicBackgroundControlContext*)cc;

        TAknLayoutRect popupBgRect;

        popupBgRect.LayoutRect(

            windowRect,

            ELayoutEmpty,

            0, 0, ELayoutEmpty, ELayoutEmpty,

            windowRect.Size().iWidth, windowRect.Size().iHeight);

        bcc->SetBitmap(KAknsIIDQsnFrPopupCenter);

        if (defaultContext)

            {

            bcc->SetRect(popupBgRect.Rect());

            }

        bcc->SetParentPos(aWindowOwningControl->PositionRelativeToScreen());

        if (defaultContext)

            {

            bcc->SetParentPos(TPoint(0,0));

            }

        }

     }

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

// CAknFepUICtrlJapaneseCandidatePane::HandleDraw

// The handler function for Draw

// Original function is AknPopupLayouts::HandleDraw()

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

//

void CAknFepUICtrlJapaneseCandidatePane::HandleDraw(CEikonEnv* /*aEikEnv*/,

                  CWindowGc& aGc,

                  const TAknPopupWindowLayoutDef& aDef,

                  CEikListBox* aListBox,

                  CAknPopupHeadingPane* aHeading)

    {

    TRect windowRect =

        AknPopupLayouts::MenuRect(const_cast<TAknPopupWindowLayoutDef&>(aDef));

    MAknsSkinInstance *skin = AknsUtils::SkinInstance();

    MAknsControlContext *cc = AknsDrawUtils::ControlContext( aListBox );

    TBool windowFrameDrawn = EFalse;

    if (!cc)

        {

        cc = aListBox->View()->ItemDrawer()->SkinBackgroundControlContext();

        }

    if (cc)

        {

		TRegionFix<2> dontDrawRegion;