/*

* 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:  View class to display a thumbnail grid after burst capture*

*/

// INCLUDE FILES

#include <eikmenub.h>

#include <StringLoader.h>       

#include <AknQueryDialog.h>

#include <TSendingCapabilities.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <sendnorm.rsg>

#include <sendui.h>

#include <SenduiMtmUids.h>

#include <CMessageData.h>

#include <aknlayoutscalable_apps.cdl.h> // AknLayoutScalable_Apps

//#include <SFIUtilsAppInterface.h>

#include <aknnotewrappers.h>  // CAknInformationNote

#include <akntoolbar.h> // CAknToolbar

#include <aknbutton.h>

#include <eiksoftkeypostingtransparency.h> // EikSoftkeyPostingTransparency

#include "CamAppUi.h"

#include "CamUtility.h"

//#include "camproductvariant.h"

#include "CamBurstThumbnailView.h"

#include "CamAppUiBase.h"

#include "CamBurstThumbnailContainer.h"

#include "Cam.hrh"

#include "CamBurstThumbnailGridModel.h"

#include "CamBurstThumbnailGrid.h"

#include "CamBurstCaptureArray.h"

#include "camoneclickuploadutility.h"

#include "CameraUiConfigManager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamBurstThumbnailViewTraces.h"

#endif

//CONSTANTS

_LIT( KCamImageMimeType, "image/jpeg" );

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

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

// CCamBurstThumbnailView::NewLC

// Symbian OS two-phased constructor

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

//

