/*
* Copyright (c) 2005-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:  Implementation for avkon based choice list control
*
*/


#include "peninputlayoutaknchoicelist.h"
#include "peninputlayout.h"

#include <avkon.hrh> // AknButton flags
#include <AknsConstants.h>
//#include <avkon.mbg>

#include <eikclbd.h>
#include <eiklbx.h>
#include <eikscrlb.h>

#include <AknLayout2ScalableDef.h>
#include <aknlayoutscalable_avkon.cdl.h>

#include <AknsFrameBackgroundControlContext.h> 



const TInt KMaxTxtLen = 256;

NONSHARABLE_CLASS(CPenUiScrolbarCtrl) : public CFepUiBaseCtrl
    {
    public:
        CPenUiScrolbarCtrl(CCoeControl* aCtrl, CFepUiLayout* aLayout);
        void ConstructL();         
    };

CPenUiScrolbarCtrl::CPenUiScrolbarCtrl(CCoeControl* aCtrl, CFepUiLayout* aLayout)
                : CFepUiBaseCtrl(aCtrl,aLayout,EFalse)
    {
    }

void CPenUiScrolbarCtrl::ConstructL()
    {
    BaseConstructL();
    }
    
// implementation for class     CFepLayoutAknChoiceList
EXPORT_C  CFepLayoutAknChoiceList* CFepLayoutAknChoiceList::NewL(CFepUiLayout* aUiLayout,
                    TInt aControlId,CCoeControl* aParent)
    {
    CFepLayoutAknChoiceList* self = new (ELeave) CFepLayoutAknChoiceList(aUiLayout,
                                                                         aControlId,aParent);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;        
    }

EXPORT_C CFepLayoutAknChoiceList::CFepLayoutAknChoiceList(CFepUiLayout* aUiLayout, 
                                  TInt aControlId,CCoeControl* aParent)
                                  : CFepLayoutChoiceList(aUiLayout,aControlId)
    {
    iParent = aParent;
    }

EXPORT_C CFepLayoutAknChoiceList::~CFepLayoutAknChoiceList()
    {
    delete iScrollbarCtrl;
    delete iTxtTransferBuf;
    delete iBgContext;
    }
    
EXPORT_C void CFepLayoutAknChoiceList::ConstructL()
    {    
    CFepLayoutChoiceList::ConstructL();

    iListBox = new(ELeave) CAknSinglePopupMenuStyleListBox ;//CAknSingleStyleListBox;
    
    iListBox->ConstructL(iParent,EAknListBoxMenuList); 
    iListBox->MakeVisible(EFalse);

   	      
    CWindowGc* gc = RootControl()->GetRWindowGcL();//(static_cast<CGenericItutUiLayout*>(UiLayout()))->WindowGc();
    iListBox->SetGc(gc);
    
    iListBox->SetGc(gc);
    iListBox->ItemDrawer()->SetGc(gc);    

    iListBox->CreateScrollBarFrameL(ETrue,EFalse,EFalse);    
    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, 
                                                        CEikScrollBarFrame::EAuto);
    
    CEikScrollBar* scrbar = iListBox->ScrollBarFrame()->VerticalScrollBar();
    iScrollbarCtrl = new(ELeave) CPenUiScrolbarCtrl(scrbar, UiLayout());
    static_cast<CPenUiScrolbarCtrl*>(iScrollbarCtrl)->ConstructL();
    UpdateTextColors();
    
    CFormattedCellListBoxData* d = iListBox->ItemDrawer()->FormattedCellData();
    TBool b = d->SubCellIsTransparent(0);
    TMargins m = d->SubCellMargins(0);
    //UseSubCellColors
    
    
    iWndControl = iListBox;
    
    iTxtTransferBuf = HBufC::NewL(KMaxTxtLen);    
    
    TRect nullRect( 0, 0, 0, 0 );

    iBgContext = CAknsFrameBackgroundControlContext::NewL(
        KAknsIIDQsnFrPopupSub, nullRect, nullRect, EFalse );        
        
    
    }
    
EXPORT_C void CFepLayoutAknChoiceList::SetItemsL(const RPointerArray<CFepLayoutChoiceList::SItem>& 
                                                 aItemList)
    {
    TRect r = iRect;
    CFepLayoutChoiceList::SetItemsL(aItemList);
    //
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());
      //= (CDesCArray*) itemList;

    for(int ii = 0; ii < aItemList.Count(); ++ii)
        {
        itemArray->AppendL(aItemList[ii]->iText);
        }    
    iListBox->HandleItemAdditionL();        
    SetRect(r);
    }


