/*
* Copyright (c) 2009 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:
*
*/
// INCLUDE FILES
#include <ganes/HgGrid.h>
#include <ganes/HgItem.h>
#include "HgLayoutData.h"
#include "HgIndicatorManager.h"
#include "HgDrawUtils.h"
#include <aknphysics.h>
#include "HgConstants.h"
#include <AknIconUtils.h>
#include <avkon.mbg>
#include <AknUtils.h>
#include <AknsUtils.h>
#include <AknsDrawUtils.h>
#include <AknsConstants.h>
#include <gulicon.h>
#include <AknUtils.h>
#include <layoutmetadata.cdl.h>
#include <aknlayoutscalable_apps.cdl.h>
#include <aknlayoutscalable_avkon.cdl.h>
using namespace AknLayoutScalable_Apps;
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CHgGrid::NewL()
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CHgGrid* CHgGrid::NewL (
const TRect& aRect,
TInt aItemCount,
CGulIcon* aDefaultIcon,
RWsSession* aSession )
{
CHgGrid* self = new ( ELeave ) CHgGrid(
aItemCount,
aDefaultIcon);
CleanupStack::PushL (self );
self->ConstructL( aRect, aSession );
CleanupStack::Pop (self );
return self;
}
// -----------------------------------------------------------------------------
// CHgGrid::ConstructL()
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHgGrid::ConstructL (const TRect& aRect, RWsSession* aSession )
{
TAknLayoutScalableParameterLimits limits = cell_gallery2_pane_ParamLimits(0);
TInt cols = limits.LastColumn() + 1;
iLayoutData = CHgGridLayoutData::NewL( cols );
CHgScroller::ConstructL( aRect, aSession );
// Activate the window, which makes it ready to be drawn
ActivateL ( );
}
// -----------------------------------------------------------------------------
// CHgGrid::CHgGrid()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CHgGrid::CHgGrid(
TInt aItemCount,
CGulIcon* aDefaultIcon )
: CHgScroller( aItemCount, aDefaultIcon ),
iToolbarVisible( ETrue )
{
// No implementation required
}
// -----------------------------------------------------------------------------
// CHgGrid::~CHgGrid()
// Destructor.
// -----------------------------------------------------------------------------
//
EXPORT_C CHgGrid::~CHgGrid ( )
{
delete iLayoutData;
}
// -----------------------------------------------------------------------------
// CHgGrid::PreferredImageSize()
// -----------------------------------------------------------------------------
//
EXPORT_C TSize CHgGrid::PreferredImageSize()
{
TAknLayoutRect gridAppPane;
TAknLayoutRect gridItem;
TAknLayoutRect gridImage;
gridAppPane.LayoutRect( TRect(), grid_gallery2_pane(0));
gridItem.LayoutRect( gridAppPane.Rect(), cell_gallery2_pane(1, 0, 0));
gridImage.LayoutRect(gridItem.Rect(), cell_gallery2_pane_g2(1));
return gridImage.Rect().Size();
}
// -----------------------------------------------------------------------------
// CHgGrid::InitItemsL()
// -----------------------------------------------------------------------------
//
void CHgGrid::InitItemsL()
{
for(TInt i = 0; i < iItemCount; ++i)
{
iItems.Append( CHgItem::NewL() );
}
}
// -----------------------------------------------------------------------------
// CHgGrid::DoDraw()
// -----------------------------------------------------------------------------
//
void CHgGrid::DoDraw (const TRect& /*aRect*/) const
{
// Get the standard graphics context
TInt xdiff = (iViewPosition.iX-(iWidth/2))% (iLandscapeScrolling ? iRowHeight : iRowWidth);
TInt ydiff = (iViewPosition.iY-(iHeight/2))%( iLandscapeScrolling ? iRowWidth : iRowHeight);
if( iItemCount == 0 )
{
TRgb color( KRgbBlack );
if ( AknsUtils::AvkonSkinEnabled() )
{
AknsUtils::GetCachedColor( AknsUtils::SkinInstance(),
color,
KAknsIIDQsnTextColors,
EAknsCIQsnTextColorsCG6 );
}
if( iEmptyText )
iDrawUtils->DrawEmptyText(SystemGc(), Rect(), *iEmptyText, color);
}
else
{
TAknLayoutRect gridAppPane;
gridAppPane.LayoutRect( GridRect(), iLayoutData->ItemLayout() );
if( iLandscapeScrolling )
{
if( AknLayoutUtils::LayoutMirrored() )
{
for(TInt i = iCurrentRow; i < iCols; ++i)
{
TInt xPos = - (((i-iCurrentRow)*iRowHeight) - xdiff);
if( i < 0 )
continue;
else if( xPos < -iWidth )
break;
DrawRows( i, gridAppPane.Rect(), xPos );
}
}
else
{
for(TInt i = iCurrentRow; i < iCols; ++i)
{
TInt xPos = ((i-iCurrentRow)*iRowHeight) - xdiff;
if( i < 0 )
continue;
else if( xPos > iWidth )
break;
DrawRows( i, gridAppPane.Rect(), xPos );
}
}
}
else
{
for(TInt i = iCurrentRow; i < iRows; ++i)
{
TInt yPos = ((i-iCurrentRow)*iRowHeight) - ydiff;
if( i < 0 )
continue;
else if( yPos > iHeight )
break;
DrawCols( i, gridAppPane.Rect(), yPos );
}
}
}
}
// -----------------------------------------------------------------------------
// CHgGrid::DrawRows()
// -----------------------------------------------------------------------------
//
void CHgGrid::DrawRows( TInt aCol, const TRect& aRect, TInt aXPos ) const
{
for(TInt j = 0; j < iRows; ++j)
{
TInt index = aCol*iRows + j;
if( index < iItems.Count())
{
TAknLayoutRect gridItem;
gridItem.LayoutRect( aRect,iLayoutData->ColumnLayout(j) );
TRect rect(gridItem.Rect());
rect.Move( aXPos, 0 );
DrawItem( index, rect );
}
else
{
break;
}
}
}
// -----------------------------------------------------------------------------
// CHgGrid::DrawCols()
// -----------------------------------------------------------------------------
//
void CHgGrid::DrawCols(TInt aRow, const TRect& aRect, TInt aYPos) const
{
for(TInt j = 0; j < iCols; ++j)
{
TInt index = aRow*iCols + j;
if( index < iItems.Count())
{
TAknLayoutRect gridItem;
gridItem.LayoutRect( aRect,iLayoutData->ColumnLayout(j) );
TRect rect(gridItem.Rect());
rect.Move( 0, aYPos );
DrawItem( index, rect );
}
else
{
break;
}
}
}
// -----------------------------------------------------------------------------
// CHgGrid::DoDraw()
// -----------------------------------------------------------------------------
//
void CHgGrid::DrawItem(TInt aIndex, const TRect& aRect ) const
{
CHgItem* item = iItems[aIndex];
CGulIcon* icon = item->Icon() ? item->Icon() : iDefaultIcon;
if( aIndex == iSelectedIndex )
{
DrawHighlight(aRect);
}
CWindowGc& gc = SystemGc();
iDrawUtils->DrawImage(gc, aRect, iLayoutData->IconLayout(), *icon);
// Draw the indicators.
iIndicatorManager->DrawIndicators(
gc,
aRect,
item->Flags(),
iLayoutData->FirstIndicatorLayout(),
iLayoutData->SecondIndicatorLayout() );
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleSizeChanged()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleSizeChanged ( )
{
iLandscapeScrolling = Layout_Meta_Data::IsLandscapeOrientation() && iLandScapeScrollingSupported;
TInt oldCount = iLandscapeScrolling ? iRows : iCols;
CalculateSizes();
if( iLandscapeScrolling )
{
iCols = iItemCount / iRows;
if(iItemCount%iRows)
{
++iCols; // partially filled col
}
iItemsOnScreen = iWidth / iRowHeight;
if((iWidth % iRowHeight))
iItemsOnScreen += 2;
else
iItemsOnScreen++;
iItemsOnScreen *= iRows;
FitTopItemToView( iCurrentRow*oldCount );
}
else
{
iRows = iItemCount / iCols;
if(iItemCount%iCols)
{
++iRows; // partially filled row
}
iItemsOnScreen = iHeight / iRowHeight;
if((iHeight % iRowHeight))
iItemsOnScreen += 2;
else
iItemsOnScreen++;
iItemsOnScreen *= iCols;
FitTopItemToView( iCurrentRow*oldCount );
}
}
// -----------------------------------------------------------------------------
// CHgGrid::CalculateSizes()
// -----------------------------------------------------------------------------
//
void CHgGrid::CalculateSizes()
{
// Count number of visible rows
// First is checked if 3x4 or 4x3 items fits to the grid.
TInt mainVariety = iToolbarVisible ? 0 : 1;
TInt gridVariety = iToolbarVisible ? 0 : 2;
TInt cellVariety = iToolbarVisible ? 0 : 4;
if( Layout_Meta_Data::IsLandscapeOrientation() )
{
++gridVariety;
++cellVariety;
}
TAknLayoutScalableParameterLimits limits = cell_gallery2_pane_ParamLimits(cellVariety);
iCols = limits.LastColumn() + 1;
iRows = limits.LastRow() + 1;
iLayoutData->ChangeCols( iCols );
iLayoutData->SetBaseLayout(main_gallery2_pane(mainVariety));
iLayoutData->SetItemLayout(grid_gallery2_pane(gridVariety));
iLayoutData->SetIconLayout(cell_gallery2_pane_g2(cellVariety));
if( iLandscapeScrolling )
{
for(TInt i = 0; i < iRows; ++i)
{
iLayoutData->SetColumnLayout(i, cell_gallery2_pane(cellVariety, 0, i));
}
}
else
{
for(TInt i = 0; i < iCols; ++i)
{
iLayoutData->SetColumnLayout(i, cell_gallery2_pane(cellVariety, i, 0));
}
}
iLayoutData->SetFirstIndicatorLayout(cell_gallery2_pane_g5(cellVariety));
iLayoutData->SetSecondIndicatorLayout(cell_gallery2_pane_g4(cellVariety));
TAknLayoutRect gridAppPane;
TAknLayoutRect gridItem;
TAknLayoutRect gridImage;
gridAppPane.LayoutRect( GridRect(), iLayoutData->ItemLayout());
gridItem.LayoutRect( gridAppPane.Rect(), iLayoutData->ColumnLayout(0));
gridImage.LayoutRect( gridItem.Rect(), iLayoutData->IconLayout());
if( iLandscapeScrolling )
{
iRowHeight = gridItem.Rect().Width();
iRowWidth = gridItem.Rect().Height();
}
else
{
iRowHeight = gridItem.Rect().Height();
iRowWidth = gridItem.Rect().Width();
}
iImageSize = gridImage.Rect().Size();
TAknLayoutRect indicator;
indicator.LayoutRect( gridItem.Rect(), iLayoutData->FirstIndicatorLayout() );
iIndicatorSize = indicator.Rect().Size();
}
// -----------------------------------------------------------------------------
// CHgGrid::GetSelected()
// -----------------------------------------------------------------------------
//
TInt CHgGrid::GetSelected( TPoint aPosition ) const
{
TAknLayoutRect gridAppPane;
gridAppPane.LayoutRect( GridRect(), iLayoutData->ItemLayout());
aPosition -= gridAppPane.Rect().iTl;
TInt index = 0;
if( iLandscapeScrolling )
{
TInt y = aPosition.iY + ((iViewPosition.iY - (iHeight/2)) % iRowWidth);
y /= iRowWidth;
TInt x = 0;
if( AknLayoutUtils::LayoutMirrored() )
{
x = aPosition.iX - ((iViewPosition.iX - (iWidth/2)) % iRowHeight);
if(x < 0) // to correct the division
x-= iRowHeight;
x /= iRowHeight;
x = ((iWidth / iRowHeight) - 1) - x; // mirrored correction to x
}
else
{
x = aPosition.iX + ((iViewPosition.iX - (iWidth/2)) % iRowHeight);
x /= iRowHeight;
}
index = (iCurrentRow*iRows) + (x*iRows) + y;
}
else
{
TInt x = aPosition.iX + ((iViewPosition.iX - (iWidth/2)) % iRowWidth);
TInt y = aPosition.iY + ((iViewPosition.iY - (iHeight/2)) % iRowHeight);
x /= iRowWidth;
y /= iRowHeight;
if( AknLayoutUtils::LayoutMirrored() )
{
x = (iCols - 1) - x;
}
index = (iCurrentRow*iCols) + (y*iCols) + x;
}
return index >= iItems.Count() || index < 0 ? KErrNotFound : index;
}
// -----------------------------------------------------------------------------
// CHgGrid::TotalSize()
// -----------------------------------------------------------------------------
//
TSize CHgGrid::TotalSize() const
{
return iLandscapeScrolling ? TSize( iCols*iRowHeight, iHeight ) : TSize(iWidth, iRows*iRowHeight);
}
// -----------------------------------------------------------------------------
// CHgGrid::DrawHighlight()
// -----------------------------------------------------------------------------
//
void CHgGrid::DrawHighlight( const TRect& aOuterRect ) const
{
TRect innerRect( aOuterRect );
innerRect.Shrink(2,2);
CWindowGc& gc = SystemGc();
if( HasHighlight() )
{
if( iPointerDown && !iPanning && iFocusedIndex != KErrNotFound && iSelectionToFocusedItem )
{
AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(),
gc,
aOuterRect,
innerRect,
KAknsIIDQsnFrGridPressed,
KAknsIIDQsnFrGridCenterPressed );
}
else
{
AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(),
gc,
aOuterRect,
innerRect,
KAknsIIDQsnFrGrid,
KAknsIIDQsnFrGridCenter );
}
}
else if( iPointerDown && !iPanning )
{
AknsDrawUtils::DrawFrame( AknsUtils::SkinInstance(),
gc,
aOuterRect,
innerRect,
KAknsIIDQsnFrGrid,
KAknsIIDQsnFrGridCenter );
}
}
// -----------------------------------------------------------------------------
// CHgGrid::DoHandleKeyEvent()
// -----------------------------------------------------------------------------
//
TBool CHgGrid::DoHandleKeyEvent( const TKeyEvent& aEvent )
{
TBool ret = ETrue;
switch( aEvent.iCode )
{
case EKeyUpArrow:
HandleUpArrow();
break;
case EKeyDownArrow:
HandleDownArrow();
break;
case EKeyLeftArrow:
HandleLeftArrow();
break;
case EKeyRightArrow:
HandleRightArrow();
break;
default:
ret = EFalse;
break;
}
return ret;
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleDownArrow()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleDownArrow()
{
if( iSelectedIndex == KErrNotFound )
{
SelectDefaultItem();
}
else
{
if( iLandscapeScrolling )
{
ChangeSelectedIndex( 1 );
}
else
{
ChangeSelectedIndex( iCols );
}
FitSelectionToView();
SelectionChanged();
DrawDeferred();
}
}
// -----------------------------------------------------------------------------
// CHgGrid::GridRect()
// -----------------------------------------------------------------------------
//
TRect CHgGrid::GridRect() const
{
TAknLayoutRect listscrollAppPane;
listscrollAppPane.LayoutRect( Rect(), iLayoutData->BaseLayout());
return listscrollAppPane.Rect();
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleUpArrow()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleUpArrow()
{
if( iSelectedIndex == KErrNotFound )
{
SelectDefaultItem();
}
else
{
if( iLandscapeScrolling )
{
ChangeSelectedIndex( -1 );
}
else
{
ChangeSelectedIndex( -iCols );
}
FitSelectionToView();
SelectionChanged();
DrawDeferred();
}
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleRightArrow()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleRightArrow()
{
if( iSelectedIndex == KErrNotFound )
{
SelectDefaultItem();
}
else
{
TInt mul = AknLayoutUtils::LayoutMirrored() ? -1 : 1;
if( iLandscapeScrolling )
{
ChangeSelectedIndex( mul * iRows );
}
else
{
ChangeSelectedIndex( mul );
}
FitSelectionToView();
SelectionChanged();
DrawDeferred();
}
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleLeftArrow()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleLeftArrow()
{
if( iSelectedIndex == KErrNotFound )
{
SelectDefaultItem();
}
else
{
TInt mul = AknLayoutUtils::LayoutMirrored() ? 1 : -1;
if( iLandscapeScrolling )
{
ChangeSelectedIndex( mul * iRows );
}
else
{
ChangeSelectedIndex( mul );
}
FitSelectionToView();
SelectionChanged();
DrawDeferred();
}
}
// -----------------------------------------------------------------------------
// CHgGrid::FitSelectionToView()
// -----------------------------------------------------------------------------
//
void CHgGrid::FitSelectionToView()
{
const TInt index = iLandscapeScrolling ?
iSelectedIndex/iRows : iSelectedIndex/iCols;
FitRowToView( index );
}
// -----------------------------------------------------------------------------
// CHgGrid::SelectDefaultItem()
// -----------------------------------------------------------------------------
//
void CHgGrid::SelectDefaultItem()
{
iSelectedIndex = CurrentIndex();
if( iSelectedIndex >= 0 && iSelectedIndex < iItems.Count() )
{
FitSelectionToView();
DrawDeferred();
}
}
// -----------------------------------------------------------------------------
// CHgGrid::CurrentIndex()
// -----------------------------------------------------------------------------
//
TInt CHgGrid::CurrentIndex()
{
return iLandscapeScrolling ? iCurrentRow * iRows : iCurrentRow * iCols;
}
// -----------------------------------------------------------------------------
// CHgGrid::IsDisplayed()
// -----------------------------------------------------------------------------
//
TBool CHgGrid::IsDisplayed( TInt aIndex )
{
TInt start = CurrentIndex();
TInt end = start + iItemsOnScreen;
return aIndex >= start && aIndex < end;
}
// -----------------------------------------------------------------------------
// CHgGrid::FitTopItemToView()
// -----------------------------------------------------------------------------
//
void CHgGrid::FitTopItemToView( TInt aIndex )
{
if( iLandscapeScrolling )
{
// Higlighted item is set to top of the list
const TInt newCol = aIndex/iRows;
TInt newPos = newCol*iRowWidth + iWidth/2;
if( ItemsOnScreen() >= iItems.Count() )
{
newPos = iWidth/2;
}
else
{
const TInt endMid = TotalSize().iWidth - iWidth/2;
if( newPos > endMid )
{
// We are presenting last items in the list
newPos = endMid;
}
}
iViewPosition.iX = newPos;
}
else
{
// Higlighted item is set to top of the list
const TInt newRow = aIndex/iCols;
TInt newPos = newRow*iRowHeight + iHeight/2;
if( ItemsOnScreen() >= iItems.Count() )
{
newPos = iHeight/2;
}
else
{
const TInt endMid = TotalSize().iHeight - iHeight/2;
if( newPos > endMid )
{
// We are presenting last items in the list
newPos = endMid;
}
}
iViewPosition.iY = newPos;
}
HandleViewPositionChanged();
}
// -----------------------------------------------------------------------------
// CHgGrid::SetLandscapeScrollingSupport()
// -----------------------------------------------------------------------------
//
EXPORT_C void CHgGrid::SetLandscapeScrollingSupport( TBool aSupportLandscapeScrolling )
{
iLandScapeScrollingSupported = aSupportLandscapeScrolling;
}
// -----------------------------------------------------------------------------
// CHgGrid::ChangeSelectedIndex()
// -----------------------------------------------------------------------------
//
void CHgGrid::ChangeSelectedIndex( TInt aMove )
{
TInt nextIndex = 0;
if( iSelectedIndex + aMove > iItems.Count() - 1 )
{
// go to beginning
nextIndex = 0;
}
else if( iSelectedIndex + aMove < 0 )
{
// go to end
nextIndex = iItems.Count() - 1;
}
else
{
nextIndex = iSelectedIndex + aMove;
}
if( iSelectionMode == ESelectionMark )
{
Mark( iSelectedIndex );
Mark( nextIndex );
}
else if( iSelectionMode == ESelectionUnMark )
{
UnMark( iSelectedIndex );
UnMark( nextIndex );
}
iSelectedIndex = nextIndex;
}
// -----------------------------------------------------------------------------
// CHgGrid::HandleScrollbarVisibilityChange()
// -----------------------------------------------------------------------------
//
void CHgGrid::HandleScrollbarVisibilityChange( TBool /*aVisible*/ )
{
}
// -----------------------------------------------------------------------------
// CHgGrid::SetToolbarVisibility()
// -----------------------------------------------------------------------------
//
EXPORT_C void CHgGrid::SetToolbarVisibility( TBool aToolbarVisible )
{
iToolbarVisible = aToolbarVisible;
HandleSizeChanged();
}
// End of File