/*

* Copyright (c) 2007-2010 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:  Base class for pre capture views*

*/

// INCLUDE FILES

#include <eikmenub.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamCaptureSetupViewBase.h"

#include "CamAppUiBase.h"

#include "CamAppController.h"

#include "CamUtility.h"

#include "CamCaptureSetupControlHandler.h"

#include "CamCaptureSetupContainer.h"

#include "CamShootingModeContainer.h"

#include "CamInfoListBoxContainer.h"

#include "CamPanic.h"

#include "Cam.hrh"

#include "CamZoomPane.h"

#include "CamTimeLapseUtility.h"

#include "camactivepalettehandler.h"

#include "CamAppUi.h"

#include <akntoolbar.h>

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

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

// CCamPreCaptureViewBase destructor

// 

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

//

CCamCaptureSetupViewBase::~CCamCaptureSetupViewBase()

  {

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

  if( AppUi() )

    {

    if ( iCaptureSetupContainer )

      {

      AppUi()->RemoveFromStack( iCaptureSetupContainer );

      delete iCaptureSetupContainer;

      }

    if ( iSceneSettingContainer )

      {

      AppUi()->RemoveFromStack( iSceneSettingContainer );

      delete iSceneSettingContainer;

      iSceneSettingContainer = NULL;

      }

    if ( iInfoListBoxContainer )

      {

      AppUi()->RemoveFromStack( iInfoListBoxContainer );

      delete iInfoListBoxContainer;

      }        

    }

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

  }

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

// CCamCaptureSetupViewBase::HandleCommandL

// Handle commands

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

//

