/*******************************************************************************

 * Copyright (c) 2005, 2010 Nokia Corporation and/or its subsidiary(-ies).

 * All rights reserved. This program and the accompanying materials

 * are made available under the terms of the Eclipse Public License v1.0

 * which accompanies this distribution, and is available at

 * http://www.eclipse.org/legal/epl-v10.html

 *

 * Contributors:

 *     Nokia Corporation - S60 implementation

 *******************************************************************************/

#include <eswtcore.rsg>

#include <AknsConstants.h>

#include <AknsUtils.h>

#include <AknUtils.h>

#include <avkon.mbg>

#include <gulicon.h>

#include <swtlaffacade.h>

#include "eswtmobileextensions.h"

#include "swtcontrolhelper.h"

#include "swttable.h"

#include "swttableitem.h"

#include "swttableitemdrawer.h"

#include "eikbtgpc.h"

#include "swttablelistbox.h"

#include "swttablelistboxview.h"

#include "swtimagetextitem.h"

#include "swtuiutils.h"

#include "swttableheader.h"

#include "swttablecolumn.h"

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

CSwtTable* CSwtTable::NewL(MSwtDisplay& aDisplay, TSwtPeer aPeer,

                           MSwtComposite& aParent, TInt aStyle)

{

    CSwtTable* self = new(ELeave) CSwtTable(aDisplay, aPeer, aParent, aStyle);

    CleanupStack::PushL(self);

    self->ConstructL();

    self->InitControlBaseL();

    CleanupStack::Pop(self);

    return self;

}

CSwtTable::~CSwtTable()

{

    ASSERT(iTableItems.Count() == 0);

    ASSERT(iTableColumns.Count() == 0);

    iTableItems.Close();

    iTableColumns.Close();

    delete iHeader;

    iHeader = NULL;

    delete iTableListBox;

    iTableListBox = NULL;

    iColumnWidths.Close();

    iImageTextItems.Close();

    iColumnAlignments.Close();

    iColumnImagesCounts.Close();

    delete iCheckBoxOnBitmap;

    delete iCheckBoxOnMask;

    delete iCheckBoxOffBitmap;

    delete iCheckBoxOffMask;

    iCheckBoxOnBitmap = NULL;

    iCheckBoxOnMask = NULL;

    iCheckBoxOffBitmap = NULL;

    iCheckBoxOffMask = NULL;

    delete iOldSelectionArray;

}

const RPointerArray<CSwtImageTextItem>& CSwtTable::GetImageTextItems() const

{

    return iImageTextItems;

}

void CSwtTable::PostSelectionEventL(TInt aDetail, TInt aItemIndex) const

{

    ASSERT(aItemIndex != -1);

    if ((aDetail == KSwtStyleCheck) && !(Style() & KSwtStyleCheck))

    {

        aDetail = KSwtNone;

    }

    TSwtPeer itemPeer(GetItemL(aItemIndex));

    TRAP_IGNORE(iDisplay.PostSelectionEventL(iPeer, aDetail, itemPeer));

}

void CSwtTable::PostDefaultSelectionEventL(TInt aItemIndex) const

{

    ASSERT(aItemIndex != -1);

    TSwtPeer itemPeer(GetItemL(aItemIndex));

    TInt detail = KSwtNone;

    if (Style() & KSwtStyleCheck)

    {

        detail = KSwtStyleCheck;

    }

    iDisplay.PostDefaultSelectionEventL(iPeer, detail, itemPeer);

}

void CSwtTable::PostColumnSelectionEventL(TSwtPeer aColumn) const

{

    iDisplay.PostSelectionEventL(aColumn);

}

void CSwtTable::PostColumnResizeEventL(TSwtPeer aColumn) const

{

    iDisplay.PostResizeEventL(aColumn);

}

void CSwtTable::PostColumnMoveEventL(TSwtPeer aColumn) const

{

    iDisplay.PostMoveEventL(aColumn);

}

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

// The header is placed above the view rectangle of the list box.

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

//

TRect CSwtTable::GetHeaderRect() const

{

    TRect clientRect(BorderInnerRect());

    TPoint headerTl(clientRect.iTl);

    TInt columnCount(GetColumnCount());

    TInt headerWidth(0);

    for (TInt i = 0; i < columnCount; ++i)

    {

        headerWidth += GetColumnWidth(i);

    }

    TSwtTableMargins margins = GetMargins();

    headerWidth += margins.iLeft;

    headerWidth += margins .iRight;

    if (Style() & KSwtStyleMulti || Style() & KSwtStyleCheck)

    {

        headerWidth += GetCheckBoxSize().iWidth;

    }

    TRect headerRect(headerTl,

                     TSize(Max(headerWidth, clientRect.Width()),

                           GetHeaderHeight()));

    return headerRect;

}

