/*

* 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 )

        {