/*

* Copyright (c) 2007-2008 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:

*

*/

// INCLUDE FILES

#include <activepalette2factory.h>

#include <activepalette2genericpluginint.h>

#include <activepalette2itemvisible.h>

#include <activepalette2eventdata.h>

#include <activepalette2navigationkeys.h>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <barsc.h>

#include <barsread.h>

#include <bautils.h>

#include <AknIconUtils.h>

#include <aknnotewrappers.h>

#include <AknUtils.h>

#include <e32math.h>

#include <gulicon.h>

#include <cameraapp.mbg>

#include <utf.h>

#include <textresolver.h>

#include <apgcli.h>

#include <apaid.h>

#include "CamUtility.h"

#include "CamAppController.h"

#include "camactivepalettehandler.h"

#include "CamAppUid.h"

#include "CamCaptureSetupViewBase.h"

#include "CamAppUiBase.h"

#include "CamPanic.h"

#include "CamAppUi.h"

#include "CamUtility.h"

#include "CamTimeLapseUtility.h"

#include "CamPSI.h"

#include "CameraUiConfigManager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamActivePaletteHandlerTraces.h"

#endif

typedef TAP2GenericPluginIcon   TCamAPGenericPluginIcon;

typedef TAP2GenericPluginParams TCamAPGenericPluginParams;

// ============================ CONSTANTS ======================================

// ActivePalette2 settings

const TActivePalette2DrawMode KActivePaletteDrawMode = EAP2DrawModeSemiTransparentTooltipModeFading;

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

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

// CCamActivePaletteHandler::CCamActivePaletteHandler

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CCamActivePaletteHandler::CCamActivePaletteHandler( CCamAppController& aController )

:   iController( aController )

    {

    }

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

// CCamActivePaletteHandler::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CCamActivePaletteHandler::ConstructL( TBool aCreatePalette )

  {

  if ( !iController.IsTouchScreenSupported() )

      {

      iEnv = CEikonEnv::Static();

      if( aCreatePalette )

        {

        iActivePalette = 

          ActivePalette2Factory::CreateActivePaletteUIL( KActivePaletteDrawMode );

        iActivePalette->SetObserver( this );

        }

      // Get the icon file name

      delete iIconFileName;

      iIconFileName = NULL;

      iIconFileName = HBufC::NewL( KMaxFileName );

      TPtr  ptr = iIconFileName->Des();

      CamUtility::ResourceFileName( ptr );

      // get res id for EV comp from psi

      CamUtility::GetPsiInt( ECamPsiAPEVCompLegend, iEvCompRes );

      if( iEvCompRes == KErrNotSupported )

        {

        iEvCompRes = R_CAM_CAPTURE_SETUP_MENU_PHOTO_EXPOSURE_ARRAY;

        }

      }

  }

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

// CCamActivePaletteHandler::NewL

// Two-phased constructor.

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

//

CCamActivePaletteHandler* CCamActivePaletteHandler::NewL( CCamAppController& aController, TBool aCreatePalette )

  {

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

  CleanupStack::PushL( self );

  self->ConstructL( aCreatePalette );

  CleanupStack::Pop();

  return self;

  }

// Destructor

CCamActivePaletteHandler::~CCamActivePaletteHandler()

  {

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

  delete iIconFileName;

  iIconFileName = NULL;

  iItemArray.Close();

  iCurrentValSettingsItem.Close();

  iPreCaptureItems.Close();

  delete iToolTipText;

  delete iOneClickUploadTooltip;

  DestroyActivePalette();

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

  }

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

// CCamActivePaletteHandler::ActivePalette()

// Return handle to Active Palette

// (other items were commented in a header).

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

//

MActivePalette2UI* CCamActivePaletteHandler::ActivePalette() const

  {

  return iActivePalette;

  }    

/*

 *  To check if a specific feature is supported, to append or show in AP

 */