TSwtTableMargins CSwtTable::GetMargins() const

{

    TSwtTableMargins margins;

    margins.iTop          = iHighlightTopBottomMargin;

    margins.iBottom       = iHighlightTopBottomMargin;

    margins.iLeft         = iHighlightLeftRightMargin;

    margins.iRight        = iHighlightLeftRightMargin;

    margins.iBetweenItems = iHighlightLeftRightMargin / 3;

    return margins;

}

TSize CSwtTable::GetCheckBoxSize() const

{

    return iCheckBoxSize;

}

void CSwtTable::GetCheckBoxBitmaps(const TBool& aChecked,

                                   const CFbsBitmap** aBitmap,

                                   const CFbsBitmap** aMask) const

{

    if (aChecked)

    {

        *aBitmap = iCheckBoxOnBitmap;

        *aMask   = iCheckBoxOnMask;

    }

    else

    {

        *aBitmap = iCheckBoxOffBitmap;

        *aMask   = iCheckBoxOffMask;

    }

}

TInt CSwtTable::IndexOfTableItem(const CSwtImageTextItem* aItem) const

{

    if (!aItem)

        return -1;

    for (TInt i = 0; i < iImageTextItems.Count(); ++i)

    {

        if (iImageTextItems[ i ] == aItem)

        {

            return i;

        }

    }

    return -1;

}

TRgb CSwtTable::GetHighlightTextRgb() const

{

    if (iTableForegroundSet)

    {

        return iTableForeground;

    }

    else

    {

        return iTableDefaultHighlightText;

    }

}

TBool CSwtTable::BackgroundSet() const

{

    return iTableBackgroundSet;

}

TBool CSwtTable::IsChecked(const TInt& aIndex) const

{

    if (Style() & KSwtStyleCheck)

    {

        if (aIndex < 0 || aIndex >= iTableItems.Count())

        {

            return EFalse;

        }

        return iTableListBox->View()->ItemIsSelected(aIndex);

    }

    return EFalse;

}

void CSwtTable::CheckItem(const TInt& aIndex)

{

    TRAP_IGNORE

    (

        iTableListBox->SelectItemL(aIndex, EFalse);

        UpdateMSKLabelL();

    );

}

void CSwtTable::UncheckItem(const TInt& aIndex)

{

    iTableListBox->DeselectRange(aIndex, aIndex);

    TRAP_IGNORE(UpdateMSKLabelL());

}

TBool CSwtTable::ListMode() const

{

    return !(GetTableColumnCount() > 0);

}

void CSwtTable::UpdateHeaderHScrollOffset(const TInt& aHScrollOffset)

{

    iHeader->SetHScrollOffset(aHScrollOffset);

}

void CSwtTable::ListBoxDefaultFontChanged()

{

    const MSwtFont* currentTableFont = GetFont();

    TSwtTableMargins margins = GetMargins();

    // The default font changed but we don't know if it's used by any

    // item/cell. So let's not pass the default font height here but

    // instead go through everything to find the highest one.

    UpdateItemHeight(0);

    iHeader->SetFont(&currentTableFont->Font());

    // Header height might have changed due to the font change.

    LayoutTable();

}

void CSwtTable::HandlePhysics(TBool aStatus)

{

    GetShell().SetUrgentPaintControl(aStatus ? this : NULL);

}

const TRgb* CSwtTable::CustomForeground() const

{

    if (iTableForegroundSet)

        return &iTableForeground;

    else

        return NULL;

}

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

// From CCoeControl

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

//

TInt CSwtTable::CountComponentControls() const

{

    TInt count(0);

    if (iTableListBox)

    {

        ++count;

    }

    if (iHeader)

    {

        ++count;

    }

    return count;

}

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

// From CCoeControl

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

//

CCoeControl* CSwtTable::ComponentControl(TInt aIndex) const

{

    CCoeControl* control = NULL;

    // It is important that the header draws after the list. Kinetic scrolling

    // can cause slight incorrect draw of the list on top of the header buttons.

    if (aIndex == 0)

    {

        control = iTableListBox;

    }

    else if (aIndex == 1)

    {

        control = iHeader;

    }

    return control;

}

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