void CCamCaptureSetupViewBase::HandleCommandL( TInt aCommand )

    {

    PRINT( _L("Camera => CCamCaptureSetupViewBase::HandleCommandL") );

    TUid view = Id();

    TBool userSceneActive = ( view.iUid == ECamViewIdPhotoUserSceneSetup );

    CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );

    switch ( aCommand )

        {

        case ECamCmdCaptureSetupWhiteBalanceStill: // fallthrough

        case ECamCmdCaptureSetupColourFilterStill:

        case ECamCmdCaptureSetupExposureStill:

        case ECamCmdCaptureSetupWhiteBalanceVideo:

        case ECamCmdCaptureSetupColourFilterVideo:

        case ECamCmdCaptureSetupBrightnessStill:

        case ECamCmdCaptureSetupContrastStill:

        case ECamCmdCaptureSetupBrightnessVideo:

        case ECamCmdCaptureSetupContrastVideo:

        case ECamCmdCaptureSetupImageSharpnessStill:

        case ECamCmdCaptureSetupFlashStill:

        case ECamCmdCaptureSetupSelfTimer:

            {

            SwitchToCaptureSetupModeL( aCommand );

            }

            break;

        case ECamCmdCaptureSetupSceneStill:

        case ECamCmdCaptureSetupSceneVideo:

            {

            SwitchToSceneSettingModeL();

            }

            break;

        case EAknSoftkeyBack:

            {

            if( appUi && appUi->APHandler()->AccessedViaAP() )

                {

                if( !userSceneActive)

                	{

                	appUi->APHandler()->APOperationComplete();

                	}

                if ( iSceneSettingModeActive )

                    {

                    iSceneSettingContainer->SaveSceneSettingIfChangedL();

                    }

                iChangeButtonPressed = EFalse;

                ExitAllModesL();

                }

            else

                {

				if( iSceneSettingModeActive )

               	    {

	           	   	ExitSceneSettingModeL();

	           	    }	

	      		else if ( iInfoListBoxActive )

	           	    {

	           	   	ExitInfoListBoxL();

	           		}

                }

            }

            break;

        case EAknSoftkeyCancel:

            {

            if ( iCaptureSetupModeActive && iCaptureSetupControlHandler )

                {

                TCamSettingItemIds iSettingItemId = iCaptureSetupControlHandler->SettingType();		

                if ( iSettingItemId == ECamSettingItemDynamicSelfTimer )					//judge if current operation selfTimer

                  {

                  iController.SetSlideInSelfTimerPreview(EFalse);

                  TInt iSelfTimerVal = iController.IntegerSettingValueUnfiltered( ECamSettingItemDynamicSelfTimer );	//get the actual selfTimer value, not the focus one 

                  iController.IntSettingChangedL(iSettingItemId, iSelfTimerVal);			//set the actual status to the actual index

                  }

                iController.CancelPreviewChangesL();

                // fallthrough to exit CaptureSetup mode

                }

            else if ( iInfoListBoxActive )

                {

                iController.CancelPreviewChangesL();

                ExitAllModesL();

                break;

                }

            else if ( iSceneSettingModeActive )

                {

                iChangeButtonPressed = EFalse;

                ExitAllModesL();

                break;

                }

            else

                {

                // do nothing, the command is handled by the framework

                break;

                }

            }

            //lint -fallthrough

        case EAknSoftkeyOk:

            {

            CaptureSetupModeSelection();

            }

            break;

        case ECamMSKCmdAppChange:

        case EAknSoftkeySelect:

            {

            if ( iCaptureSetupModeActive && iCaptureSetupControlHandler )

                {

                CaptureSetupModeSelection();

                // fallthrough to exit CaptureSetup mode

                }

            else if ( iSceneSettingContainer )

                {

                if ( iSceneSettingContainer->UserSceneHighlighted() )

                    {                  

                    // use context specific ok options menu if user scene is highlighted

                    CEikMenuBar* menuBar = MenuBar();            

                    if ( menuBar )

                        {

                        menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_OK_MENUBAR );

                        MenuBar()->SetMenuType( CEikMenuBar::EMenuContext );

                        menuBar->TryDisplayMenuBarL();

                        menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_MENUBAR );

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

            			menuBar->SetMenuType( CEikMenuBar::EMenuOptions );

                        }

                    break;

                    }

                } 

            }

            //lint -fallthrough

        case ECamCmdSelect:

            {

            if ( iSceneSettingContainer )

                {

                // If successfully saved the scene change to the settings model

                // then exit the scene setting mode.

                if ( iSceneSettingContainer->SaveSceneSettingL() )

                    {

                    if( appUi && appUi->APHandler()->AccessedViaAP() )

                        {

                        if( !userSceneActive)

		                	{

		                	appUi->APHandler()->APOperationComplete();

		                	}

                        ExitAllModesL();

                        }

                    else

                        {

                    	ExitSceneSettingModeL();

                        }

                    }

                }

            else if( iInfoListBoxContainer )

            		{

            		HandleInfoListBoxSelectionL();	

 					}

            }

            break;

        case ECamCmdEdit:

            {

            // If 'change' user scene selected from scene list, exit all

            // modes in the precapture view and switch view to user scene.

            if ( iSceneSettingModeActive )

                {

                iChangeButtonPressed = ETrue;

            	AppUi()->HandleCommandL( ECamCmdUserScene );

            	AppUi()->StatusPane()->MakeVisible( ETrue );

                }

            }

            break;

        case ECamCmdUserSceneSelected:

            {

            // check as a precaution that there is a container and userscene is highlighted

            if ( iSceneSettingContainer && iSceneSettingContainer->UserSceneHighlighted() )

                {

                // use context specific ok options menu if user scene is highlighted

                CEikMenuBar* menuBar = MenuBar();            

                if ( menuBar )

                    {

                    MenuBar()->SetMenuType( CEikMenuBar::EMenuContext );

                    menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_OK_MENUBAR );

                    menuBar->TryDisplayMenuBarL();

                    menuBar->SetMenuType( CEikMenuBar::EMenuOptions );

                    menuBar->SetMenuTitleResourceId( R_CAM_SCENE_SETTING_MENUBAR );

                    }

                }

            break;

            }

        case ECamCmdInternalExit:

            {

            if ( appUi )

                {

                if ( !appUi->ZoomPane()->IsZoomAtMinimum() )

                    {

                    appUi->ZoomPane()->ResetZoomTo1x();

                    }

                }

            ExitAllModesL();

            CCamViewBase::HandleCommandL( aCommand );

            }

            break;

        case ECamCmdRedrawScreen:

            {

            if( iCaptureSetupContainer )

                {

                iCaptureSetupContainer->DrawDeferred();

                }

            CCamViewBase::HandleCommandL( aCommand );

            }

            break;

        default:

            {

            CCamViewBase::HandleCommandL( aCommand );

            break;

            }

        }

    PRINT( _L("Camera <= CCamCaptureSetupViewBase::HandleCommandL") );

    }

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

// CCamCaptureSetupViewBase::HandleFocusLossL

// Handle focus loss

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

//

void CCamCaptureSetupViewBase::HandleFocusLossL()

    {

	// We dont exit any of the modes when we loose focus

	// we do it when we gain focus.

    }

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

// CCamCaptureSetupViewBase::DoDeactivate

// From CAknView deactivates the view

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

//

void CCamCaptureSetupViewBase::DoDeactivate()

    {

    if ( iSceneSettingContainer )

        {

        AppUi()->RemoveFromStack( iSceneSettingContainer );

        delete iSceneSettingContainer;

        iSceneSettingContainer = NULL;

        }

    CCamViewBase::DoDeactivate();

    }

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

