/*
* Copyright (c) 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: Class for displaying the images captured by a Burst session.*
*/
// INCLUDE FILES
#include <coecntrl.h>
#include <fbs.h>
#include <eikscrlb.h> // For CEikScrollBar
#include <bitmaptransforms.h> // For CBitmapScaler
#include <eikenv.h>
#include <eiksbfrm.h>
#include <barsread.h> // For TResourceReader
#include <cameraapp.mbg>
#include <AknIconArray.h>
#include <AknIconUtils.h>
#include <avkon.mbg> // EMbmAvkonQgn_indi_marked_grid_add
#include <cameraapp.rsg>
#include <vgacamsettings.rsg>
#include <AknsUtils.h>
#include <AknsDrawUtils.h>
#include <aknlayoutscalable_apps.cdl.h> // AknLayoutScalable_Apps
#include "camuiconstants.h"
#include "CamUtility.h"
#include "CamBurstThumbnailGrid.h"
#include "CamAppUi.h"
#include "CamPanic.h"
// EXTERNAL DATA STRUCTURES
// EXTERNAL FUNCTION PROTOTYPES
// CONSTANTS
// MACROS
// LOCAL CONSTANTS AND MACROS
// MODULE DATA STRUCTURES
// LOCAL FUNCTION PROTOTYPES
// FORWARD DECLARATIONS
// ============================= LOCAL FUNCTIONS ===============================
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::CCamBurstThumbnailGrid
// C++ default constructor can NOT contain any code, that
// might leave.
// -----------------------------------------------------------------------------
//
CCamBurstThumbnailGrid::CCamBurstThumbnailGrid( CCamBurstThumbnailGridModel& aModel ) :
iModel( aModel )
{
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CCamBurstThumbnailGrid::ConstructL( const CCoeControl* aParent )
{// Fill in the model
SetContainerWindowL( *aParent );
// Generate the grid size (either 6 for 3x2 or 9 for 3x3 grid)
iGridSize = iModel.GridHeight() * KGridWidth;
// Create component bitmaps
// TFileName resFileName;
//CamUtility::ResourceFileName( resFileName );
//TPtrC resname = resFileName;
iBitmapMark = NULL;
iBitmapMarkMask = NULL;
AknIconUtils::CreateIconL( iBitmapMark,
iBitmapMarkMask,
AknIconUtils::AvkonIconFileName(),
EMbmAvkonQgn_indi_marked_grid_add,
EMbmAvkonQgn_indi_marked_grid_add_mask );
// Request notification of Deletion and new Thumbnail events
iModel.AddModelObserverL( this, CCamBurstThumbnailGridModel::EModelEventDeleted |
CCamBurstThumbnailGridModel::EModelEventThumb );
UpdateLayout();
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::NewL
// Two-phased constructor.
// -----------------------------------------------------------------------------
//
CCamBurstThumbnailGrid* CCamBurstThumbnailGrid::NewL( const CCoeControl* aParent, CCamBurstThumbnailGridModel& aModel )
{
CCamBurstThumbnailGrid* self = new( ELeave ) CCamBurstThumbnailGrid( aModel );
CleanupStack::PushL( self );
self->ConstructL( aParent );
CleanupStack::Pop();
return self;
}
// Destructor
CCamBurstThumbnailGrid::~CCamBurstThumbnailGrid()
{
delete iBitmapMark;
delete iBitmapMarkMask;
// Remove notification of Deletion and new Thumbnail events
iModel.RemoveModelObserver( this, CCamBurstThumbnailGridModel::EModelEventDeleted |
CCamBurstThumbnailGridModel::EModelEventThumb );
DeleteScrollBar();
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::Draw
// The control's drawing function
// -----------------------------------------------------------------------------
//
void CCamBurstThumbnailGrid::Draw( const TRect& aRect ) const
{
PRINT( _L("Camera => CCamBurstThumbnailGrid::Draw") );
CWindowGc& gc = SystemGc();
// Draw skin background
MAknsSkinInstance* skin = AknsUtils::SkinInstance();
MAknsControlContext* cc = AknsDrawUtils::ControlContext( this );
AknsDrawUtils::Background( skin, cc, gc, Rect() );
TInt index = 0;
TInt visibleIndex = iModel.TopLeftGridIndex(); // first visible item index
TInt y = 0;
TInt x = 0;
for ( y = 0; y < iModel.GridHeight(); y++ ) // height of visible grid
{
for ( x = 0; x < KGridWidth; x++ )
{
if ( visibleIndex >= iModel.NoOfValidCells() )
{
break; // only breaks the inner for-loop
}
// Draw the outline rectangle for the Cell
//gc.SetPenColor( KGreyOutline ); // From the screenshot
TRect r = iGridCellLayout[ index ].iCellRect.Rect();
// draw background highlight for the focused item
if ( iModel.HighlightedGridIndex() == visibleIndex )
{
#ifdef _DEBUG
TRect _cell = iGridCellLayout[ index ].iCellRect.Rect();
TRect _high = iGridCellLayout[ index ].iHighRect.Rect();
TRect _thmb = iGridCellLayout[ index ].iThmbRect.Rect();
PRINT4( _L("Camera <> CCamBurstThumbnailGrid - grid cell rect[x:%d y:%d w:%d h%d]"),
_cell.iTl.iX, _cell.iTl.iY, _cell.Width(), _cell.Height() );
PRINT4( _L("Camera <> CCamBurstThumbnailGrid - highlight rect[x:%d y:%d w:%d h%d]"),
_high.iTl.iX, _high.iTl.iY, _high.Width(), _high.Height() );
PRINT4( _L("Camera <> CCamBurstThumbnailGrid - thumbnail rect[x:%d y:%d w:%d h%d]"),
_thmb.iTl.iX, _thmb.iTl.iY, _thmb.Width(), _thmb.Height() );
#endif // _DEBUG
TRgb highlight;
AknsUtils::GetCachedColor( skin, highlight, KAknsIIDQsnHighlightColors,
EAknsCIQsnHighlightColorsCG1 );
PRINT1( _L("Camera <> CCamBurstThumbnailGrid::Draw - highlight color: 0x%08x"), highlight.Internal() );
gc.SetBrushColor( highlight );
gc.Clear( r );
}
CThumbnailGridItem* item = iModel.GridItem( visibleIndex );
if ( item )
{
TRect trgRect( iGridCellLayout[ index ].iThmbRect.Rect() );
if ( item->iDisplayThumb )
{
PRINT( _L("Camera <> CCamBurstThumbnailGrid::Draw - prescaled thumb available") );
// Thumbnail grid sizer provides an image that fits
// to the given rect by one dimension and is larger in the other.
// (If aspect ratios don't match.) Crop the oversize area.
gc.SetClippingRect( trgRect );
const TSize& bmpSize( item->iDisplayThumb->SizeInPixels() );
PRINT2( _L("Camera <> CCamBurstThumbnailGrid - bmp size [w:%d h%d]"),
bmpSize.iWidth, bmpSize.iHeight );
PRINT2( _L("Camera <> CCamBurstThumbnailGrid - cell size [w:%d h%d]"),
trgRect.Width(), trgRect.Height() );
// Move the start of drawing so, that the image stays centered to the available area.
TInt widthDif = bmpSize.iWidth - trgRect.Width();
TInt heightDif = bmpSize.iHeight - trgRect.Height();
TPoint drawTl = trgRect.iTl - TPoint( widthDif/2, heightDif/2 );
PRINT2( _L("Camera <> CCamBurstThumbnailGrid - draw start offset [x:%d y%d]"),
widthDif, heightDif );
gc.BitBlt( drawTl, item->iDisplayThumb );
gc.SetClippingRect( aRect );
}
else // no rescaled bitmap exists, and we can fast-rescale snapshot
{
PRINT( _L("Camera <> CCamBurstThumbnailGrid::Draw - prescaled thumb NOT available") );
const CFbsBitmap* bmp = iModel.Snapshot( iModel.TopLeftGridIndex() + index );
if ( bmp )
{
TSize bmpSize( bmp->SizeInPixels() );
TRect srcRect( bmpSize );
TReal bmpRatio( TReal( bmpSize.iWidth ) / TReal( bmpSize.iHeight ) );
TReal trgRatio( TReal( trgRect.Width() ) / TReal( trgRect.Height() ) );
if( bmpRatio > trgRatio )
{
// Thumbnail aspect ratio is wider than the target cell area.
// Crop some of the thumbnail width off and fill the target rect.
const TInt width = Max( bmpSize.iHeight * trgRatio, 1 );
const TInt crop = ( bmpSize.iWidth - width ) / 2;
srcRect.Shrink( crop, 0 );
}
if( bmpRatio < trgRatio )
{
// Bitmap is higher than the screen.
// Crop some of the thumbnail height off and fill the target rect.
const TInt height = Max( bmpSize.iWidth * trgRatio, 1 );
const TInt crop = ( bmpSize.iHeight - height ) / 2;
srcRect.Shrink( 0, crop );
}
PRINT2( _L("Camera <> CCamBurstThumbnailGrid - bmp size [w:%d h%d]"),
bmpSize.iWidth, bmpSize.iHeight );
PRINT4( _L("Camera <> CCamBurstThumbnailGrid - bmp cropped [x:%d y:%d w:%d h%d]"),
srcRect.iTl.iX, srcRect.iTl.iY, srcRect.Width(), srcRect.Height() );
PRINT4( _L("Camera <> CCamBurstThumbnailGrid - trg rect [x:%d y:%d w:%d h%d]"),
trgRect.iTl.iX, trgRect.iTl.iY, trgRect.Width(), trgRect.Height() );
gc.DrawBitmap( trgRect, bmp, srcRect );
}
}
// Draw the marked symbol
if ( item->iMarked )
{
PRINT2(_L("CAMERA <> CCamBurstThumbnailGrid::Draw (item marked) x:%d y:%d"), x, y )
TRect mark = iGridCellLayout[ index ].iMarkRect.Rect();
gc.SetBrushStyle( CGraphicsContext::ENullBrush ); // Make sure background isn't drawn
gc.BitBltMasked( iGridCellLayout[ index ].iMarkRect.Rect().iTl,
iBitmapMark,
iBitmapMark->SizeInPixels(),
iBitmapMarkMask,
EFalse );
}
} // end of: if ( item )
index++;
visibleIndex++;
} // for x
} // for y
PRINT( _L("Camera <= CCamBurstThumbnailGrid::Draw") );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::CountComponentControls
// Returns the number of component controls
// ---------------------------------------------------------
//
TInt CCamBurstThumbnailGrid::CountComponentControls() const
{
TInt count = 0; // Return the number of controls inside this container
if ( iScrollFrame )
{
count = iScrollFrame->CountComponentControls();
}
return count;
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::SizeChanged
// Constructs the grid layout structure
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::SizeChanged()
{
PRINT( _L("Camera => CCamBurstThumbnailGrid::SizeChanged()") );
ReadLayout();
// set the new thumbnail size for gridmodel (to be used with thumbnail scaling)
// use layout for the first cell (all thumbnails are same size)
iModel.SetThumbnailSize( iGridCellLayout[0].iThmbRect.Rect().Size() );
AknIconUtils::SetSize( iBitmapMark, iGridCellLayout[0].iMarkRect.Rect().Size() );
AknIconUtils::SetSize( iBitmapMarkMask, iGridCellLayout[0].iMarkRect.Rect().Size() );
PRINT( _L("Camera <= CCamBurstThumbnailGrid::SizeChanged()") );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::ResourceId
// Returns the ID of the resource to use for the grid structure
// ---------------------------------------------------------
//
TInt CCamBurstThumbnailGrid::ResourceId()
{
TInt resource = 0;
if ( iModel.NoOfValidCells() > KSmallGridCellCount )
{
if ( !AknLayoutUtils::LayoutMirrored() )
{
resource = R_CAM_BURST_POST_CAPTURE_GRID_ARRAY;
}
else
{
resource = R_CAM_BURST_POST_CAPTURE_GRID_ARRAY;
}
}
else // Else six or less image to be used
{
if ( !AknLayoutUtils::LayoutMirrored() )
{
resource = R_CAM_BURST_POST_CAPTURE_GRID_ARRAY_UPTO_SIX;
}
else
{
resource = R_CAM_BURST_POST_CAPTURE_GRID_ARRAY_UPTO_SIX_AH;
}
}
return resource;
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::ReadLayoutL
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::ReadLayout()
{
PRINT( _L("Camera => CCamBurstThumbnailGrid::ReadLayout() ") );
TInt layoutVariantForThumbnail = 0;
TInt layoutVariantForCell = 1;
if ( iModel.NoOfValidCells() <= KBurstGridDefaultThumbnails)
{
layoutVariantForThumbnail = 0;
layoutVariantForCell = 1;
}
else if ( iModel.NoOfValidCells() <= KBurstGridMaxVisibleThumbnails )
{
layoutVariantForThumbnail = 1;
layoutVariantForCell = 3;
}
else // iModel.NoOfValidCells() > KBurstGridMaxVisibleThumbnails
{
layoutVariantForThumbnail = 2;
layoutVariantForCell = 5;
}
TInt i = 0;
TInt y = 0;
TInt x = 0;
// set all layout entries for cells
for ( y = 0; y < iModel.GridHeight(); y++ )
{
for ( x = 0; x < KGridWidth; x++ )
{
iGridCellLayout[i].iCellRect.LayoutRect( Rect(),
AknLayoutScalable_Apps::cell_cam4_burst_pane( layoutVariantForCell, x, y ) );
iGridCellLayout[i].iThmbRect.LayoutRect( iGridCellLayout[i].iCellRect.Rect(),
AknLayoutScalable_Apps::cell_cam4_burst_pane_g1( layoutVariantForThumbnail, 0, 0 ) );
iGridCellLayout[i].iMarkRect.LayoutRect( iGridCellLayout[i].iThmbRect.Rect(),
AknLayoutScalable_Apps::cell_cam4_burst_pane_g2( layoutVariantForThumbnail ) );
i++;
}
}
PRINT( _L("Camera <= CCamBurstThumbnailGrid::ReadLayout() ") );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::ComponentControl
// Returns the requested component control
// ---------------------------------------------------------
//
CCoeControl* CCamBurstThumbnailGrid::ComponentControl( TInt aIndex ) const
{
if ( iScrollFrame )
{
return iScrollFrame->ComponentControl( aIndex );
}
else
{
return NULL;
}
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::ThumbnailGenerated
// Called when a thumbnail has been scaled
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::ThumbnailGenerated()
{
DrawDeferred();
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::HandleScrollEventL
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::HandleScrollEventL( CEikScrollBar* aScrollBar, TEikScrollEvent aEventType )
{
// compare to old position, set correct starting point for drawing the grid
TInt numOfRows = ( iModel.NoOfValidCells() / KGridWidth ) ;
if ( iModel.NoOfValidCells() % KGridWidth != 0 )
{
numOfRows++;
}
TInt oldRow = ( iModel.TopLeftGridIndex() / KGridWidth );
if ( iModel.TopLeftGridIndex() % KGridWidth != 0 )
{
oldRow++;
}
TInt newRow = aScrollBar->ThumbPosition();
PRINT1( _L("Camera <> CCamBurstThumbnailGrid::HandleScrollEventL - thumb postition %d"), newRow );
if ( oldRow != newRow )
{
iModel.ScrollGrid( ETrue, newRow);
DrawDeferred();
}
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::ImagesDeleted
// Called when one or more images have been deleted
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::ImagesDeleted()
{
// Check if scrollbar frame exists, and if it's currently visible, and
// we now have only enough elements for one screen, then hide the bar
if ( iScrollFrame &&
iScrollFrame->ScrollBarVisibility( CEikScrollBar::EVertical ) == CEikScrollBarFrame::EOn )
{
if ( iModel.NoOfValidCells() <= iGridSize )
{
DeleteScrollBar();
}
else // Check if need to adjust scrollbar proportions
{
// This will adjust the proportions
TRAPD( ignore, SetupScrollbarL() );
if ( ignore )
{
// Do nothing ( removes build warning )
}
}
}
if ( iModel.NoOfValidCells() <= KBurstGridMaxVisibleThumbnails )
{
UpdateLayout();
// draw parent because size of the control might have been changed
Parent()->DrawDeferred();
}
DrawDeferred();
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::OfferKeyEventL
// Handles key events
// -----------------------------------------------------------------------------
//
TKeyResponse CCamBurstThumbnailGrid::OfferKeyEventL( const TKeyEvent& aKeyEvent, TEventCode aType )
{
TInt startTopIndex = iModel.TopLeftGridIndex();
if ( aType == EEventKey )
{
TBool changed = EFalse;
switch ( aKeyEvent.iScanCode )
{
case EStdKeyUpArrow:
{
if ( iModel.MoveHighlight( CCamBurstThumbnailGridModel::EMoveSelectUp ) )
{
changed = ETrue;
}
break;
}
case EStdKeyDownArrow:
{
if ( iModel.MoveHighlight( CCamBurstThumbnailGridModel::EMoveSelectDown ) )
{
changed = ETrue;
}
break;
}
case EStdKeyLeftArrow:
{
CCamBurstThumbnailGridModel::TMoveSelect direction;
if ( !AknLayoutUtils::LayoutMirrored() )
{
direction = CCamBurstThumbnailGridModel::EMoveSelectLeft;
}
else
{
direction = CCamBurstThumbnailGridModel::EMoveSelectRight;
}
if ( iModel.MoveHighlight( direction ) )
{
changed = ETrue;
}
break;
}
case EStdKeyRightArrow:
{
CCamBurstThumbnailGridModel::TMoveSelect direction;
if ( !AknLayoutUtils::LayoutMirrored() )
{
direction = CCamBurstThumbnailGridModel::EMoveSelectRight;
}
else
{
direction = CCamBurstThumbnailGridModel::EMoveSelectLeft;
}
if ( iModel.MoveHighlight( direction ) )
{
changed = ETrue;
}
break;
}
default:
{
break;
}
} // end of switch
// Update scroll bar if visible screen proportions changed
if ( iScrollFrame )
{
// Work out whether the 3x2 view has moved
TInt endTopIndex = iModel.TopLeftGridIndex();
TInt indexDiff = endTopIndex - startTopIndex;
if ( indexDiff != 0 )
{
iScrollFrame->MoveVertThumbTo( endTopIndex / KGridWidth );
}
}
// If a change was made, update the display
if ( changed )
{
DrawDeferred();
}
}
return EKeyWasNotConsumed;
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::SetupScrollbarL
// Checks if a scroll bar is needed, and if so, creates one.
// -----------------------------------------------------------------------------
//
void CCamBurstThumbnailGrid::SetupScrollbarL()
{
PRINT(_L("Camera => CCamBurstThumbnailGrid::SetupScrollbarL()") );
__ASSERT_DEBUG( iScrollFrame, CamPanic( ECamPanicNullPointer ) );
// Work out the number of scrollable rows we need. Take into account
// the rounding errors with integer maths with a modulus check too.
TInt numOfRows = ( iModel.NoOfValidCells() / KGridWidth ) ;
if ( iModel.NoOfValidCells() % KGridWidth != 0 )
{
numOfRows ++;
}
TInt startRow = ( iModel.TopLeftGridIndex() / KGridWidth );
if ( iModel.TopLeftGridIndex() % KGridWidth != 0 )
{
startRow ++;
}
iScrollFrame->SetScrollBarVisibilityL( CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOn );
// Set up the model accordingly
ivModel.SetScrollSpan( numOfRows );
ivModel.SetFocusPosition( startRow );
ivModel.SetWindowSize( iModel.GridHeight() );
iScrollFrame->CreateDoubleSpanScrollBarsL( ETrue, EFalse ); // was true, false
TRect rect = iScrollLayout.Rect();
iScrollFrame->Tile( &ivModel, rect );
iScrollFrame->MoveVertThumbTo( startRow );
PRINT(_L("Camera <= CCamBurstThumbnailGrid::SetupScrollbarL()") );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::DeleteScrollBar
// Hides and deletes the scrollbar frame
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::DeleteScrollBar()
{
if ( iScrollFrame )
{
// Hide the scrollbar
TRAPD( ignore, iScrollFrame->SetScrollBarVisibilityL(
CEikScrollBarFrame::EOff,
CEikScrollBarFrame::EOff ) );
if ( ignore )
{
// Do nothing ( removes build warning )
}
}
// Delete the frame
delete iScrollFrame;
iScrollFrame = NULL;
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::CreateScrollBarL
// Creates the scrollbar frame object
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::CreateScrollBarL()
{
// Create scrollbar frame
iScrollFrame = new ( ELeave ) CEikScrollBarFrame( this, this, ETrue );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::GridSize
// Returns the height of the thumbnail grid, in cells
// ---------------------------------------------------------
//
TInt CCamBurstThumbnailGrid::GridSize() const
{
return iGridSize;
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::UpdateLayout()
// Updates layouts. Used to reload layouts when images are deleted.
// ---------------------------------------------------------
//
void CCamBurstThumbnailGrid::UpdateLayout()
{
TInt gridSize = iModel.NoOfValidCells();
TRect mainPaneRect;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane,
mainPaneRect );
TRect statusPaneRect;
AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EStatusPane,
statusPaneRect );
// layout area rectangle contains the area, where components need to be
// drawn to. the container size is the whole screen, but the layouts are
// for the client area. aRect is the container size that might include or
// might not include statuspane area. calculating area self will
// go around the problem
TRect layoutAreaRect;
layoutAreaRect = mainPaneRect;
layoutAreaRect.BoundingRect( statusPaneRect );
// CCamAppUi* appUi = static_cast<CCamAppUi*>( iEikonEnv->AppUi() );
TAknLayoutRect burstPaneRect;
if ( CamUtility::IsNhdDevice() )
{
// use layoutAreaRect for nhd (contains the statuspane)
burstPaneRect.LayoutRect( layoutAreaRect, AknLayoutScalable_Apps::main_cam4_burst_pane() );
// SetRect( layoutAreaRect );
}
else
{
// use mainpane for vga
burstPaneRect.LayoutRect( mainPaneRect, AknLayoutScalable_Apps::main_cam4_burst_pane() );
// SetRect( mainPaneRect );
}
TRect rect;
if ( gridSize <= KBurstGridDefaultThumbnails)
{
AknLayoutUtils::LayoutControl( this,
burstPaneRect.Rect(),
AknLayoutScalable_Apps::grid_cam4_burst_pane(1) );
}
else if ( gridSize <= KBurstGridMaxVisibleThumbnails )
{
AknLayoutUtils::LayoutControl( this,
burstPaneRect.Rect(),
AknLayoutScalable_Apps::grid_cam4_burst_pane(3) );
}
else
{
AknLayoutUtils::LayoutControl( this,
burstPaneRect.Rect(),
AknLayoutScalable_Apps::grid_cam4_burst_pane(5) );
}
// set scrollbar layout
iScrollLayout.LayoutRect( burstPaneRect.Rect(),
AknLayoutScalable_Apps::scroll_pane_cp30(1) );
ReadLayout();
// set the new thumbnail size for gridmodel (to be used with thumbnail scaling)
// use layout for the first cell (all thumbnails are same size)
iModel.SetThumbnailSize( iGridCellLayout[0].iThmbRect.Rect().Size() );
AknIconUtils::SetSize( iBitmapMark, iGridCellLayout[0].iMarkRect.Rect().Size() );
AknIconUtils::SetSize( iBitmapMarkMask, iGridCellLayout[0].iMarkRect.Rect().Size() );
}
// ---------------------------------------------------------
// CCamBurstThumbnailGrid::HitTestGridItems( TPoint aPosition )
// returns the grid item index that the position corresponds
// if position does not match to any grid item return value is negative
// ---------------------------------------------------------
TInt CCamBurstThumbnailGrid::HitTestGridItems( const TPoint aPosition )
{
TInt retVal = -1;
for ( TInt i = 0; i < KGridSize; i++ )
{
if ( iGridCellLayout[i].iCellRect.Rect().Contains( aPosition ) )
{
retVal = i;
break;
}
} // end for
// check if the scrollbar position affects to the grid item index
if ( iScrollFrame )
{
retVal = retVal + iScrollFrame->VerticalScrollBar()->ThumbPosition()*KGridWidth;
}
return retVal < iModel.NoOfValidCells() ? retVal : -1;
}
// -----------------------------------------------------------------------------
// CCamBurstThumbnailGrid::HighlightChanged
// Sets the grid to be redrawn
// -----------------------------------------------------------------------------
//
void CCamBurstThumbnailGrid::HighlightChanged()
{
// does nothing at the moment
}
// ---------------------------------------------------------
// TCamBurstGridCellLayout::ConstructFromResource
// Constructs the layout entries from the specified resource
// ---------------------------------------------------------
//
void TCamBurstGridCellLayout::ConstructFromResource( TResourceReader& aReader, TRect& aRect )
{
iCellRect.LayoutRect( aRect, aReader );
iHighRect.LayoutRect( aRect, aReader );
iMarkRect.LayoutRect( aRect, aReader );
iThmbRect.LayoutRect( aRect, aReader );
}
// End of File