EXPORT_C void CFepLayoutAknChoiceList::AddItemL(const CFepLayoutChoiceList::SItem& aItem)
    {
    TRect r = iRect;
    CFepLayoutChoiceList::AddItemL(aItem);
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());    
    itemArray->AppendL(AdjustColumnText(aItem.iText));
    iListBox->HandleItemAdditionL();    
    SetRect(r);
    }
    
    
EXPORT_C void CFepLayoutAknChoiceList::InsertItemL(TInt aPostion, 
                                                   const CFepLayoutChoiceList::SItem& aItem)
    {
    TRect r = iRect;
    CFepLayoutChoiceList::InsertItemL(aPostion,aItem);
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());     
    itemArray->InsertL(aPostion,AdjustColumnText(aItem.iText));   
    iListBox->HandleItemAdditionL();    
    SetRect(r);
    }

EXPORT_C void CFepLayoutAknChoiceList::RemoveItemByCommand(TInt aCommand)
    {
    TInt idx = FindCommand(aCommand);
    if(idx > 0)
        {        
        RemoveItemByIndex(idx);
        }
    }
    
void CFepLayoutAknChoiceList::RemoveItemByIndexL(TInt aIndex)
    {
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());    
    __ASSERT_DEBUG(aIndex >= 0 && aIndex < itemArray->Count(),User::Leave(EUiGeneralIndexError));
    CFepLayoutChoiceList::RemoveItemByIndex(aIndex);
    itemArray->Delete(aIndex);
    TRAP_IGNORE(iListBox->HandleItemRemovalL());
    }

EXPORT_C void CFepLayoutAknChoiceList::RemoveItemByIndex(TInt aIndex)
    {
    TRAP_IGNORE(RemoveItemByIndexL(aIndex));
    }
    
EXPORT_C void CFepLayoutAknChoiceList::ClearItemsL()
    {
    CFepLayoutChoiceList::ClearItemsL();    
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());    
    itemArray->Reset();
    }
    
EXPORT_C TInt CFepLayoutAknChoiceList::ItemsCount()
    {
    CDesCArray* itemArray = static_cast<CDesCArray*>(FormatedCellListBox()->Model()->ItemTextArray());    
    return itemArray->Count();
    }
    
EXPORT_C void CFepLayoutAknChoiceList::Draw()
    {
    
    if(iWndControl && AbleToDraw())
        {
  		DrawOpaqueMaskBackground();              
        CFbsBitGc* gc = static_cast<CFbsBitGc*>(BitGc());
        gc->Activate( BitmapDevice() );

        const TRect& r = Rect();
        MAknsSkinInstance* skin = AknsUtils::SkinInstance();
        TRAP_IGNORE(CWindowGc& sysgc = *(RootControl()->GetRWindowGcL()));
        //if ( !AknsDrawUtils::Background( skin, iBgContext, sysgc, r ) )
            {
            gc->Clear( Rect());
            }
        
        iWndControl->DrawNow();
        UpdateArea(iRect, EFalse);        
        }

    }
    
EXPORT_C void CFepLayoutAknChoiceList::SetItemRect(const TRect& , const TRect& )
    {
    //do nothing
    }

// CFepLayoutChoiceList::OnDisplay
// Prepare display.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CFepLayoutAknChoiceList::OnDisplay(const TPoint& /*aOffset*/)
    {
    //set window position
    //iListBox->ActivateL();	
    //TBool b = iListBox->IsVisible();    
    TPoint layoutPos = UiLayout()->LayoutOwner()->LayoutRect().iTl;
    layoutPos = TPoint(0,0);
    //CFepLayoutChoiceList::OnDisplay(aOffset);
 //   iListBox->SetExtent(layoutPos + aOffset,Rect().Size());    
    
    CListBoxView* view = iListBox->View();
    TRect r = view->ViewRect();
    r.iBr.iY -= 50; 
    view->SetViewRect(r);

    TSize is = view->ItemSize(0);    
    TInt w = MinItemWidthInPixels();
    TSize s = iListBox->ItemDrawer()->MinimumCellSize();
    TSize ls = iListBox->ItemDrawer()->LafItemSize ();
    
    UpdateControlContext();
    UpdateTextColors();
    iListBox->MakeVisible(ETrue);
    TRAP_IGNORE(iListBox->ActivateL());	    
//    iListBox->ItemDrawer()->FormattedCellData()->SetSkinEnabledL( EFalse );
    // Marquee can be requested.. ;) 
  //  iListBox->ItemDrawer()->FormattedCellData()->EnableMarqueeL( EFalse );
    
    }



EXPORT_C CEikColumnListBox* CFepLayoutAknChoiceList::ListBox()
    {
    return 0;//iListBox;
    }