CCamBurstThumbnailView* CCamBurstThumbnailView::NewLC( CCamAppController& aController )

    {

    CCamBurstThumbnailView* self = 

        new( ELeave ) CCamBurstThumbnailView( aController );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CCamBurstThumbnailView destructor

// 

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

//

CCamBurstThumbnailView::~CCamBurstThumbnailView()

  {

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

  // Free some space by deleting the model

  delete iGridModel;

  // NOTE: iAiwServiceHandler owned and deleted by base class

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

  }

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

// CCamBurstThumbnailView::Id

// Returns UID of view

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

//

TUid CCamBurstThumbnailView::Id() const

    {

    return TUid::Uid( ECamViewIdBurstThumbnail );

    }

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

// CCamBurstThumbnailView::DynInitMenuPaneL

// Changes MenuPane dynamically

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

//

void CCamBurstThumbnailView::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    PRINT( _L("Camera => CCamBurstThumbnailView::DynInitMenuPaneL"))

    // initializes the aiw service parameters for aiw commands

    DynInitAiwMenuPaneL( aResourceId, aMenuPane );

    if ( iAiwServiceHandler )

        {

        // handle any AIW menu cascades

        if ( iAiwServiceHandler->HandleSubmenuL( *aMenuPane ) )

            {

            return;

            }

        }

    if ( aResourceId == R_CAM_BURST_THUMBNAIL_MENU )

        {

        // If there are >1 images marked remove the 

        // open image item.

        if ( iGridModel->NoOfMarkedImages() > 1 )

            {

            aMenuPane->SetItemDimmed( ECamCmdOpenPhoto, ETrue );

            TInt itemPos = 0;

            if( aMenuPane->MenuItemExists( KAiwCmdUpload, itemPos ) )

                {

                PRINT( _L("Camera => CCamBurstThumbnailView::DynInitMenuPaneL SetItemDimmed: KAiwCmdUpload"))

                aMenuPane->SetItemDimmed(

                    KAiwCmdUpload, ETrue );

                }

            if( aMenuPane->MenuItemExists( ECamCmdShareOnOvi, itemPos ) )

                {

                PRINT( _L("Camera => CCamBurstThumbnailView::DynInitMenuPaneL SetItemDimmed: ECamCmdShareOnOvi"))

                aMenuPane->SetItemDimmed(

                    ECamCmdShareOnOvi, ETrue );

                }

            }

        // In touch ui the delete option is available on the fixed toolbar

        // there is no need to display it in the options menu

        if ( iController.IsTouchScreenSupported() )

            {

            TInt itemPos = 0;

            if ( aMenuPane->MenuItemExists( ECamCmdDelete, itemPos ) )

                {

                aMenuPane->SetItemDimmed( ECamCmdDelete, ETrue );

                }

            }

        } // ends: if ( aResourceId == R_CAM_BURST_THUMBNAIL_MENU )

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

    if ( aResourceId == R_CAM_BURST_THUMBNAIL_MENU ||

         aResourceId == R_CAM_BURST_THUMBNAIL_OK_MENU )

        {

        TBool showSend = ETrue;

        TBool showSendToCaller = EFalse;

/*#ifndef __WINS__

        if ( iSFIUtils->IsCLIValidL() )

            {

            showSend = EFalse;

            showSendToCaller = ETrue;

            if ( iGridModel->NoOfMarkedImages() > 1 )

                {

                // Send to caller is disabled if multiple images

                // have been marked.

                showSendToCaller = EFalse;

                }

            }

#endif*/

        if ( iController.IsTouchScreenSupported() &&

             !iOneClickUploadUtility->OneClickUploadSupported() &&

             aResourceId == R_CAM_BURST_THUMBNAIL_MENU )

            {

            // In touch UI, when one click upload is not supported,

            // there will be a Send button in the fixed toolbar. Options

            // menu items are not needed. Send is kept in the context menu.

            showSend = EFalse;

            showSendToCaller = EFalse;

            }

        TInt itemPos = 0;

        if( aMenuPane->MenuItemExists( ECamCmdSendToCallerMultimedia, itemPos ) )

            {

            aMenuPane->SetItemDimmed(

                ECamCmdSendToCallerMultimedia, !showSendToCaller );

            }

        if( aMenuPane->MenuItemExists( ECamCmdSend, itemPos ) )

            {

            aMenuPane->SetItemDimmed(

                ECamCmdSend, !showSend );

            }

        }

    if ( aResourceId == R_AVKON_MENUPANE_MARKABLE_LIST_IMPLEMENTATION )

        {

        if ( iGridModel->IsMarkedL( iGridModel->HighlightedGridIndex() ) )

            {

            // If marked, hide the MARK option

            aMenuPane->SetItemDimmed( EAknCmdMark, ETrue );

            }

        else

            {

            // If unmarked, hide the UNMARK option

            aMenuPane->SetItemDimmed( EAknCmdUnmark, ETrue );        

            }

        if ( iGridModel->NoOfMarkedImages() == 0 )

            {

            // If NO marked cells, hide the UNMARK ALL option

            aMenuPane->SetItemDimmed( EAknUnmarkAll, ETrue );        

            }

        if ( iGridModel->NoOfMarkedImages() == iGridModel->NoOfValidCells() )

            {

            // If ALL cells are marked, hide the MARKALL option

            aMenuPane->SetItemDimmed( EAknMarkAll, ETrue ); 

            }    

        }    

    PRINT( _L("Camera <= CCamBurstThumbnailView::DynInitMenuPaneL"))

    }   

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

// CCamBurstThumbnailView::HandleCommandL

// Handle commands

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

//