// CCamCaptureSetupViewBase::CCamCaptureSetupViewBase

// C++ constructor

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

//

CCamCaptureSetupViewBase::CCamCaptureSetupViewBase( CCamAppController& aController )

    {

    }

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

// CCamCaptureSetupViewBase::CreateCaptureSetupControlHandlerL

// Create a control handler for the correct capture setup item

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

//

void CCamCaptureSetupViewBase::CreateCaptureSetupControlHandlerL( TInt aSetupCommand )

    {

    __ASSERT_DEBUG( !iCaptureSetupControlHandler, CamPanic( ECamPanicInvalidState ) );

    TCamSettingItemIds settingItemId = ECamSettingItemDynamicPhotoWhiteBalance;

    switch ( aSetupCommand )

        {

        case ECamCmdCaptureSetupWhiteBalanceStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoWhiteBalance;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupColourFilterStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoColourFilter;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupExposureStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoExposure;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupFlashStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoFlash;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupSelfTimer:

            {

            settingItemId = ECamSettingItemDynamicSelfTimer;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupWhiteBalanceVideo:

            {

            settingItemId = ECamSettingItemDynamicVideoWhiteBalance;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO;

            }

            break;

        case ECamCmdCaptureSetupColourFilterVideo:

            {

            settingItemId = ECamSettingItemDynamicVideoColourFilter;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO;

            }

            break;

        // User scene settings pages.

        case ECamCmdCaptureSetupWhiteBalanceUser:

            {

            settingItemId = ECamSettingItemUserSceneWhitebalance;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupColourFilterUser:

            {

            settingItemId = ECamSettingItemUserSceneColourFilter;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupExposureUser:

            {

            settingItemId = ECamSettingItemUserSceneExposure;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupFlashUser:

            {

            settingItemId = ECamSettingItemUserSceneFlash;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

		case ECamCmdCaptureSetupBrightnessStill:

			{

			settingItemId = ECamSettingItemDynamicPhotoBrightness;

			iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

			}

			break;

		case ECamCmdCaptureSetupContrastStill:

			{

			settingItemId = ECamSettingItemDynamicPhotoContrast;

			iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

			}

			break;

		case ECamCmdCaptureSetupBrightnessVideo:

			{

			settingItemId = ECamSettingItemDynamicVideoBrightness;

			iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO;

			}

			break;

        case ECamCmdCaptureSetupContrastVideo:

			{

			settingItemId = ECamSettingItemDynamicVideoContrast;

			iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO;

			}

			break;

        case ECamCmdCaptureSetupBrightnessUser:

            {

            settingItemId = ECamSettingItemUserSceneBrightness;

			iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupContrastUser:

            {

            settingItemId = ECamSettingItemUserSceneContrast;

			iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupImageSharpnessStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoImageSharpness;

			iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupImageSharpnessUser:

            {

            settingItemId = ECamSettingItemUserSceneImageSharpness;

			iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdCaptureSetupLightSensitivityStill:

            {

            settingItemId = ECamSettingItemDynamicPhotoLightSensitivity;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_STILL;

            }

            break;

        case ECamCmdCaptureSetupLightSensitivityVideo:

            {

            settingItemId = ECamSettingItemDynamicVideoLightSensitivity;

            iSettingModeTitleResourceId = R_CAM_CAPTURE_SETUP_TITLE_VIDEO;

            }

            break;

        case ECamCmdCaptureSetupLightSensitivityUser:

            {

            settingItemId = ECamSettingItemUserSceneLightSensitivity;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        case ECamCmdSetUserDefault:

            { 

            settingItemId = ECamSettingItemUserSceneDefault;

            iSettingModeTitleResourceId = R_CAM_USER_SCENE_SETUP_TITLE;

            }

            break;

        default:

            {

            User::Leave( KErrNotSupported );

            }

            break;

        }

    iCaptureSetupControlHandler = new( ELeave )

        CCamCaptureSetupControlHandler( iController, settingItemId );

    }

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

// CCamCaptureSetupViewBase::CleanupCaptureSetupContainer

// Cleanup the capture setup controls if a leave occurs

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

//

void CCamCaptureSetupViewBase::CleanupCaptureSetupContainer( TAny* aAny )

    {

    CCamCaptureSetupViewBase* view = static_cast<CCamCaptureSetupViewBase*>( aAny );

    delete view->iCaptureSetupControlHandler;

    view->iCaptureSetupControlHandler = NULL;