/*

* 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 to model the contents of the burst post-capture view*

*/

// INCLUDE FILES

#include <fbs.h>     

#include <barsread.h>

#include <eikenv.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <StringLoader.h>

#include <aknnotewrappers.h>

#include "CamBurstThumbnailGridModel.h"

#include "CamBurstThumbnailGrid.h"

#include "CamBurstCaptureArray.h"

#include "camlogging.h"

#include "CamPanic.h"

// Uncommenting the define below will allow wrapping of the grid from the first

// element of the grid to the very last, and vice-versa.

#define ALLOW_GRID_WRAPPING

// ============================= LOCAL FUNCTIONS ===============================

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

CCamBurstThumbnailGridModel::CCamBurstThumbnailGridModel() 

    {

    }

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

// CCamBurstCaptureItem::NewL

// Two-phased constructor.

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

//

CCamBurstThumbnailGridModel* CCamBurstThumbnailGridModel::NewL()

    {

    CCamBurstThumbnailGridModel* self = new( ELeave ) CCamBurstThumbnailGridModel();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CCamBurstThumbnailGridModel::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCamBurstThumbnailGridModel::ConstructL()

    {

    iThumbSize.iWidth = 0;

    iThumbSize.iHeight = 0;

    iGridSizer = CCamThumbnailGridSizer::NewL( this, iThumbSize );        

    iTopLeftIndex = 0;

    }

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

// CCamBurstThumbnailGridModel::GridItem

// Returns pointer to the requested item, or NULL if index is invalid

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

//

CThumbnailGridItem* CCamBurstThumbnailGridModel::GridItem( TInt aIndex )

    {

    if ( aIndex >= iValidThumbGrid.Count() )

        {

        return NULL;

        }

    else 

        {

        return iValidThumbGrid[ aIndex ];

        }

    }

// Note: Returns ONLY non-deleted cells

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

// CCamBurstThumbnailGridModel::Snapshot

// Returns pointer to the requested item, or NULL if index is invalid

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

//

const CFbsBitmap* CCamBurstThumbnailGridModel::Snapshot( TInt aIndex )

    {

    if ( aIndex >= iValidThumbGrid.Count() )

        {

        return NULL;

        }

    else 

        {        

        TInt ind = ConvertFromValidToGlobalIndex( aIndex );

        if ( ind != KErrNotFound )

            {

            return iBurstArray->Snapshot( ind );

            }

        else 

            {

            return NULL;

            }

        }

    }

// Destructor

CCamBurstThumbnailGridModel::~CCamBurstThumbnailGridModel()

  {

  PRINT( _L("Camera => ~CCamBurstThumbnailGridModel") );

  if ( iGridSizer )

      {

      iGridSizer->Cancel();

      }

  delete iGridSizer;

  // Delete the array and the objects pointed to

  iAllThumbGrid.ResetAndDestroy();

  // Note: As this points to the same thing as the array above, just 

  // delete the array, not the objects

  iValidThumbGrid.Reset();

  // Do NOT destroy the objects pointed to, just the list.

  iThumbObserver.Reset();     

  iHighlightObserver.Reset();

  iDeleteObserver.Reset();

  PRINT( _L("Camera <= ~CCamBurstThumbnailGridModel") );

  }

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

// CCamBurstThumbnailGridModel::AddCellL

// Adds the cell to the internal structures.  Takes ownership of the cell.

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

//

void CCamBurstThumbnailGridModel::AddCellL( CThumbnailGridItem* aCell )

    {

    // Add to the master list of grid items

    User::LeaveIfError( iAllThumbGrid.Append( aCell ) );

    // Add to the list of VALID (non deleted) grid items

    User::LeaveIfError( iValidThumbGrid.Append( aCell ) );

    }

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

// CCamBurstThumbnailGridModel::StartThumbnailL

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

//

void CCamBurstThumbnailGridModel::StartThumbnailL( TInt aIndex )

    {        

    // Burst array may be released by the app when swicthing

    // views so do a check that it is still valid

    if ( iBurstArray )

        {

        const CFbsBitmap* source = iBurstArray->Snapshot( aIndex );

        if ( source )

            {

            iGridSizer->StartScaleL( *source, iThumbSize, aIndex );

            }

        }

    }

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

// CCamBurstThumbnailGridModel::CancelThumbnails

// Cancels any outstanding thumbnail generation operation

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

//

void CCamBurstThumbnailGridModel::CancelThumbnails()

    {

    if ( iGridSizer->IsActive() )

        {

        iGridSizer->Cancel();

        }

    }    

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

// CCamBurstThumbnailGridModel::ImageFilesDeletedL

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

//

void CCamBurstThumbnailGridModel::ImageFilesDeleted()

    {

    TBool highlightDeleted = EFalse;

    TInt highlightIndex = ConvertFromValidToGlobalIndex( iCurrHighlight );

    for ( TInt i = 0; i < iBurstArray->Count(); i++ )

        {

        if ( iBurstArray->IsDeleted( i ) )

            {

            if ( highlightIndex == i )

                {

                highlightDeleted = ETrue;

                }

            TRAPD( error, DeleteItemL( i ) );

            // DeleteItemL() leaves only when file can't be deleted and that should never

            // happen here as the files are already deleted

            __ASSERT_DEBUG( error == KErrNone, CamPanic( ECamPanicUi ) );

            error++; // remove compile warnings

            }

        }

    DoPostDeleteGridCheck( highlightDeleted );

    }

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

// CCamThumbnailGridSizer::SetThumbnailSize

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

//

void CCamBurstThumbnailGridModel::SetThumbnailSize( const TSize aThumbSize )

    {

    if ( aThumbSize != iThumbSize )

        {

        iThumbSize = aThumbSize;

		iGridSizer->SetSize( iThumbSize );

        // delete all thumbs because size has changed and they need to be regenerated

        TInt imagesRemaining = iBurstArray->ImagesRemaining();

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

            {

            // delete display thumbnail

            delete iValidThumbGrid[i]->iDisplayThumb;

            iValidThumbGrid[i]->iDisplayThumb = NULL;   

            }

        // recalculate needed thumbs

        RecalculateThumbs();

        }

    }

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

// CCamBurstThumbnailGridModel::BitmapScaleCompleteL

// Callback called when a bitmap scaling operation has completed.

// We take ownership of the 'aBitmap' object

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

//

void CCamBurstThumbnailGridModel::BitmapScaleCompleteL( TInt aErr, CFbsBitmap* aBitmap, TInt32 aInfo )

    {

    if ( aErr == KErrNone )

        {       

        // Update internal structure

        CThumbnailGridItem* item = iAllThumbGrid[aInfo];

        item->iDisplayThumb = aBitmap;

        // Inform observer(s) to ensure the screen is updated     

        NotifyModelObserver( EModelEventThumb );

        }    

    }      

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

// CCamBurstThumbnailGridModel::RecalculateThumbs

// Called to check which thumbnails need creating, and start the procedure

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

//

void CCamBurstThumbnailGridModel::RecalculateThumbs()

    {        

    // If in the grid below, items 3-8 were visible in the screen grid, 

    // items 0-2 and 9-11 would also have thumbnails generated to attempt

    // to reduce visible artifacts from calculating on the fly.

    //    [ 0 ][ 1 ][ 2 ]   <= Row above (not visible)

    //    [ 3 ][ 4 ][ 5 ]   <= First visible row

    //    [ 6 ][ 7 ][ 8 ]   <= Second visible row

    //    [ 9 ][ 10][ 11]   <= Row below (not visible)

    //

    // If we get to recalculate thumbnails, we need to cancel any outstanding 

    // rescale operation

    CancelThumbnails();

    // Work out the top left index. This is the top-left cell of the VIEWABLE

    // grid, less one row (which serves as a thumbnail cache)        

    TInt topLeftIndex = iTopLeftIndex - KGridWidth;

    if ( topLeftIndex < 0 )

        {

        topLeftIndex = 0;

        }

    // Work out the bottom right index. This is the bottom-right cell of the 

    // VIEWABLE grid, plus one row (which serves as a thumbnail cache)

    TInt botRightIndex = iTopLeftIndex + ( KGridWidth * iGridHeight ) - 1 + KGridWidth;

    if ( botRightIndex > iValidThumbGrid.Count() - 1 )

        {

        botRightIndex = iValidThumbGrid.Count() - 1;

        }

    // Delete the thumbnails for cells that are not immediately visible, and are

    // not in the next or last row.

    TInt i;

    TInt imagesRemaining = iBurstArray->ImagesRemaining();

    for ( i = 0; i < imagesRemaining; i++ )

        {

        if ( ( i < topLeftIndex || i > botRightIndex ) &&

            iValidThumbGrid[i]->iDisplayThumb ) 

            {

            // delete display thumbnail

            delete iValidThumbGrid[i]->iDisplayThumb;

            iValidThumbGrid[i]->iDisplayThumb = NULL;   

            }

        }

    // Queue up the thumbnails that need to be resized

    TRAPD( ignore, QueueThumbnailsL() );

    if ( ignore )

        { 

        // Do nothing ( removes build warning )

        }                   

    }

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

// CCamBurstThumbnailGridModel::QueueThumbnailsL

// Queues the thumbnails to be resized as needed

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

//

void CCamBurstThumbnailGridModel::QueueThumbnailsL()

    {

    //    [ 0 ][ 1 ][ 2 ]   <= Row above (not visible)

    //    [ 3 ][ 4 ][ 5 ]   <= First visible row

    //    [ 6 ][ 7 ][ 8 ]   <= Second visible row

    //    [ 9 ][ 10][ 11]   <= Row below (not visible)

    //    

    TInt start = iTopLeftIndex;

    TInt index = KErrNotFound; 

    TInt max = iTopLeftIndex + KGridSize;

    if ( max > iValidThumbGrid.Count() )

        {

        max = iValidThumbGrid.Count();

        }

    // Top priority is the set of thumbs visible AT THIS MOMENT

    TInt i;

    for ( i = start; i < max ; i++ )

        {

        if ( !iValidThumbGrid[i]->iDisplayThumb )

            {

            // If we get here, then 'i' is the index to the VALID set of items.

            // Need to convert this to the index in the GLOBAL set of items

            index = ConvertFromValidToGlobalIndex( i );

            StartThumbnailL( index );

            }

        }

    // SECOND top priority is the set of thumbs BELOW the visible set

    if ( iValidThumbGrid.Count() >= iTopLeftIndex + KGridSize ) 

        {

        start = iTopLeftIndex+KGridSize;

        max = i + KGridWidth;

        if ( max > iValidThumbGrid.Count() )

            {

            max = iValidThumbGrid.Count();

            }

        // If we have got here, we can cache the row *below* the 2nd visible row

        for ( i = start; i < max; i++ )

            {

            if ( !iValidThumbGrid[i]->iDisplayThumb )

                {

                // If we get here, then 'i' is the index to the VALID set of items.

                // Need to convert this to the index in the GLOBAL set of items

                index = ConvertFromValidToGlobalIndex( i );

                StartThumbnailL( index );

                }

            }

        }

    // THIRD priority is the set of thumbs ABOVE the visible set

    if ( iTopLeftIndex >= KGridWidth ) // ONLY if there IS a previous row

        {

        start = iTopLeftIndex - KGridWidth;

        max = iTopLeftIndex;

        // If we have got here, we can cache the row *above* this one.

        for ( i = start; i < max; i++ )

            {

            if ( !iValidThumbGrid[i]->iDisplayThumb )

                {

                // If we get here, then 'i' is the index to the VALID set of items.

                // Need to convert this to the index in the GLOBAL set of items

                index = ConvertFromValidToGlobalIndex( i );

                StartThumbnailL( index );

                }

            }

        }

    }

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

// CCamBurstThumbnailGridModel::ConvertFromValidToGlobalIndex

// Converts from a valid-index (non-deleted only) to global (del & non-del) index

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

//

TInt CCamBurstThumbnailGridModel::ConvertFromValidToGlobalIndex( TInt aValidIndex )   

    {       

    if ( aValidIndex < iValidThumbGrid.Count() )

        {

        CThumbnailGridItem* item = iValidThumbGrid[aValidIndex];

        return iAllThumbGrid.Find( item );    

        }

    else

        {

        return KErrNotFound;

        }

    }      

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

// CCamBurstThumbnailGridModel::SetBurstArrayL

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

//

void CCamBurstThumbnailGridModel::SetBurstArrayL( CCamBurstCaptureArray* aArray )

    {

    PRINT( _L("Camera => CCamBurstThumbnailGridModel::SetBurstArrayL") );

    // If we've not been initialised yet, and have no data, then use the array

    // just passed in.  

    if ( iAllThumbGrid.Count() == 0 )

        {

        iBurstArray = aArray;

        // Build up model to match burst array

        if ( iBurstArray )

            {

            TInt i;

            TInt count = iBurstArray->Count();

            PRINT1( _L("Camera <> got %d thumbnails"), count );

            // Create a set of items to match the number in the burst array

            for ( i = 0; i < count; i++ )

                {

                CThumbnailGridItem* item = new ( ELeave ) CThumbnailGridItem();

                CleanupStack::PushL( item );

                item->iDisplayThumb = NULL;

                item->iMarked = EFalse;

                AddCellL( item );

                CleanupStack::Pop( item );

                if ( !iBurstArray->Snapshot( i ) )

                    {

                    DeleteItemL( i );

                    }

                }

            // Setup the base grid height based on the number of items

            if ( NoOfValidCells() <= KSmallGridCellCount )

                {

                iGridHeight = KSmallGridHeight;

                }

            else 

                {

                iGridHeight = KLargeGridHeight;

                }

            // Start the generation of thumbnails

            RecalculateThumbs();

            }

        }

    PRINT( _L("Camera <= CCamBurstThumbnailGridModel::SetBurstArrayL") );

    }

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

// CCamBurstThumbnailGridModel::AddModelObserverL

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

//

void CCamBurstThumbnailGridModel::AddModelObserverL( MThumbModelObserver* aObserver, TInt aMask )

    {

    if ( aMask & EModelEventHighlight )

        {

        User::LeaveIfError( iHighlightObserver.Append( aObserver ) );

        }

    if ( aMask & EModelEventDeleted )

        {

        User::LeaveIfError( iDeleteObserver.Append( aObserver ) );

        }

    if ( aMask & EModelEventThumb )

        {

        User::LeaveIfError( iThumbObserver.Append( aObserver ) );

        }   

    }

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

// CCamBurstThumbnailGridModel::RemoveModelObserver

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

//

void CCamBurstThumbnailGridModel::RemoveModelObserver( MThumbModelObserver* aObserver, TInt aMask )

    {

    TInt pos;

    if ( aMask & EModelEventHighlight )

        {

        pos = iHighlightObserver.Find( aObserver );

        if ( pos != KErrNotFound )

            {

            iHighlightObserver.Remove( pos );

            }

        }

    if ( aMask & EModelEventDeleted )

        {

        pos = iDeleteObserver.Find( aObserver );

        if ( pos != KErrNotFound )

            {

            iDeleteObserver.Remove( pos );

            }

        }

    if ( aMask & EModelEventThumb )

        {

        pos = iThumbObserver.Find( aObserver );