diff -r 61bc0f252b2b -r bac7acad7cb3 camerauis/cameraapp/generic/src/CamBurstThumbnailGrid.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/camerauis/cameraapp/generic/src/CamBurstThumbnailGrid.cpp Wed Sep 01 12:30:54 2010 +0100 @@ -0,0 +1,835 @@ +/* +* 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 +#include +#include // For CEikScrollBar +#include // For CBitmapScaler +#include +#include +#include // For TResourceReader +#include +#include +#include +#include // EMbmAvkonQgn_indi_marked_grid_add + +#include +#include + +#include +#include +#include // 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( 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