/*

* Copyright (c) 2002-2005 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:  One rows list with icon for drop-down list objects

*

*/

// Include 

#include "peninputlistonerowwithouticon.h"

#include "peninputcandidate.h"

#include <peninputdropdownlistcontext.h>

#include <peninputdropdownlist.h>

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

// Implementation of Class CListOneRowWithoutIcon 

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

// CListOneRowWithoutIcon::CListOneRowWithoutIcon

// C++ default constructor can NOT contain any code, that

// might leave

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

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

//

CListOneRowWithoutIcon::CListOneRowWithoutIcon(CListManager* aManager, 

                                               MFepCtrlDropdownListContext* aOwner)

:CList(aManager, aOwner)

    {

    iIsMultiRows = EFalse;

    }

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

// CListOneRowWithoutIcon::NewL

// factory function

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

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

//

CListOneRowWithoutIcon* CListOneRowWithoutIcon::NewL(CListManager* aManager,

                                                     MFepCtrlDropdownListContext* aOwner)

    {

    CListOneRowWithoutIcon* self = new (ELeave) CListOneRowWithoutIcon(aManager, aOwner);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CListOneRowWithoutIcon::~CListOneRowWithoutIcon

// desstrutor function

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

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

//

CListOneRowWithoutIcon::~CListOneRowWithoutIcon()

    {   

    }

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

// CListOneRowWithoutIcon::HandlePointerDownL

// handle pointer down 

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

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

//

void CListOneRowWithoutIcon::HandlePointerDownL(const TPoint& aPoint)

    {    

    // Pass the event first to the base     

    CList::HandlePointerDownL(aPoint);

    }

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

// CListOneRowWithoutIcon::HandlePointerDragL

// handle pointer drag function

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

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

//

void CListOneRowWithoutIcon::HandlePointerDragL(const TPoint& aPoint)

    { 

    // Pass the event first to the base

    CList::HandlePointerDragL(aPoint);

    // If the mouse have click in the area of DDL

    if ( iIndicateButtonClicked )  

        {

        TInt index = -1;

        CCandidate* candidate = FindCandidate(aPoint, index);

        iMoveLatestRect = KEmptyRect;

        if ( candidate )

            {

            iMoveLatestRect.SetRect(candidate->GetRect().iTl, candidate->GetRect().Size());

            }          

        // Compare the two rect, then decide draw it or not

        CompareRect(iMoveLatestRect, iClickedRect);

        }

    }

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

// CListOneRowWithoutIcon::HandlePointerUpL

// handle pointer up function

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

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

//

void CListOneRowWithoutIcon::HandlePointerUpL(const TPoint& aPoint)

    {

    if ( !iClickedRect.IsEmpty() )

        {

        // Find out which rectangle was clicked and save it for 

        // later usage (HandlePointerUpL)

        if ( iContentRect.Contains( aPoint ) )

            {

            if ( iClickedRect.Contains( aPoint ) )

                {

                if ( iClickedCandidateIndex != KErrNotFound )

                    {

                    // Redraw the selection rect  

                    DrawSelection( iClickedRect, EFalse );

                    // We have selected a candidate

                    // Send message to plugin         

                    CCandidate* candidate = iOwner->GetCandidate(iClickedCandidateIndex);

                    if ( candidate )

                        {

                        iOwner->ReportCandidateSelectEventL(candidate->GetCandidate(),

                                                           iClickedCandidateIndex); 

                        }

                    }                

               }

            iIndicateButtonClicked = EFalse;

            }

        iClickedRect = KEmptyRect;               

        }

    }

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

// CListOneRowWithoutIcon::Draw

// draw the list

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

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

//

void CListOneRowWithoutIcon::Draw()

    {

    CList::Draw();

    // Draw all visible candidates

    DrawCandidates();

    DrawSelection(iClickedRect, ETrue);

    }

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

// CListOneRowWithoutIcon::CalculateAreas

// Calculate all kinds of rectangles

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

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

//

void CListOneRowWithoutIcon::CalculateAreas()

    {

    // Calculate the rect of the list

    iRect.iTl = iOwner->GetTopLeftPoint();

    TInt width = iOwner->GetCellWidth() * iOwner->GetColNum() + iOwner->GetNaviWidth() + 

                 (iOwner->GetColNum() + 2) * iOwner->GetCellHorizontalMargin();

    TInt height = iOwner->GetCellHeight() + 2 * iOwner->GetCellVerticalMargin();                 

    iRect.SetSize(TSize(width,height));

    // Calculate the rect of the content

    iContentRect.iTl = TPoint(iRect.iTl.iX + iOwner->GetCellHorizontalMargin(),

                              iRect.iTl.iY + iOwner->GetCellVerticalMargin());

    iContentRect.SetSize(TSize(width - 2 * iOwner->GetCellHorizontalMargin(),

                               iOwner->GetCellHeight()));

    // Calculate the rect of the navigation area

    iNavigationRect = TRect(0,0,0,0);

    // Calculate the rect of the down button

    iNavigationNextRect = TRect(0,0,0,0);

    // Calculate the rect of the up button

    iNavigationPreviousRect = TRect(0,0,0,0);

    }

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

// CListOneRowWithoutIcon::CalculatePositionsL

// calculate the position of all visible cells in the list

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

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

//

TInt CListOneRowWithoutIcon::CalculatePositionsL()

    {

    TInt t = 0;

    TPoint setpoints;

    const TInt count = iOwner->CandidateCount();

    // First store the last index

    iOwner->SetFirstCandidateIndex ( iOwner->GetLastCandidateIndex() );        

    if ( count > 0 )

        {

        // Initial the position to iContentRect

        /*

        setpoints.iX = iContentRect.iTl.iX;

        setpoints.iY = iContentRect.iTl.iY;

        */

        TBool candHLToR = (iOwner->CandHDirection() == CFepCtrlDropdownList::ECandFromLToR);

        candHLToR ? setpoints.SetXY(iContentRect.iTl.iX, iContentRect.iTl.iY) :

                    setpoints.SetXY(iContentRect.iBr.iX, iContentRect.iTl.iY);

        TInt cellNumberInOneRow = iOwner->GetColNum() + 1;

        TInt lastUsedCellCount = 0;

        TInt currentCellIndex = 0;

        TInt newCount = 0;

        newCount = Min(count,iOwner->GetLastCandidateIndex() + cellNumberInOneRow);   

        for( t = iOwner->GetLastCandidateIndex(); t < newCount ; t++ )

            {

            // setting a position for this candidate 

            CCandidate* candidate = iOwner->GetCandidate(t);

            if ( !candidate )

                {

                continue;

                }

            lastUsedCellCount = candidate->SetPositionL(setpoints,

                                                        iOwner->GetCellWidth(),

                                                        iOwner->GetCellHeight(),

                                                        iOwner->GetFont(),

                                                        iOwner->GetCellHorizontalMargin()); 

            currentCellIndex += lastUsedCellCount;

            if ( currentCellIndex > ( iOwner->GetColNum() + 1 ) )

                {

                // If no space to contain other cells 

                break;

                }

            // Recalcuate the x position

            candHLToR? (setpoints.iX += (iOwner->GetCellWidth() + iOwner->GetCellHorizontalMargin()) * lastUsedCellCount) : 

                       (setpoints.iX -= (iOwner->GetCellWidth() + iOwner->GetCellHorizontalMargin()) * lastUsedCellCount);

            } // for-loop

        } // if candidate exist 

    return t; // as lastCandidateIndex

    }

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

// CListOneRowWithoutIcon::UpdateList

// update the list

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

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

//

void CListOneRowWithoutIcon::UpdateListL(TBool aDrawFlag, TBool aRecalculate)

    {

    if ( aRecalculate )

        {

        // Recalculate the position of all candidates

        iOwner->SetLastCandidateIndex(CalculatePositionsL());    

        }

    if(aDrawFlag)    

        {

        Draw();

        iOwner->Invalidate(iRect);

        }

    }

// End Of File