EXPORT_C CEikFormattedCellListBox* CFepLayoutAknChoiceList::FormatedCellListBox()
    {
    return iListBox;
    }

void CFepLayoutAknChoiceList::UpdateTextColors()
    {
    TRgb color( KRgbBlack );  // sane default for nonskinned case
    if ( AknsUtils::AvkonSkinEnabled() )
        {
        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
                               color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG8 );
        }

    iListBox->ItemDrawer()->SetTextColor( color );
    iListBox->ItemDrawer()->SetBackColor( AKN_LAF_COLOR( 0 ) );

    if ( AknsUtils::AvkonSkinEnabled() )
        {
        AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
                               color, KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG8 );
        }

    CFormattedCellListBoxData* d = iListBox->ItemDrawer()->FormattedCellData();

    iListBox->ItemDrawer()->SetHighlightedTextColor( color );
    iListBox->ItemDrawer()->SetHighlightedBackColor( AKN_LAF_COLOR( 0 ) );    
    }
    
void CFepLayoutAknChoiceList::UpdateControlContext()
    {
    
        CFormattedCellListBoxItemDrawer* itemDrawer = iListBox->ItemDrawer();
        CFormattedCellListBoxData* d = itemDrawer->FormattedCellData();        

        TAknLayoutRect cellRect;
        cellRect.LayoutRect( Rect(), 
            AknLayoutScalable_Avkon::list_single_choice_list_pane(0) );
        
        TRect cell( cellRect.Rect() );

        TRAP_IGNORE(iListBox->SetItemHeightL( cell.Height() ));

        //d->SetTextSubCellL( 0, AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(0) );    
    {
    
    const TAknTextLineLayout& aTextLayout =  
                                       AknLayoutScalable_Avkon::list_single_choice_list_pane_t1(0);
            
    TAknLayoutText t;
    TInt subCell = 0;
    t.LayoutText( iListBox->View()->ItemDrawer()->ItemCellSize(), aTextLayout );
    CFormattedCellListBoxData* d = iListBox->ItemDrawer()->FormattedCellData();
    TRAP_IGNORE(d->SetSubCellSizeL( subCell, t.TextRect().Size() ));
    TRAP_IGNORE(d->SetSubCellPositionL( subCell, t.TextRect().iTl ));
    TRAP_IGNORE(d->SetSubCellFontL( subCell, t.Font() ));
    TRAP_IGNORE(d->SetSubCellAlignmentL( subCell, 
                                         AknLayoutUtils::TextAlignFromId( aTextLayout.iJ ) ));
    TInt B = 22;//AknLayoutUtils::CorrectBaseline( iListBox->View()->ItemDrawer()->ItemCellSize().iHeight, aTextLayout.iB, aTextLayout.FontId() );
    TRAP_IGNORE(d->SetSubCellBaselinePosL( subCell, B ));
    }
    
    
    {
        TAknLayoutRect cellRect;
        cellRect.LayoutRect( Rect(), 
            AknLayoutScalable_Avkon::list_single_choice_list_pane(0) );
            
        iListBox->View()->ItemDrawer()->SetItemCellSize( cellRect.Rect().Size() );
            
        TRAP_IGNORE(iListBox->SetItemHeightL( cell.Height()*2 ));            
    
    }
/*    TRect rectParent( Rect() );
                      
    TAknLayoutRect layoutRect;
    TInt variety = 0;

    // check if scrollbar-layout should be selected
    if ( ScrollbarVisible() )
        {
        variety = 1;

        iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOn);            
        
        AknLayoutUtils::LayoutVerticalScrollBar( iListBox->ScrollBarFrame(), 
            rectParent, 
            AknLayoutScalable_Avkon::scroll_pane_cp23().LayoutLine()
        );                    
        }
    else
        {
        iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff);
        }
        
    layoutRect.LayoutRect( rectParent, 
        AknLayoutScalable_Avkon::list_choice_list_pane( variety ).LayoutLine() );        
    iListBox->SetRect( layoutRect.Rect() );
            
    TAknLayoutRect innerRect;
    innerRect.LayoutRect( 
        rectParent, 
        AknLayoutScalable_Avkon::list_choice_list_pane(0).LayoutLine() 
        );
    
    iBgContext->SetFrameRects(rectParent, innerRect.Rect());        */
    }    
