/*

* 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:  Implementation of the mode setup pane handler class.

*

*  Copyright © 2007 Nokia.  All rights reserved.

*  This material, including documentation and any related computer

*  programs, is protected by copyright controlled by Nokia.  All

*  rights are reserved.  Copying, including reproducing, storing,

*  adapting or translating, any or all of this material requires the

*  prior written consent of Nokia.  This material also contains

*  confidential information which may not be disclosed to others

*  without the prior written consent of Nokia.

*

*

*/

#include <coemain.h>

#include <barsRead.h>

#include <stringloader.h>

#include "CamModeSetupPaneHandler.h"

#include "CamSetupPaneItemArray.h"

#include "CamSetupPane.h"

#include "CamSetupPaneItem.h"

#include "CamPreCaptureContainerBase.h"

#include "CamAppUi.h"

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

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

// CCamModeSetupPaneHandler::NewLC

// Part of the two-phase class construction.

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

//

CCamModeSetupPaneHandler* CCamModeSetupPaneHandler::NewLC( CCamAppController& aController )

	{

	CCamModeSetupPaneHandler* self = new( ELeave ) CCamModeSetupPaneHandler(aController);

	CleanupStack::PushL( self );

	self->ConstructL();

	return self;

	}

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

// CCamModeSetupPaneHandler::NewL

// Part of the two-phase class construction.

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

//

CCamModeSetupPaneHandler* CCamModeSetupPaneHandler::NewL( CCamAppController& aController )

	{

	CCamModeSetupPaneHandler* self = CCamModeSetupPaneHandler::NewLC( aController );

	CleanupStack::Pop(self);

	return self;

	}

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

// CCamModeSetupPaneHandler::CCamModeSetupPaneHandler

// C++ class constructor.

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

//

CCamModeSetupPaneHandler::CCamModeSetupPaneHandler( CCamAppController& aController )

 : iController( aController ),

   iPaneLevel( EMenuLevel )

	{

	}

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

// CCamModeSetupPaneHandler::ConstructL

// Carries out two-phase class construction.

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

//

void CCamModeSetupPaneHandler::ConstructL()

	{

    // Setup helper context    

    iLastCaptureHelper = iController.LastCaptureHelper();

    iLastCaptureHelper->SetPaneModel( this ); // register

	iCurrentSettingsArrayIndex = KErrNotFound; // Invalidate.		

	}

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

// CCamModeSetupPaneHandler::~CCamModeSetupPaneHandler

// C++ destructor.

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

//

CCamModeSetupPaneHandler::~CCamModeSetupPaneHandler()

  {

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

  ResetArray();

  iPaneControl = NULL; // Not owned.	

  if ( iLastCaptureHelper )

    {

    iLastCaptureHelper->SetPaneModel( NULL ); // de-register

    iLastCaptureHelper = NULL; // Not owned    

    }

  delete iLastCapTitle;

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

  }

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

// CCamModeSetupPaneHandler::ResetArray

// Deletes the contents of the settings item array

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

//

void CCamModeSetupPaneHandler::ResetArray()

    {

   	TInt i;

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

		{

		delete iSettingItems[i];

		iSettingItems[i] = NULL;

		}

    }

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

// CCamModeSetupPaneHandler::HandleEvent

// 

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

//

void CCamModeSetupPaneHandler::HandleEvent( TEvent aEvent )

    {

    switch ( aEvent )

        {

        case EEventSelect:

            {

    		// ASSERT(iPaneLevel == EItemLevel); // Should only get this event for item-level selections.

    		// Eventually need to handle commands from captureViewBase to open menu items.

    		// Let OK button open them for now...

    		if ( iPaneLevel == EItemLevel )

    			{

    			HandlePaneItemLevelSelection();

    			}

    		else

    			{

    			if ( iPaneLevel == EMenuLevel &&

    			     IconIsThumbnail( iHighlightedItemIndex ) )

    			    {

    			    HandleLastCaptureSelection();    

    			    }

    			else

    			    {

    			    HandlePaneMenuLevelSelection( iController.IntegerSettingValue( HighlightedItemId() ) );    

    			    }    		

    			}            

            break;            

            }

        case EEventCancel:

            {

            HandlePaneCancel();

            break;

            }

        case EEventLeft:

            {

            MoveToPreviousItem();

            break;

            }

        case EEventRight:

            {

            MoveToNextItem();

            break;

            }

        case EEventEditUser:

            {        

            SwitchToUserSceneView();

            break;

            }            

        default:

            {

            break;

            }

        }

    }

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

// CCamModeSetupPaneHandler::MoveToPreviousItem

// Changes the highlighted item to the previous one.

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

//

void CCamModeSetupPaneHandler::MoveToPreviousItem()

	{

	iPaneControl->ScrollToPreviousItem();

	iHighlightedItemIndex--;

	if ( iHighlightedItemIndex < 0 )

		{

		iHighlightedItemIndex = NumberOfItems() - 1;

		}

	HandlePaneItemChanged();

	}

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