TBool CCamActivePaletteHandler:: IsAPItemFeatureSupportedL( const TInt aItemId ) const

  {

  TBool featureSupported = ETrue; // by default we feature supported

  CCameraUiConfigManager* configMgr = iController.UiConfigManagerPtr();

  switch( aItemId )

      {

      case ECamSettingItemFaceTracking:

          {

          featureSupported = configMgr->IsFaceTrackingSupported();

          break;

          }

      case ECamSettingItemGotoPhotos:

          {

          featureSupported = configMgr->IsPhotosSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoFlash:

          {

          featureSupported = configMgr->IsFlashModeSupported();

          break;

          }   

      case ECamSettingItemDynamicVideoFlash:

          {

          featureSupported = configMgr->IsVideoLightSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoColourFilter:

      case ECamSettingItemDynamicVideoColourFilter:

          {

          featureSupported = configMgr->IsColorToneFeatureSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoWhiteBalance:

      case ECamSettingItemDynamicVideoWhiteBalance:    

          {

          featureSupported = configMgr->IsWhiteBalanceFeatureSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoLightSensitivity:

          {    

          featureSupported = configMgr->IsISOSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoExposure:

          {

          featureSupported = configMgr->IsEVSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoImageSharpness:

          {

          featureSupported = configMgr->IsSharpnessFeatureSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoContrast:

      case ECamSettingItemDynamicVideoContrast:

          {

          featureSupported = configMgr->IsContrastSupported();

          break;

          }

      case ECamSettingItemDynamicPhotoBrightness:

      case ECamSettingItemDynamicVideoBrightness:

          {

          featureSupported = configMgr->IsBrightnessSupported();

          break; 

          }

      default:

          {

          break;      

          }    

      }

  return featureSupported;

  }

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

// CCamActivePaletteHandler::InstallAPItemsL

// Install ap items from resource

// (other items were commented in a header).

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

//

void CCamActivePaletteHandler::InstallAPItemsL( TInt aResId )

  {  

  PRINT( _L( "Camera => CCamActivePaletteHandler::InstallAPItemsL" ) );  

  if ( !iController.IsTouchScreenSupported() )

      {

      // Clear existing items first	  

      iItemArray.Reset();

      if ( iController.UiConfigManagerPtr() &&

           iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

          {

          iCurrentValSettingsItem.Reset();

          }

      // Array for new toolbar items

      RArray<TCamActivePaletteItem> newItems;

      CleanupClosePushL( newItems );  

      // Static toolbar content - load items from resource

      PRINT( _L( "Camera <> CCamActivePaletteHandler::InstallAPItemsL - Static toolbar items from resource" ) );        

      ReadToolbarItemsFromResourceL( aResId, newItems );                  

      iDynamicToolbar = EFalse;

      TInt nItems = newItems.Count();

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

        {

        TCamActivePaletteItem item = newItems[i];

        TBool append ( ETrue );

        if ( ECamActivePaletteItemTypePostCapture != item.iType )

            {

            append = IsAPItemFeatureSupportedL( item.iItemId ); 

            }

        else

            {

            // if postcapture items, then check if add to album and properties ae supported

            if ( ECamCmdAddToAlbum == item.iCmdId ||

                 ECamCmdProperties == item.iCmdId ||

                 ECamCmdPhotos == item.iCmdId )

                 {

                 append = iController.UiConfigManagerPtr()->IsPhotosSupported();

                 }

            else

                {

                }

            }

        if ( append )

            {

            iItemArray.AppendL( item ); 

            }

        }

      TInt items = iItemArray.Count();

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

        {

        TCamAPSettingsItem settingItem;

        settingItem.iSettingItem = iItemArray[i].iItemId;

        TUid uid( TUid::Uid( KActivePalette2GenericPluginUID ) );

        switch( iItemArray[i].iType )

          {

          case ECamActivePaletteItemTypeCommand:

            {

            PRINT( _L("Camera <> CCamActivePaletteHandler: case ECamActivePaletteItemTypeCommand") );

            // Command id is used to identify the icon.

            // Only one icon is used for command type items.

            settingItem.iSettingVal = iItemArray[i].iCmdId;

            iIconId = GetBitmapIdFromValueL( settingItem );

            break;

            }

          case ECamActivePaletteItemTypePreCapture:

            {

            PRINT( _L("Camera <> CCamActivePaletteHandler: case ECamActivePaletteItemTypePreCapture") );

            // Get initial value & associated icon

            settingItem.iSettingVal = iController.IntegerSettingValue( iItemArray[i].iItemId );

            iIconId = GetBitmapIdFromValueL( settingItem );

            break;

            }

          case ECamActivePaletteItemTypePreCaptureNonSetting:

            {                

            PRINT( _L("Camera <> CCamActivePaletteHandler: case ECamActivePaletteItemTypePreCaptureNonSetting") );

            settingItem.iSettingVal = DetermineNonSettingState( iItemArray[i] );

            iIconId = GetBitmapIdFromValueL( settingItem );

            if ( iIconId != KErrNotFound )

              {

              SetNonSettingItemTooltipL( iItemArray[i] );

              }

            break;

            }

          case ECamActivePaletteItemTypePostCapture:

            {

            PRINT( _L("Camera <> CCamActivePaletteHandler: case ECamActivePaletteItemTypePostCapture") );

            // Setting up the AP post-capture is simpler as the icons

            // don't need to change depending on any settings.

            LoadPostCaptureResourcesL( PostCaptureItemId( iItemArray[i].iCmdId ) );

            break;

            }

          default:

            {

            PRINT( _L("Camera <> CCamActivePaletteHandler: default case => PANIC!!!") );

             __ASSERT_DEBUG( EFalse, CamPanic( ECamPanicInvalidActivePaletteItemType ) );

            break;

            }

          } // switch

        PRINT( _L("Camera <> CCamActivePaletteHandler::InstallAPItemsL About to install item"));    

        // Override tooltip for one-click upload

        if ( iOneClickUploadTooltip &&

             iItemArray[i].iCmdId == ECamCmdOneClickUpload )

            {

            delete iToolTipText;

            iToolTipText = NULL;

            iToolTipText = iOneClickUploadTooltip->AllocL();

            }

        // cache the current values of the AP items so that we don't need to check later

        // specifically for the items that there values are persisted

        if ( iController.UiConfigManagerPtr() &&

             iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

            {

            TCamAPSettingsItem tempSettingItem;

            tempSettingItem.iSettingItem   = iItemArray[i].iItemId;

            // set initial value to some invalid number using -1

            tempSettingItem.iSettingVal    = -1;

            iCurrentValSettingsItem.AppendL( tempSettingItem );

            }

        InstallOneAPItemL( iItemArray[i], uid, *iToolTipText, *iIconFileName, iIconId, iIconId );

        PRINT( _L("Camera <> CCamActivePaletteHandler::InstallAPItemsL Item installed"));    

        } // for

    if ( iController.UiConfigManagerPtr()->IsXenonFlashSupported() )

        {

        CheckFlashItemVisibilityL();

        }

      CleanupStack::PopAndDestroy(); // newItems

      }

  PRINT( _L( "Camera <= CCamActivePaletteHandler::InstallAPItemsL" ) );

  }

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

// InstallOneAPItemL

//

// Helper method to install one AP item.

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

//

void 

CCamActivePaletteHandler

::InstallOneAPItemL( const TCamActivePaletteItem& aItem,

                     const TUid&                  aPluginUid,

                     const TDesC&                 aToolTipText,

                     const TDesC&                 aIconFileName,

                           TInt                   aIconId,

                           TInt                   aMaskId )

  {

  // only add items that actually exist

  if( iIconId != KErrNotFound )

      {

      TCamAPGenericPluginParams params( 

              TCamAPGenericPluginParams::EGenericCustomResFile,

              aIconFileName,

              aIconId,

              aMaskId,

              aToolTipText,

              aItem.iCmdId,   // message ID

              0 );            // Custom param            

      TPckg<TCamAPGenericPluginParams> paramsPckg( params );

      TActivePalette2ItemVisible itemVisible( aItem.iCmdId,aItem.iIsVisible );

      iActivePalette->InstallItemL( itemVisible,

              aPluginUid, 

              paramsPckg );

      }

  }

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

// CheckFlashItemVisibilityL

//

// Hide flash AP item if needed.

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

//

void CCamActivePaletteHandler::CheckFlashItemVisibilityL()

  {

  if ( !iController.IsTouchScreenSupported() && 

       iController.UiConfigManagerPtr()->IsXenonFlashSupported() )

      {

      // Make flash item invisible, in case updating AP for burst mode

      CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

      if( appUi &&  ECamImageCaptureBurst == appUi->CurrentBurstMode() || 

          // ECamCaptureModeTimeLapse == appUi->CurrentBurstMode() || 

          ECamSceneSports == iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) )

          {

          // Flash item is disabled in burst mode and for sport scene   

          iActivePalette->SetItemVisibility( ECamCmdCaptureSetupFlashStill, EFalse );

          }

       else

          {

          iActivePalette->SetItemVisibility( ECamCmdCaptureSetupFlashStill, ETrue );    

          }

      }

  }

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

// CCamActivePaletteHandler::ReturnedFromPretendExitL

// Resets current item position and updates the active palette.

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

//   

 void CCamActivePaletteHandler::ReturnedFromPretendExitL()

    {

    PRINT( _L("Camera => CCamActivePaletteHandler::ReturnedFromPretendExitL"));

    if ( !iController.IsTouchScreenSupported() )

        {

        if ( iActivePalette ) 

            {       

             ResetToDefaultItem();

            }

        UpdateActivePaletteL();

        }

    PRINT( _L("Camera <= CCamActivePaletteHandler::ReturnedFromPretendExitL"));    

    }

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

// CCamActivePaletteHandler::ResetToFirstItem

// Resets highlight to the first AP item

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

//   

void CCamActivePaletteHandler::ResetToFirstItem()

    {

    PRINT( _L("Camera => CCamActivePaletteHandler::ResetToFirstItem"));

    if ( !iController.IsTouchScreenSupported() )

        {

        if( iActivePalette && iItemArray.Count() > 0 )

            {

            iActivePalette->SetCurrentItem( iItemArray[0].iCmdId );            

            } 

        }

    PRINT( _L("Camera <= CCamActivePaletteHandler::ResetToFirstItem"));                          

    }     

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

// CCamActivePaletteHandler::ResetToDefaultItem

// Resets highlight to the default AP item

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

//   

void CCamActivePaletteHandler::ResetToDefaultItem()

    {

    PRINT( _L("Camera => CCamActivePaletteHandler::ResetToDefaultItem"));

    if ( !iController.IsTouchScreenSupported() )

        {

        CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

        if( !appUi->IsEmbedded() 

/*#ifndef __WINS__

            || appUi->IsInCallSend()           

#endif*/

          )

            {          

            if( iActivePalette && iItemArray.Count() > 1 )

                {

                // In static toolbar, always reset to second item 

                // First item selected to adjust the visible items

                iActivePalette->SetCurrentItem( iItemArray[0].iCmdId );            

                iActivePalette->SetCurrentItem( iItemArray[1].iCmdId );            

                }