// ---------------------------------------------------------------------------
// CFepLayoutPopupWnd::SetRect
// Set the pop up window's rect
// ---------------------------------------------------------------------------
//    
EXPORT_C void CFepLayoutAknChoiceList::SetRect(const TRect& aRect)
    {    
    
    //Ensure that the top left of pop up window is always (0,0)
    //iRect.Move(-aRect.iTl.iX,-aRect.iTl.iY);    
    if(iRect == aRect)
        return;
    
    iRect = aRect;  
    /*      
    if(iWndControl)
        iWndControl->SetRect(iRect); 
        */       
    iListBox->SetRect( aRect);        
    UpdateControlContext();        
    if(iScrollbarCtrl)
        {        
        //set the rect of the scroll bar    
        TRect rect = iScrollbarCtrl->WndControl()->Rect();
        iScrollbarCtrl->SetRect(rect);
        }
    
    }

EXPORT_C TBool CFepLayoutAknChoiceList::ScrollbarVisible()
    {
    return ETrue;
    }

// ---------------------------------------------------------------------------
// CFepLayoutAknChoiceList::HandlePointerDownEventL
// Handle pointer down event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//      
EXPORT_C CFepUiBaseCtrl* CFepLayoutAknChoiceList::HandlePointerDownEventL(const TPoint& aPoint)
    {
    if(ScrollbarVisible())
        {
        if(iScrollbarCtrl->Rect().Contains(aPoint))
            {
            iScrollbarCaptured = ETrue;
            return iScrollbarCtrl->HandlePointerDownEventL(aPoint);
            }
        }
    CFepUiBaseCtrl::HandlePointerDownEventL(aPoint);
    //CFepLayoutChoiceList::HandlePointerDownEventL(aPoint);
    return this;
    }

// ---------------------------------------------------------------------------
// CFepLayoutAknChoiceList::HandlePointerUpEventL
// Handle pointer up event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//    
EXPORT_C CFepUiBaseCtrl* CFepLayoutAknChoiceList::HandlePointerUpEventL(
                                                         const TPoint& aPoint)
    {
    if(iScrollbarCaptured)
        {
        iScrollbarCaptured = EFalse;
        return iScrollbarCtrl->HandlePointerUpEventL(aPoint);
        }
    //CFepUiBaseCtrl::HandlePointerUpEventL(aPoint);
    CFepLayoutChoiceList::HandlePointerUpEventL(aPoint);
    return this;
    }

// ---------------------------------------------------------------------------
// CFepLayoutAknChoiceList::HandlePointerMoveEventL
// Handle pointer move event
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C CFepUiBaseCtrl* CFepLayoutAknChoiceList::HandlePointerMoveEventL(
                                                        const TPoint& aPoint)
    {
    if(iScrollbarCaptured)
        {
        iScrollbarCtrl->HandlePointerMoveEventL(aPoint);
        }
    if(PointerDown()) //only handle move event after pointer down
        CFepUiBaseCtrl::HandlePointerMoveEventL(aPoint);
    //CFepLayoutChoiceList::HandlePointerMoveEventL(aPoint);
    return this;

    }

// ---------------------------------------------------------------------------
// CFepLayoutAknChoiceList::AdjustColumnText
// Adjust the txt which is added to column list.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
const TDesC& CFepLayoutAknChoiceList::AdjustColumnText(const TDesC& aTxt)
    {
    return aTxt;
    /*_LIT(KLitTabulate,"\t");
    if(aTxt.Find(KLitTabulate) >=0)
        return aTxt;
    if(KMaxTxtLen < aTxt.Length() + KLitTabulate().Length())
        {
        delete iTxtTransferBuf;
        iTxtTransferBuf = 0;
        iTxtTransferBuf = HBufC::NewL(aTxt.Length() + KLitTabulate().Length());        
        }
    TPtr ptr = iTxtTransferBuf->Des();    
    ptr.Zero();
    ptr.Append(KLitTabulate);
    ptr.Append(aTxt);
    return *iTxtTransferBuf;*/
    }

// CFepLayoutAknChoiceList::ReCalcLayout
// Calculates the displaying rect.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
EXPORT_C void CFepLayoutAknChoiceList::ReCalcLayout()
    {
    //do nothing
    }
    								       
EXPORT_C TInt CFepLayoutAknChoiceList::MinItemWidthInPixels()
    {
    
    TInt minWidth = 0;
    for(TInt i = 0; i < ItemsCount(); ++i)
        {
        TInt itemWidth = iListBox->ItemDrawer()->ItemWidthInPixels (i);
        minWidth = itemWidth > minWidth ? itemWidth : minWidth;
        }
        
      
    CFormattedCellListBoxData* d = iListBox->ItemDrawer()->FormattedCellData();
    TSize s1 = d->SubCellSize(0);
    TSize s2 = d->SubCellSize(1);
    return minWidth;	      
    }

//END OF FILE