/*
* 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:  Image settings list class
*
*/


// INCLUDE FILES
 
#include <bldvariant.hrh>
#include <CAknMemorySelectionSettingItem.h> // CAknMemorySelectionSettingItem
#include <featmgr.h>
#include <gscamerapluginrsc.rsg>
#include <StringLoader.h>
#include <AknQueryDialog.h>
#include <AknWaitDialog.h>
#include <CAknMemorySelectionSettingItemMultiDrive.h>
#include <driveinfo.h> // DriveInfo
#include <AknCommonDialogsDynMem.h>

#include "GSCamcorderPlugin.hrh"
#include "Cam.hrh"
#include "CamSettings.hrh"
#include "CamSettingsInternal.hrh"
#include "CamPanic.h"
#include "CamAppUiBase.h"
#include "CamUtility.h"
#include "MCamAppController.h"
#include "GSCamPhotoSettingsList.h"
#include "GSCamcorderPlugin.h"
#include "GSCamQualitySettingItem.h"
#include "GSCustomQualitySettingItem.h"
#include "GSCamDefaultNameSettingItem.h"
#include "CameraUiConfigManager.h"
#include "CamCollectionManagerAo.h"
#include "CamWaitDialog.h"
#include "CamLocationSettingItem.h"
#include "camconfiguration.h"
#include "GSCamCaptureToneSettingItem.h"

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

// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::CGSCamPhotoSettingsList
// C++ constructor
// ---------------------------------------------------------------------------
//
CGSCamPhotoSettingsList::CGSCamPhotoSettingsList( CCamStaticSettingsModel& aModel )
: iModel( aModel )
    {
    }


// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::ConstructL
// Symbian OS 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CGSCamPhotoSettingsList::ConstructL( TBool aLaunchedFromGS,
                                          TBool aSecondaryCameraSettings )
    {
    CAknViewAppUi *AppUi = static_cast<CAknViewAppUi*>
                           ( CCoeEnv::Static()->AppUi() );

    CGSCamcorderPlugin* parent = static_cast<CGSCamcorderPlugin*> 
        					   ( AppUi->View( KGSCamcorderGSPluginUid ) );
    if ( parent )
        {
        parent->LoadVideoStaticSettingsL( ETrue );
        parent->LoadPhotoStaticSettingsL( ETrue );
        }

    iLaunchedFromGS = aLaunchedFromGS;
    iSecondaryCameraSettings = aSecondaryCameraSettings;
    iSettings.ResetAndDestroy();
    iModel.Configuration().GetPsiIntArrayL( ECamPsiSupportedStillQualities, iSupportedQualityLevels );
    
    TInt resId;
    if ( iModel.UiConfigManagerPtr() &&
         iModel.UiConfigManagerPtr()->IsLocationSupported() )
        {
        resId =  iLaunchedFromGS?R_CAM_PHOTO_GSSETTINGS_WITH_LOCATION_ITEM_LIST_CAMCORDER:
                                 R_CAM_PHOTO_SETTINGS_WITH_LOCATION_ITEM_LIST_CAMCORDER;
        }
    else
        {
        resId =  iLaunchedFromGS?R_CAM_PHOTO_GSSETTINGS_ITEM_LIST_CAMCORDER:
                                 R_CAM_PHOTO_SETTINGS_ITEM_LIST_CAMCORDER;
        }
    
    if ( iSecondaryCameraSettings )
        {
        resId =  R_CAM_PHOTO_SETTINGS_ITEM_LIST_PORTRAIT;
        }
    ConstructFromResourceL( resId );
    }


// Destructor
CGSCamPhotoSettingsList::~CGSCamPhotoSettingsList()
    {
    iSettings.ResetAndDestroy();
    iSettings.Close();
    iSupportedQualityLevels.Close(); 
    }


// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::CreateSettingItemL
// From CAknSettingItemList Handles creating setting items
// ---------------------------------------------------------------------------
//
CAknSettingItem* CGSCamPhotoSettingsList::CreateSettingItemL( TInt aIdentifier )
    {
    // Add storage place to storage list of settings values. 
    // ...create the storage place.
    CAknViewAppUi *AppUi = static_cast<CAknViewAppUi*>
                           ( CCoeEnv::Static()->AppUi() );

    CGSCamcorderPlugin* parent = static_cast<CGSCamcorderPlugin*> 
        					   ( AppUi->View( KGSCamcorderGSPluginUid ) );

    TIntSetting* newSetting = new( ELeave ) TIntSetting;
    CleanupStack::PushL( newSetting );
    // ...set the identifier for this setting item.
    newSetting->iItemId = aIdentifier;
    if( aIdentifier != ECamSettingItemRestoreCameraSettings && parent )
        {
        newSetting->iValueId = parent->IntegerSettingValue( aIdentifier );
        }
    else
        {
        newSetting->iValueId = 0;     
        }
    // ...add the new storage place item to the storage list.
    iSettings.AppendL( newSetting );
    CleanupStack::Pop( newSetting );

  // Create the list setting item
  CAknSettingItem* settingItem = NULL;
  TInt lastItem = iSettings.Count() - 1;
  // Setting items take reference to the value to be manipulated.
  TInt& valueId( iSettings[lastItem]->iValueId );

  switch ( aIdentifier )
    {
    case ECamSettingItemPhotoShowFocusPoint:
    case ECamSettingItemShowCapturedPhoto:
      {
      settingItem = new( ELeave ) 
          CAknBinaryPopupSettingItem( aIdentifier, valueId );	
      }
      break;

    case ECamSettingItemPhotoDigitalZoom:
      {
      if ( iModel.UiConfigManagerPtr() &&
              iModel.UiConfigManagerPtr()->IsExtendedDigitalZoomSupported() )
          {
          settingItem = new( ELeave ) 
                          CAknEnumeratedTextPopupSettingItem( aIdentifier, valueId );          
          }
      }
      break;

    case ECamSettingItemPhotoQuality:
      {
      if ( parent )
          {
          iQualityValue = parent->IntegerSettingValue( ECamSettingItemPhotoQuality );
          }
      if ( !iLaunchedFromGS )
          {
          settingItem = new( ELeave )
                  CGSCamQualitySettingItem( ECamControllerImage,
                                            aIdentifier,
                                            iQualityValue,
                                            iModel
                                          );
          }
      else
          {
          settingItem = new( ELeave ) 
                  CGSCustomQualitySettingItem( aIdentifier, 
                                               iQualityValue,
                                               iModel,
                                               ECamControllerImage
                                              );
          }
       }
       break;
     case ECamSettingItemPhotoCaptureTone:
            {
            settingItem = new( ELeave ) 
                CGSCamCaptureToneSettingItem( aIdentifier, valueId );    
            }
            break;

        case ECamSettingItemImageRotation:
            {
            if ( iModel.UiConfigManagerPtr() &&
                 iModel.UiConfigManagerPtr()->IsOrientationSensorSupported() )
                {
                settingItem = 
                    new( ELeave ) CAknBinaryPopupSettingItem( aIdentifier, valueId );
                }
            }
            break;

        case ECamSettingItemRestoreCameraSettings:
            {
            settingItem = new ( ELeave ) CAknBigSettingItemBase( aIdentifier );
            }
        break;

        case ECamSettingItemPhotoMediaStorage:
            {
            // Convert the setting to a memory enum
            iMemVal = static_cast<DriveInfo::TDefaultDrives>
                    ( CamUtility::MapToSettingsListMemory( valueId ) );
            
		    // Get the root path of the default mass storage memory.
		    if(iMemVal != KErrNotFound)
		        {
                TInt driveInt;
		        TInt err = DriveInfo::GetDefaultDrive( iMemVal, driveInt );
		        iDrive = static_cast<TDriveNumber>(driveInt);
		        }
		    else
		        {
                iDrive = static_cast<TDriveNumber>(0); //Doesn't matter
		        }
		    TInt includedMedias(0);
		    CGSCamcorderPlugin* parent = static_cast<CGSCamcorderPlugin*> 
		                                ( AppUi->View( KGSCamcorderGSPluginUid ) );
		    TInt driveCount(0);
		    if( !parent->IntegerSettingValue(ECamSettingItemRemovePhoneMemoryUsage) )
		        {
                includedMedias |= AknCommonDialogsDynMem::EMemoryTypePhone;
                driveCount++;
		        }
		    
		    TInt drive(0);
		    TUint driveStatus(0);    
		    TInt err(0);
		    err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultMassStorage, drive );
		    if( err == KErrNone )
		        {
		        err = DriveInfo::GetDriveStatus( CCoeEnv::Static()->FsSession(), 
		                                         drive, 
		                                         driveStatus );
		        if( err == KErrNone )
		            {
                    if( ( driveStatus & DriveInfo::EDrivePresent) ==  DriveInfo::EDrivePresent )
                        {
                        if( ( driveStatus & DriveInfo::EDriveRemovable ) != DriveInfo::EDriveRemovable )
                            {
                            includedMedias |= AknCommonDialogsDynMem::EMemoryTypeInternalMassStorage;
                            driveCount++;
                            }
                        }
		            }
                }
		    
		    err = DriveInfo::GetDefaultDrive( DriveInfo::EDefaultRemovableMassStorage, drive );
            if( err == KErrNone )
                {
                err = DriveInfo::GetDriveStatus( CCoeEnv::Static()->FsSession(), 
                                                 drive,
                                                 driveStatus );
                if( err == KErrNone )
                    {
                    if( ( driveStatus & DriveInfo::EDrivePresent) ==  DriveInfo::EDrivePresent )
                        {
                        includedMedias |= AknCommonDialogsDynMem::EMemoryTypeMMCExternalInDevice;
                        driveCount++;
                        }
                    }
                }
		    
		    settingItem = new ( ELeave ) 
		                  CAknMemorySelectionSettingItemMultiDrive(
		                                                      aIdentifier,
                                                              iDrive
                                                              );
		    static_cast<CAknMemorySelectionSettingItemMultiDrive*>(settingItem)
		                        ->SetIncludedMediasL(includedMedias);
		    if( driveCount <= 1 )
		        {
                settingItem->SetHidden( ETrue );
                }
		    }
            break;
 
        case ECamSettingItemPhotoNameBaseType:
            {
            if ( parent )
                {
                iDefaultNameBase = parent->TextSettingValue(
                                   ECamSettingItemPhotoNameBase );
                TBool flag = ( iLaunchedFromGS );
                settingItem = 
                    new( ELeave ) CGSCamDefaultNameSettingItem( iDefaultNameBase, 
                                                                ECamControllerImage,
                                                                aIdentifier,
                                                                valueId, 
                                                                flag );
                }
             }
            break;          

    case ECamSettingItemRecLocation:
      {
      if ( !iLaunchedFromGS )
        {
        settingItem = 
            new( ELeave ) CCamLocationSettingItem( ECamControllerImage,
                                                   aIdentifier, 
                                                   valueId );
        }
      else
        {
        settingItem = new( ELeave ) 
            CAknBinaryPopupSettingItem( aIdentifier, valueId );
        }
      }
      break;

    default:
       {
       break;
       }
     }
    return settingItem;
    }



// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::EditItemL
// Launch the setting page for the current item by calling
// EditItemL on it.
// ---------------------------------------------------------------------------
//
void CGSCamPhotoSettingsList::EditItemL( TInt aIndex, TBool aCalledFromMenu )
    {
    CAknViewAppUi *AppUi = static_cast<CAknViewAppUi*>( CCoeEnv::Static()->AppUi() );
    CGSCamcorderPlugin* parent = static_cast<CGSCamcorderPlugin*> 
        					( AppUi->View( KGSCamcorderGSPluginUid ) );
    CAknSettingItemArray* itemArray = SettingItemArray();
    CAknSettingItem* editedItem = itemArray->At(aIndex);
    
    if ( editedItem->Identifier() == ECamSettingItemRestoreCameraSettings )
        {
        TInt response = 0; 
        if ( parent )
            {
            response = parent->DisplayRestoreSettingsDlgL(); 
            }
        // If launched from GS and response "Yes" reload settings page to update values 
        if ( iLaunchedFromGS && response )
            {
            AppUi->ActivateLocalViewL( KGSCamcorderGSPluginUid );
            }
        return;
        }    

    // Edit item via setting page or in-place.
    CAknSettingItemList::EditItemL( aIndex, aCalledFromMenu );
    
    // Write the new value for the edited control to its stored data.
    editedItem->StoreL();

    // Update the settings model so that the navipane is updated.
    TInt settingValue;
    // ...If the changed setting is the media storage setting
    // ...then convert the memory value to settings model type value.
    if ( editedItem->Identifier() == ECamSettingItemPhotoMediaStorage )
        {
        iMemVal = static_cast<DriveInfo::TDefaultDrives>(CamUtility::GetDriveTypeFromDriveNumber( iDrive ));
        settingValue = CamUtility::MapFromSettingsListMemory( iMemVal );
        settingValue = ( (settingValue == ECamMediaStoragePhone) && 
                         parent->IntegerSettingValue(ECamSettingItemRemovePhoneMemoryUsage)  )?
                                 ECamMediaStorageNone:settingValue;
        }
    else if ( editedItem->Identifier() == ECamSettingItemPhotoQuality )
        {
        settingValue = iQualityValue;
        }
    else
        {
        settingValue = ValueOfSetting( editedItem->Identifier() );
        }
   
      if ( parent )
        {
        parent->SetIntegerSettingValueL( editedItem->Identifier(), settingValue );
        }

    // If the setting is for the photo base name then store the name.
      if ( parent )
        {
        parent->SetTextSettingValueL( ECamSettingItemPhotoNameBase,
                                      iDefaultNameBase );
        }

    }

// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::ValueOfSetting
// Returns the current value of the a setting for this list.
// Note, this is not the value currently stored in the settings model, as these
// may differ.
// ---------------------------------------------------------------------------
//
TInt CGSCamPhotoSettingsList::ValueOfSetting( TInt aItemId ) const
    {
    TInt itemIndex = IndexOfSetting( aItemId );
    return iSettings[itemIndex]->iValueId;
    }

// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::IndexOfSetting
// Returns the array index of a setting for this list.
// ---------------------------------------------------------------------------
//
TInt CGSCamPhotoSettingsList::IndexOfSetting( TInt aItemId ) const
    {
    TInt i;
  TInt itemTotal = iSettings.Count();
    for ( i = 0; i < itemTotal; ++i )
        {
        if ( iSettings[i]->iItemId == aItemId )
            {
            return i;
            }
        }

    // Should never get here.
    // Remove lint warning
    return KErrNotFound;
    }

   
// ---------------------------------------------------------------------------
// CGSCamPhotoSettingsList::SizeChanged
// Set the size and position of component controls.
// ---------------------------------------------------------------------------
//
void CGSCamPhotoSettingsList::SizeChanged()
    {
    CAknSettingItemList::SizeChanged();

    CEikListBox* lb = ListBox();
    if( lb )
        {
        lb->SetRect( Rect() );  // Set container's rect to listbox
        }
    }

// End of File