// From class CCoeControl.

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

//

void CSwtTable::SizeChanged()

{

    LayoutTable();

    CSwtComposite::SizeChanged();

}

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

// From class CCoeControl.

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

//

void CSwtTable::HandleResourceChange(TInt aType)

{

    TRAP_IGNORE(HandleResourceChangeL(aType));

}

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

// From class CCoeControl.

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

//

TKeyResponse CSwtTable::OfferKeyEventL(const TKeyEvent& aKeyEvent,TEventCode aType)

{

    TBool traversalDoIt = EFalse;

    TSwtTraversal detail = ESwtTraverseNone;

    TInt currentItemRowIndex = 0;

    TInt lastItemRowIndex = 0;

    TInt itemCount(GetItemCount());

    // Up/down arrows, try to traverse if not at the middle

    if (aKeyEvent.iCode == EKeyDownArrow ||

            aKeyEvent.iCode == EKeyUpArrow)

    {

        if (itemCount > 0)

        {

            currentItemRowIndex = iTableListBox->View()->CurrentItemIndex();

            lastItemRowIndex = itemCount - 1;

        }

        else

        {

            // In empty table this makes it to traverse

            currentItemRowIndex = 0;

            lastItemRowIndex = 0;

        }

    }

    if (aKeyEvent.iCode == EKeyDownArrow)

    {

        if (currentItemRowIndex == lastItemRowIndex)

        {

            detail = ESwtTraverseArrowNext;

        }

    }

    else if (aKeyEvent.iCode == EKeyUpArrow)

    {

        if (currentItemRowIndex == 0)

        {

            detail = ESwtTraverseArrowPrevious;

        }

    }

    // Left/right arrows, always try to traverse

    if (aKeyEvent.iCode == EKeyLeftArrow)

    {

        if (!iTableListBox->TableView()->CanScrollLeft())

        {

            detail = ESwtTraverseArrowPrevious;

        }

    }

    else if (aKeyEvent.iCode == EKeyRightArrow)

    {

        if (!iTableListBox->TableView()->CanScrollRight())

        {

            detail = ESwtTraverseArrowNext;

        }

    }

    // Tab key traversal is handled in HandleKeyL

    if (aKeyEvent.iCode == EKeyTab)

    {

        traversalDoIt = ETrue;

    }

    if (detail != ESwtTraverseNone &&

            (GetShell().FindTraversalTargetL(detail, *this)))

    {

        traversalDoIt = ETrue;

    }

    return HandleKeyL(aKeyEvent, aType, traversalDoIt);

}

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

// From class CCoeControl.

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

//

void CSwtTable::FocusChanged(TDrawNow aDrawNow)

{

    HandleFocusChanged(aDrawNow);

}

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

// From class CCoeControl.

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

//

TTypeUid::Ptr CSwtTable::MopSupplyObject(TTypeUid aId)

{

    if (aId.iUid == MAknsControlContext::ETypeId)

    {

        return TTypeUid::Null();

    }

    return ASwtControlBase::SwtMopSupplyObject(aId);

}

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

// From class CCoeControl.

// Overridden to prevent the background drawing implemented by CSwtComposite.

// The component controls take care of painting the background for Table.

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

//

void CSwtTable::Draw(const TRect& /*aRect*/) const

{

}

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

// From class MSwtTable

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

//

CSwtPeerArray* CSwtTable::GetTableItemsL()

{

    const TInt itemCount = iTableItems.Count();

    if (itemCount == 0)

    {

        return NULL;

    }

    CSwtPeerArray* array = new(ELeave) CSwtPeerArray(itemCount);

    CleanupStack::PushL(array);

    for (TInt i = 0; i < itemCount; ++i)

    {

        MSwtTableItem* item = iTableItems[ i ];

        array->AppendL(item->JavaPeer());

    }

    CleanupStack::Pop(array);

    return array;

}

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

// From class MSwtTable

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

//

CSwtPeerArray* CSwtTable::GetTableColumnsL()

{

    const TInt columnCount = iTableColumns.Count();

    if (columnCount == 0)

    {

        return NULL;

    }

    CSwtPeerArray* array = new(ELeave) CSwtPeerArray(columnCount);

    CleanupStack::PushL(array);

    for (TInt i = 0; i < columnCount; ++i)

    {

        MSwtTableColumn* column = iTableColumns[ i ];

        array->AppendL(column->JavaPeer());

    }

    CleanupStack::Pop(array);

    return array;