void CCamBurstThumbnailView::HandleCommandL( TInt aCommand )

    {

    PRINT1( _L("Camera => CCamBurstThumbnailView::HandleCommandL (aCommand: %d)"), aCommand )

    // sometimes commands come even after DoDeactivate() has been called.

    // this makes sure that those are ignored.

    if ( iGridModel == NULL )

        {

        return;

        }

    switch ( aCommand )

        {

        case ECamCmdOneClickUpload:

            {

            TInt markedItems = iGridModel->NoOfMarkedImages();

            // If there are no images marked use the highlighted image

            // set it now for safety just in case no marked images are found

            iController.SetAsCurrentImage(

                    iGridModel->HighlightedBurstIndex() );

            if ( markedItems > 0 )

                {

                // Upload marked images

                CDesC16ArrayFlat* fileNames =

                    new ( ELeave ) CDesC16ArrayFlat( markedItems );

                CleanupStack::PushL( fileNames );

                for ( TInt i = 0; i < iGridModel->NoOfImages(); i++ )

                    {

                    if ( iGridModel->IsMarkedL( i ) )

                        {

                        fileNames->AppendL( iGridModel->ImageFileName( i ) );

                        }

                    }

                iOneClickUploadUtility->UploadL(

                        *fileNames );

                CleanupStack::PopAndDestroy( fileNames );

                }

            else

                {

                // Upload highlighted image

                iOneClickUploadUtility->UploadL(

                        iController.CurrentFullFileName() );

                }

            break;

            }

        case ECamCmdRenameImage:

            {

            iController.SetAsCurrentImage( 

                iGridModel->ConvertFromValidToGlobalIndex (

                    SingleSelectionGridIndexL() ) );

            QueryRenameL( ECamControllerImage );

            break;

            }

        case ECamCmdDelete:        

            {

            if ( DisplayDeleteNoteL() )

                {

                DoDeleteL();

                }

            break;

            }

        case ECamCmdNewPhoto:

            {

            // the thumbnail scaling needs to be stopped in

            // preparation for the app ui switching the view

            iGridModel->CancelThumbnails();

            CCamViewBase::HandleCommandL( aCommand ); // Pass on to AppUi

            break;

            }

        case ECamCmdToolbarMarkUnmark:

            {

            TBool mark = iGridModel->IsMarkedL( iGridModel->HighlightedGridIndex() );                        

            iGridModel->SetCurrentMark( !mark );

      //      UpdateOneClickUploadButton();

            break;

            }

        case EAknCmdMark:        

            {

            iGridModel->SetCurrentMark( ETrue );

    //        UpdateOneClickUploadButton();

            break;

            }

        case EAknCmdUnmark:

            {

            iGridModel->SetCurrentMark( EFalse );

 //           UpdateOneClickUploadButton();

            break;

            }

        case EAknMarkAll:

            {

            iGridModel->MarkAll( ETrue );

  //          UpdateOneClickUploadButton();

            break;

            }

        case EAknUnmarkAll:

            {

            iGridModel->MarkAll( EFalse );

  //          UpdateOneClickUploadButton();

            break;

            }

        case EAknSoftkeyBack:

            {

            // the thumbnail scaling needs to be stopped in

            // preparation for the app ui switching the view

            iGridModel->CancelThumbnails();            

            // About to be closed by user, so will want to delete the model

            // on deactivation

            if ( IsForeground() )

                {

                iResetModelOnDeactivate = ETrue;    

                }

            CCamViewBase::HandleCommandL( aCommand ); // Pass on to AppUi

            break;

            }

        case ECamMSKCmdAppChange:

        case EAknSoftkeySelect:

            {   

            if ( iGridModel->NoOfMarkedImages() == 0 )

                {

                // select the focused item and open it to still postcapture

                iResetModelOnDeactivate = EFalse;   

                // This selects the highlighted image

                iController.SetAsCurrentImage( iGridModel->HighlightedGridIndex() );

                // ConvertFromValidToGlobalIndex used so that appropriate images are displayed

                iController.SetAsCurrentImage( iGridModel->ConvertFromValidToGlobalIndex( iGridModel->HighlightedGridIndex() ) );    

                CCamViewBase::HandleCommandL( ECamCmdOpenPhoto );

                }

            else    

                {   

                // If at least one image is marked, open context sensitive menu

                CEikMenuBar* menuBar = MenuBar();            

                if ( menuBar )

                    {

                    menuBar->SetMenuTitleResourceId( R_CAM_BURST_THUMBNAIL_OK_MENUBAR);

                    menuBar->SetMenuType( CEikMenuBar::EMenuContext );

                    menuBar->TryDisplayMenuBarL();

                    // Here we again set back the type of menu to "Options" when pressed LSK

                    menuBar->SetMenuType( CEikMenuBar::EMenuOptions );

                    menuBar->SetMenuTitleResourceId( R_CAM_BURST_THUMBNAIL_MENUBAR);

                    }

                }

            break;

            }

        case EAknSoftkeyOptions:

            {

            // do nothing - handled by the framework

            break;

            }

        case EAknSoftkeyCancel:

            {

            // do nothing - handled by framework

            break;

            }

        case ECamCmdSend:

            {

            CCamPostCaptureViewBase::HandleCommandL( aCommand );

            break;

            }

        case ECamCmdSendToCallerMultimedia:

            {

/*#ifndef __WINS__

            DoInCallSendL();

#endif*/

            }

            break;

		case ECamCmdQuickSend:

       		{

/*#ifndef __WINS__

            if( iSFIUtils->IsCLIValidL() )

                {

                // only do send to caller if no images are marked

                // or one image is marked

                if ( iGridModel->NoOfMarkedImages() < 2 )

                    {

                    DoInCallSendL();

                    }

                }

            else

#endif // __WINS__*/

                //{

                DoSendAsL();

                //}

            }

            break;            

       case ECamCmdExitStandby:

        	{

       		PRINT( _L("Camera :: CCamBurstThumbnailView::HandleCommandL ECamCmdExitStandby in") )	

        	CCamViewBase::ExitStandbyModeL();

        	PRINT( _L("Camera :: CCamBurstThumbnailView::HandleCommandL ECamCmdExitStandby out") )

        	break;

        	}

        case ECamCmdOpenPhoto:

            {

            iResetModelOnDeactivate = EFalse;   

            TInt markedItems = iGridModel->NoOfMarkedImages();

            // If there are no images marked use the highlighted image 

            // set it now for safety just in case no marked images are found

            iController.SetAsCurrentImage( iGridModel->HighlightedBurstIndex() );

            if ( markedItems != 0 )  // this command should never be available if there is >1 marked item

                {

                TInt totalItems = iGridModel->NoOfImages();

                TInt index = 0;

                TBool found = EFalse;

                while ( index < totalItems && !found )

                    {

                    if ( iGridModel->IsMarkedL( index ) )

                        {

                        found = ETrue;

                        iController.SetAsCurrentImage( index );

                        }

                    index++;

                    }

                }

            }

            //lint -fallthrough 

        default: 

            {

            // Handle AIW commands

            TInt aiwServiceCmd = iAiwServiceHandler->ServiceCmdByMenuCmd( aCommand );

            if ( aiwServiceCmd != KAiwCmdNone )

                {

                CAiwGenericParamList& inParams  = iAiwServiceHandler->InParamListL();

                CAiwGenericParamList& outParams = iAiwServiceHandler->OutParamListL();

                // Add file path/s to AIW parameters

                TInt markedItems = iGridModel->NoOfMarkedImages();

                // If there are no images marked use the highlighted image

                if ( markedItems == 0 )

                    {

                    TAiwVariant variant( iGridModel->ImageFileName( 

                                         iGridModel->HighlightedBurstIndex() ) );

                    TAiwGenericParam param( EGenericParamFile, variant );

                    inParams.AppendL( param );

                    // Set as contact call iamge needs image MIME type as AIW param

                    // Set as wall paper requires MIME type also.

                    TAiwVariant variant2(  KCamImageMimeType );

                    TAiwGenericParam param2( EGenericParamMIMEType, variant2 );

                    inParams.AppendL( param2 );

                    }

                else // there are marked items, add them to the list

                    {

                    TInt totalItems = iGridModel->NoOfImages();

                    TInt index = 0;

                    TInt found = 0;

                    while ( index < totalItems && found < markedItems )

                        {

                        if ( iGridModel->IsMarkedL( index ) )

                            {

                            found++;

                            TAiwVariant variant( iGridModel->ImageFileName( index ) );

                            TAiwGenericParam param( EGenericParamFile, variant );

                            inParams.AppendL( param );

                            // Set as contact call iamge needs image MIME type as AIW param

                            // Set as wall paper requires MIME type also.

                            TAiwVariant variant2(  KCamImageMimeType );

                            TAiwGenericParam param2( EGenericParamMIMEType, variant2 );

                            inParams.AppendL( param2 );

                            }

                        index++;

                        }

                    }

                iAiwServiceHandler->ExecuteMenuCmdL( aCommand, inParams, outParams, 0, this );

                }

            else

                {