/*

* 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:  Multi rows list with icon for drop-down list objects

*

*/

// Include 

#include <fbs.h>

#include <AknsUtils.h>

#include <AknLayoutDef.h>

#include <peninputdropdownlistcontext.h>

#include <peninputdropdownlist.h>

#include <AknsDrawUtils.h> 

#include "peninputlistmultirowwithicon.h"

#include "peninputlayout.h"

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

// Implementation of Class CListMultiRowWithIcon 

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

// CListMultiRowWithIcon::CListMultiRowWithIcon

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

// might leave

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

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

//

CListMultiRowWithIcon::CListMultiRowWithIcon(CListManager* aManager, 

                                             MFepCtrlDropdownListContext *aOwner)

: CList(aManager, aOwner)

    {

    iIsMultiRows = ETrue; 

    }

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

// CListMultiRowWithIcon::NewL

// factory function

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

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

//

CListMultiRowWithIcon* CListMultiRowWithIcon::NewL(CListManager* aManager, 

                                                   MFepCtrlDropdownListContext *aOwner)

    {

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CListMultiRowWithIcon::~CListMultiRowWithIcon

// desstrutor function

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

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

//

CListMultiRowWithIcon::~CListMultiRowWithIcon()

    {     

    }

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

// CListMultiRowWithIcon::HandlePointerDownL

// handle pointer down 

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

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

//

void CListMultiRowWithIcon::HandlePointerDownL(const TPoint& aPoint)

    {

    CList::HandlePointerDownL(aPoint);

    // also consider fuzzy boundry of drop down list

    TRect fuzzyrect = iRect;

    fuzzyrect.Grow(iOwner->FuzzyBoundry(), iOwner->FuzzyBoundry());

    if (!fuzzyrect.Contains(aPoint))

        {

        iOwner->SetCapture(EFalse);

        iOwner->AutoChangeActiveList(iOwner->GetFirstCandidateIndex());

        return;

        }

    // If click in navigation rect and NextButton is not disable, then do 

    if ( iNavigationRect.Contains(aPoint) )

        {   

        if ( iNavigationCloseRect.Contains(aPoint) && !iCloseButtonDisable )

            {

			#ifdef RD_TACTILE_FEEDBACK

	        static_cast<CFepCtrlDropdownList*>(iOwner)->UiLayout()->

	            DoTactileFeedback(ETouchFeedbackBasic);

			#endif //RD_TACTILE_FEEDBACK 

            iClickedRect.SetRect(iNavigationCloseRect.iTl, iNavigationCloseRect.iBr);

            iIndicateButtonClicked = ETrue;

            DrawSelection(iClickedRect, ETrue);                

            }  

        else if (!iOwner->PageCtrlShown())

            {

            iClickedRect = KDummyRect;

            return;

            }

        else if ( iNavigationPreviousRect.Contains(aPoint) && !iPreviousButtonDisable )

            {

			#ifdef RD_TACTILE_FEEDBACK

            static_cast<CFepCtrlDropdownList*>(iOwner)->UiLayout()->

	            DoTactileFeedback(ETouchFeedbackBasic);

			#endif //RD_TACTILE_FEEDBACK 

            iClickedRect.SetRect(iNavigationPreviousRect.iTl, iNavigationPreviousRect.iBr);

            iIndicateButtonClicked = ETrue;

            DrawSelection(iClickedRect, ETrue);                

            }

        else if ( iNavigationNextRect.Contains(aPoint) && !iNextButtonDisable )

            {

			#ifdef RD_TACTILE_FEEDBACK

            static_cast<CFepCtrlDropdownList*>(iOwner)->UiLayout()->

            	            DoTactileFeedback(ETouchFeedbackBasic);    

			#endif //RD_TACTILE_FEEDBACK  

            iClickedRect.SetRect(iNavigationNextRect.iTl, iNavigationNextRect.iBr);

            iIndicateButtonClicked = ETrue;

            DrawSelection(iClickedRect, ETrue);                

            }

        else

            {

            iClickedRect = KDummyRect;                                

            }

        }

    }

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

// CListMultiRowWithIcon::HandlePointerDragL

// handle pointer drag function

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

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

//

void CListMultiRowWithIcon::HandlePointerDragL(const TPoint& aPoint)

    {

    // Pass the event first to the base

    CList::HandlePointerDragL(aPoint);

    if ( !iClickedRect.IsEmpty() )  // clicked rect is not outside the whole DDL

        {        

        TInt index = -1;

        CCandidate* candidate = FindCandidate(aPoint, index);

        iMoveLatestRect = KEmptyRect;

        if ( candidate )

            {

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

            }

        else if ( iNavigationRect.Contains(aPoint) )

            {

            if ( iNavigationCloseRect.Contains(aPoint) && !iCloseButtonDisable )

                {

                iMoveLatestRect.SetRect(iNavigationCloseRect.iTl, iNavigationCloseRect.iBr);

                }

            else if (!iOwner->PageCtrlShown())

                {

                return;

                }

            else if ( iNavigationPreviousRect.Contains(aPoint) && !iPreviousButtonDisable )

                {

                iMoveLatestRect.SetRect(iNavigationPreviousRect.iTl, iNavigationPreviousRect.iBr);

                }

            else if ( iNavigationNextRect.Contains(aPoint) && !iNextButtonDisable )

                {

                iMoveLatestRect.SetRect(iNavigationNextRect.iTl, iNavigationNextRect.iBr);

                }

            }

        CompareRect(iMoveLatestRect, iClickedRect);                                    

        }

    }

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

// CListMultiRowWithIcon::HandlePointerUpL

// handle pointer up function

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

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

//

void CListMultiRowWithIcon::HandlePointerUpL(const TPoint& aPoint)

    {  

    // Reset the button clicked flag to EFalse

    iIndicateButtonClicked = EFalse;

#ifdef __WINS__

    // in emulator, double click will be treated as:

    // 1 pointer down and 2 pointer up, which will cause error

    if (iClickedRect.IsEmpty() && ((CFepUiBaseCtrl*)iOwner)->PointerDown()) 

#else

    if (iClickedRect.IsEmpty())

#endif // __WINS__

        {

        iOwner->SetCapture(EFalse);

        // Change active list object ie. close the dd-list

        iOwner->AutoChangeActiveList( iOwner->GetFirstCandidateIndex() );

        }

    else

        {

        if ( iContentRect.Contains(aPoint) )

            {

            if ( iClickedRect.Contains(aPoint) )

                {

                // Redraw the selected aread    

                DrawSelection(iClickedRect, EFalse);

                iOwner->SetCapture(EFalse);

                // We have selected a candidate and iClickedCandidateIndex is the selected Index.

                // Send the candidate to others

                if (iClickedCandidateIndex != KErrNotFound)

                    {

			        iOwner->AutoChangeActiveList( iOwner->GetFirstCandidateIndex() );

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

                    if ( candidate )

                        {

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

                                                           iClickedCandidateIndex);

                        }

                    }

                }

            }

        else if ( iNavigationCloseRect.Contains(aPoint) )

            {

            if ( iNavigationCloseRect == iClickedRect )

                {

                iOwner->SetCapture(EFalse);

		        iOwner->AutoChangeActiveList(iOwner->GetFirstCandidateIndex());

                }

            }

        else if (!iOwner->PageCtrlShown())

            {

            iClickedRect = KEmptyRect;

            return;

            }

        else if ( iNavigationNextRect.Contains(aPoint) )

            {

            if ( iNavigationNextRect == iClickedRect )

                {

                iOwner->NotifyGetNextPage();

                UpdateListL();

                }

            }

        else if ( iNavigationPreviousRect.Contains(aPoint) )

            {

            if ( iNavigationPreviousRect == iClickedRect )

                {

                // Change page to previous

                iOwner->NotifyGetPreviousPage(); // do nothing, just to avoid clear candidate

                TInt firstIndex = 0;

                TInt lastIndex = 0;

                if (iOwner->GetPages()->GetPreviousIndex(iOwner->GetLastCandidateIndex(), 

                                                         firstIndex,lastIndex))    

                    {

                    iOwner->SetFirstCandidateIndex(firstIndex);

                    iOwner->SetLastCandidateIndex(lastIndex);

                    }

                UpdateListL(ETrue, EFalse);

                }             

            }

       	iClickedRect =  KEmptyRect;

        }

    }

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