// CCamModeSetupPaneHandler::MoveToNextItem

// Changes the highlighted item to the next one.

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

//

void CCamModeSetupPaneHandler::MoveToNextItem()

	{

	iPaneControl->ScrollToNextItem();

	iHighlightedItemIndex++;

	if ( iHighlightedItemIndex >= NumberOfItems() )

		{

		iHighlightedItemIndex = 0;

		}

	HandlePaneItemChanged();

	}

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

// CCamModeSetupPaneHandler::HighlightedItemId

// Returns the id of the currently highlighted item.

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

//

TInt CCamModeSetupPaneHandler::HighlightedItemId() const

	{

	if ( iPaneLevel == EMenuLevel )

		{

		return iMenuItemIds[iHighlightedItemIndex];

		}

	else

		{

		ASSERT( iPaneLevel == EItemLevel );

		ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

		return iSettingItems[iCurrentSettingsArrayIndex]->At( HighlightedItemIndex() )->Id();

		}

	}

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

// CCamModeSetupPaneHandler::NumberOfItems

// Returns the number of items in the current pane model.

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

//

TInt CCamModeSetupPaneHandler::NumberOfItems() const

	{

	if ( iPaneLevel == EMenuLevel )

		{		

		TInt items = iNoOfSettingsItems; 

		// Check if there is a "last capture" dynamic item to add

		if ( iLastCaptureHelper->IsThumbValid() )

		    {

		    items ++; // +1 for dynamic 'last picture taken' item

		    }

		return items;		    

		}

	else

		{

		ASSERT( iPaneLevel == EItemLevel );

		ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

		return iSettingItems[iCurrentSettingsArrayIndex]->Count();

		}

	}

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

// CCamModeSetupPaneHandler::TitleText

// Returns the current pane title text (for the highlighted pane item).

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

//

const TDesC& CCamModeSetupPaneHandler::TitleText() const

	{

	if ( iPaneLevel == EMenuLevel )

		{

		return iMenuTitles[iHighlightedItemIndex];

		}

	else

		{

		ASSERT( iPaneLevel == EItemLevel );

		ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

		return iMenuTitles[iCurrentSettingsArrayIndex];

		}

	}

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

// CCamModeSetupPaneHandler::DescriptorText

// Returns the current pane descriptor text (for the highlighted pane item).

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

//

const TDesC& CCamModeSetupPaneHandler::DescriptorText() const

	{

	if ( iPaneLevel == EMenuLevel )

		{

		if ( iHighlightedItemIndex < iNoOfSettingsItems )

			{

			const TInt settingVal = iController.IntegerSettingValue( HighlightedItemId() );

			const TInt index = iSettingItems[iHighlightedItemIndex]->ItemIndexFromItemId( settingVal );

			if ( index != KErrNotFound )

				{

				return iSettingItems[iHighlightedItemIndex]->At( index )->Text();

				}

			}

		else

			{

			ASSERT( iHighlightedItemIndex == iNoOfSettingsItems );

			// Return filename of last taken picture.

			return iLastCapName;

			}

		}

	else

		{

		ASSERT( iPaneLevel == EItemLevel );

		ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

		return iSettingItems[iCurrentSettingsArrayIndex]->At( iHighlightedItemIndex )->Text();

		}

	return KNullDesC; // All else failed.

	}

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

// CCamModeSetupPaneHandler::Icon

// Returns the icon for the given pane item index.

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

//

CGulIcon& CCamModeSetupPaneHandler::Icon( TInt aItemIndex )

	{

	ASSERT( aItemIndex >= 0  &&  aItemIndex < NumberOfItems() );

	if ( iPaneLevel == EMenuLevel )

		{

		if ( aItemIndex < iNoOfSettingsItems )

			{

			const TInt settingVal = iController.IntegerSettingValue( iMenuItemIds[aItemIndex] );

			const TInt index = iSettingItems[aItemIndex]->ItemIndexFromItemId( settingVal );

			if ( index != KErrNotFound )

				{

				return iSettingItems[aItemIndex]->At( index )->Icon();

				}			

			}

		}

	else

		{

		ASSERT( iPaneLevel == EItemLevel );

		ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

		return iSettingItems[iCurrentSettingsArrayIndex]->At( aItemIndex )->Icon();

		}

    // Must return something.				

    return iSettingItems[aItemIndex]->At( 0 )->Icon(); 

	}

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

// CCamModeSetupPaneHandler::Thumbnail

// Get the thumbnail (of specified size) for last captured icon

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

//

CGulIcon& CCamModeSetupPaneHandler::Thumbnail( TBool aSmall )

    {

    return *iLastCaptureHelper->Thumbnail( aSmall );

    }

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

// CCamModeSetupPaneHandler::IconIsThumbnail

// Returns whether item indicated by aItemIndex is the last captured thumbnail

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