// CListMultiRowWithIcon::Draw

// draw the list

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

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

//

void CListMultiRowWithIcon::Draw()

    {

    // Call draw in base class;

    CList::Draw();

    DrawCandidates();

	const CFbsBitmap* bitmapBg = iOwner->GetBitmapDb()->GetBitMap(CBitmapDb::EBitmapListBg);

	const CFbsBitmap* bitmapBgMask = iOwner->GetBitmapDb()->GetBitMap(CBitmapDb::EBitmapListBgMask);

    if (!bitmapBg || !bitmapBgMask)

    	{

	    iOwner->Gc()->SetPenSize(iOwner->GetPenSize());

	    if ((iOwner->GetCellHorizontalMargin() == 0) && (iOwner->GetCellVerticalMargin() == 0))

	        {

	        iOwner->Gc()->SetPenStyle(CGraphicsContext::ESolidPen);

	        }

	    else

	        {

	        iOwner->Gc()->SetPenStyle(CGraphicsContext::ENullPen);

	        }

	    iOwner->Gc()->SetPenColor(iOwner->GetBorderColor());

	    iOwner->Gc()->SetBrushColor(iOwner->GetBgColor());

	    iOwner->Gc()->SetBrushStyle( CGraphicsContext::ESolidBrush );                

	    // Draw the rect for navi

	    iOwner->Gc()->DrawRect(iNavigationRect);

    	}

    else

    	{

        iOwner->Gc()->DrawBitmapMasked(iNavigationRect, bitmapBg, 

                                       bitmapBg->SizeInPixels(), bitmapBgMask, ETrue);        

    	}

    iOwner->Gc()->SetPenStyle(CGraphicsContext::ESolidPen);

    // First draw down button

    if ( iBButtonClose )

        {

	    //mask bitmaps

	    TRect rect = iNavigationCloseRect;   

	    if (iDropdownListDrawInfo.iSupportSkin)

	    	{

		    TRect innerRect = rect;

		    innerRect.Shrink( 4, 4 );

		    // ----- draw bitmaps -----

			AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), 

				                      *iOwner->Gc(), 

				                      rect, 

				                      innerRect,

				                      iDropdownListDrawInfo.iNormalBtnImgID,

				                      KAknsIIDDefault ); 

		    iBButtonMaskClose = iOwner->GetBitmapDb()->GetBitMap(CBitmapDb::EBitmapCloseMask);   

			TRect srcRect( TPoint( 0, 0 ), iBButtonClose->SizeInPixels() );

			iOwner->Gc()->BitBltMasked( iNavigationCloseRect.iTl, 

							            iBButtonClose, 

									    srcRect,

									    iBButtonMaskClose,

									    EFalse);	       

	    	}

        else 

        	{

	        // Draw the rect for navi next

	        iOwner->Gc()->DrawLine(TPoint(iNavigationCloseRect.iTl.iX, iNavigationCloseRect.iBr.iY),

	                               iNavigationCloseRect.iBr);

	        if (iOwner->GetCellHorizontalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(iNavigationCloseRect.iTl, 

	                                   TPoint(iNavigationCloseRect.iTl.iX, 

	                                          iNavigationCloseRect.iBr.iY));

	            iOwner->Gc()->DrawLine(TPoint(iNavigationCloseRect.iBr.iX, 

	                                          iNavigationCloseRect.iTl.iY),

	                                   iNavigationCloseRect.iBr);                       

	            }

	        if (iOwner->GetCellVerticalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(iNavigationCloseRect.iTl, 

	                                   TPoint(iNavigationCloseRect.iBr.iX, 

	                                          iNavigationCloseRect.iTl.iY));

	            }

	        rect.Shrink(TSize(1,1));

	        rect.iBr.iY = rect.iBr.iY + 1;

	        if (iOwner->GetCellHorizontalMargin() != 0)

	            {

	            rect.iBr.iX = rect.iBr.iX + 1;

	            }

	        iOwner->Gc()->DrawBitmapMasked(rect, iBButtonClose, 

	                                       iBButtonClose->SizeInPixels(), iBButtonMaskClose, ETrue);

        	}

        }

    if (!iOwner->PageCtrlShown())

        {

        iOwner->Invalidate(iRect);

        return;

        }

    // First draw down button

    if ( iBButtonDown )

        {

	    //mask bitmaps

	    TRect rect = iNavigationNextRect;

	    if (iDropdownListDrawInfo.iSupportSkin)

	    	{

		    TRect innerRect = rect;

		    innerRect.Shrink( 4, 4 );

		    // ----- draw bitmaps -----

			AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), 

		                     *iOwner->Gc(), 

		                     rect, 

		                     innerRect,

		                     iDropdownListDrawInfo.iNormalBtnImgID,

		                     KAknsIIDDefault ); 

		    iBButtonMaskDown = iOwner->GetBitmapDb()->GetBitMap(CBitmapDb::EBitmapNextMask);   

			TRect srcRect( TPoint( 0, 0 ), iBButtonDown->SizeInPixels() );

			iOwner->Gc()->BitBltMasked( iNavigationNextRect.iTl, 

									    iBButtonDown, 

									    srcRect,

									    iBButtonMaskDown,

									    EFalse);	    

	    	}

		else

			{

	        // Draw the rect for navi next

	        iOwner->Gc()->DrawLine(iNavigationNextRect.iTl,

	                               TPoint(iNavigationNextRect.iBr.iX, iNavigationNextRect.iTl.iY));

	        if (iOwner->GetCellHorizontalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(iNavigationNextRect.iTl, 

	                                  TPoint(iNavigationNextRect.iTl.iX, iNavigationNextRect.iBr.iY));

	            iOwner->Gc()->DrawLine(TPoint(iNavigationNextRect.iBr.iX, iNavigationNextRect.iTl.iY),

	                                   iNavigationNextRect.iBr);

	            }

	        if (iOwner->GetCellVerticalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(TPoint(iNavigationNextRect.iTl.iX, iNavigationNextRect.iBr.iY),

	                                   iNavigationNextRect.iBr);

	            }

	        rect.Shrink(TSize(1,1));               

	        if (iOwner->GetCellHorizontalMargin() != 0)

	            {

	            rect.iBr.iX = rect.iBr.iX + 1;

	            }

	        if (iOwner->GetCellVerticalMargin() != 0)

	            {

	            rect.iBr.iY = rect.iBr.iY + 1;

	            }

	        iOwner->Gc()->DrawBitmapMasked(rect, iBButtonDown, 

	                                       iBButtonDown->SizeInPixels(), iBButtonMaskDown, ETrue);				

			}

        }

    // Second draw up button

    if ( iBButtonUp )

        {

	    //mask bitmaps

	    TRect rect = iNavigationPreviousRect;

	    if (iDropdownListDrawInfo.iSupportSkin)

	    	{

		    TRect innerRect = rect;

		    innerRect.Shrink( 4, 4 );

		    // ----- draw bitmaps -----

			AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(), 

		                     *iOwner->Gc(), 

		                     rect, 

		                     innerRect,

		                     iDropdownListDrawInfo.iNormalBtnImgID,

		                     KAknsIIDDefault ); 

		    iBButtonMaskUp = iOwner->GetBitmapDb()->GetBitMap(CBitmapDb::EBitmapPreviousMask);   

			TRect srcRect( TPoint( 0, 0 ), iBButtonMaskUp->SizeInPixels() );

			iOwner->Gc()->BitBltMasked( iNavigationPreviousRect.iTl, 

									    iBButtonUp, 

									    srcRect,

									    iBButtonMaskUp,

									    EFalse);	    

	    	}

		else

			{

	        // Draw the rect for navi next

	        iOwner->Gc()->DrawLine(TPoint(iNavigationPreviousRect.iTl.iX, 

	                                      iNavigationPreviousRect.iBr.iY),

	                               iNavigationPreviousRect.iBr );

	        if (iOwner->GetCellHorizontalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(iNavigationPreviousRect.iTl, 

	                         TPoint(iNavigationPreviousRect.iTl.iX, iNavigationPreviousRect.iBr.iY));

	            iOwner->Gc()->DrawLine(

	                         TPoint(iNavigationPreviousRect.iBr.iX, iNavigationPreviousRect.iTl.iY),

	                                iNavigationPreviousRect.iBr);

	            }

	        if (iOwner->GetCellVerticalMargin() != 0)

	            {

	            iOwner->Gc()->DrawLine(iNavigationPreviousRect.iTl, 

	                         TPoint(iNavigationPreviousRect.iBr.iX, iNavigationPreviousRect.iTl.iY));

	            }

	        rect.Shrink(TSize(1,1));                

	        if (iOwner->GetCellHorizontalMargin() != 0)