//

TBool CCamModeSetupPaneHandler::IconIsThumbnail( TInt aItemIndex ) const

    {

    // Thumbnail is always the last item so check the specified index is the

    // last item.  Also check that the thumbnail is valid.

    if ( aItemIndex == iNoOfSettingsItems &&

         iPaneLevel == EMenuLevel &&

         iLastCaptureHelper->IsThumbValid() )

        {                

        return ETrue;

        }

    else 

        {

        return EFalse;

        }        

    }

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

// CCamModeSetupPaneHandler::HighlightedItemIndex

// Returns the currently highlighted pane item.

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

//

TInt CCamModeSetupPaneHandler::HighlightedItemIndex() const

	{

	return iHighlightedItemIndex;

	}

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

// CCamModeSetupPaneHandler::HandlePaneItemChanged

// Handles a change of the currently highlighted pane item.

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

//

void CCamModeSetupPaneHandler::HandlePaneItemChanged()

	{

	if ( iPaneLevel == EItemLevel )

		{

		HandlePaneItemLevelItemChanged();

		}

	}

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

// CCamModeSetupPaneHandler::HandlePaneItemLevelItemChanged

// Handles a change of the current item at the 'item' level.

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

//

void CCamModeSetupPaneHandler::HandlePaneItemLevelItemChanged()

	{

	ASSERT( iPaneLevel == EItemLevel );

	ASSERT( iCurrentSettingsArrayIndex != KErrNotFound );

    // Showing a Scene item requires the Options menu, and setting of the current highlighted item

    if ( ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoScene ) ||

         ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoScene )

         || ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemUserSceneBasedOnScene ) )    

        {

        CCamPreCaptureContainerBase* parent = static_cast<CCamPreCaptureContainerBase*>( iParent );	    

        parent->SetCurrentSetupPaneItem( HighlightedItemId() );

        }	

    else

        {        

        // Set the controller to preview the new setting.

        // This will either be comitted by a "Select" or reverted by a "Cancel"

        TRAPD( ignore, iController.PreviewSettingChangeL( iMenuItemIds[iCurrentSettingsArrayIndex], HighlightedItemId() ); )

        if ( ignore )

            { 

            // Do nothing ( removes build warning )

            }      

        }

	}

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

// CCamModeSetupPaneHandler::HandlePaneMenuLevelSelection

// Handles pane selections made at the 'menu' level.

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

//

void CCamModeSetupPaneHandler::HandlePaneMenuLevelSelection( TInt aValueToBeHighlighted )

	{

	ASSERT( iPaneLevel == EMenuLevel );

	if ( iHighlightedItemIndex < iNoOfSettingsItems )

		{

		iCurrentSettingsArrayIndex = iHighlightedItemIndex;

		iHighlightedItemIndex = iSettingItems[iCurrentSettingsArrayIndex]->ItemIndexFromItemId( aValueToBeHighlighted );

		iPaneLevel = EItemLevel;

		iPaneControl->HandleModelChanged();

        // Showing a Scene item requires the Options menu, and setting of the current highlighted item

		if ( ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoScene ) ||

		     ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoScene ) ||

	         ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemUserSceneBasedOnScene ) )

		    {		    

		    CCamPreCaptureContainerBase* parent = static_cast<CCamPreCaptureContainerBase*>( iParent );

		    parent->SetUseSetupPaneOptions( ETrue );

		    parent->SetCurrentSetupPaneItem( HighlightedItemId() );   

		    }			

		// Check whether the viewfinder should be active but masked to 

		// preview some settings values

		if ( iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoWhiteBalance ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoColourFilter ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoBrightness ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicPhotoContrast || 

             iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoWhiteBalance ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoColourFilter ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoBrightness ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemDynamicVideoContrast ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemUserSceneWhitebalance ||

		     iMenuItemIds[iCurrentSettingsArrayIndex] == ECamSettingItemUserSceneColourFilter

		     )		     

		    {

		    CCamPreCaptureContainerBase* parent = static_cast<CCamPreCaptureContainerBase*>( iParent );	    

            parent->SetViewFinderState( CCamPreCaptureContainerBase::EVfStateActiveMasked );

		    }		    

	    } 

	}

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

// CCamModeSetupPaneHandler::HandleLastCaptureSelection

// Handles user selection of the "LastCapture" thumbnail where available

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

//

void CCamModeSetupPaneHandler::HandleLastCaptureSelection()	

    {

    // Check we have a valid thumbnail

    if ( IconIsThumbnail( iHighlightedItemIndex ) )

	    {

	    // Need to fire off post capture view with the snapshot.

        TRAPD( err, iLastCaptureHelper->ShowPostCaptureViewL() );            

        if ( err == KErrNoMemory )

            {

            TRAPD( ignore, static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() )->ShowOOMNoteL() );

            if ( ignore )

                {       

                // Do nothing ( removes build warning )

                }

            }

        }    

    }

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