1 /*

     2 * Copyright (c) 2007-2008 Nokia Corporation and/or its subsidiary(-ies). 

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include <activepalette2factory.h>

    22 #include <activepalette2genericpluginint.h>

    23 #include <activepalette2itemvisible.h>

    24 #include <activepalette2eventdata.h>

    25 #include <activepalette2navigationkeys.h>

    26 #include <cameraapp.rsg>

    27 #include <vgacamsettings.rsg>

    28 #include <barsc.h>

    29 #include <barsread.h>

    30 #include <bautils.h>

    31 #include <AknIconUtils.h>

    32 #include <aknnotewrappers.h>

    33 #include <AknUtils.h>

    34 #include <e32math.h>

    35 #include <gulicon.h>

    36 #include <cameraapp.mbg>

    37 #include <utf.h>

    38 #include <textresolver.h>

    39 #include <apgcli.h>

    40 #include <apaid.h>

    41 

    42 #include "CamUtility.h"

    43 #include "CamAppController.h"

    44 #include "camactivepalettehandler.h"

    45 #include "CamAppUid.h"

    46 #include "CamCaptureSetupViewBase.h"

    47 #include "CamAppUiBase.h"

    48 #include "CamPanic.h"

    49 #include "CamAppUi.h"

    50 #include "CamUtility.h"

    51 #include "CamTimeLapseUtility.h"

    52 #include "CamPSI.h"

    53 #include "CameraUiConfigManager.h"

    54 #include "OstTraceDefinitions.h"

    55 #ifdef OST_TRACE_COMPILER_IN_USE

    56 #include "camactivepalettehandlerTraces.h"

    57 #endif

    58 

    59 

    60 typedef TAP2GenericPluginIcon   TCamAPGenericPluginIcon;

    61 typedef TAP2GenericPluginParams TCamAPGenericPluginParams;

    62 

    63 // ============================ CONSTANTS ======================================

    64 

    65 // ActivePalette2 settings

    66 const TActivePalette2DrawMode KActivePaletteDrawMode = EAP2DrawModeSemiTransparentTooltipModeFading;

    67 

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

    69 

    70 // -----------------------------------------------------------------------------

    71 // CCamActivePaletteHandler::CCamActivePaletteHandler

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

    73 // might leave.

    74 // -----------------------------------------------------------------------------

    75 //

    76 CCamActivePaletteHandler::CCamActivePaletteHandler( CCamAppController& aController )

    77 :   iController( aController )

    78     {

    79     }

    80 

    81 // -----------------------------------------------------------------------------

    82 // CCamActivePaletteHandler::ConstructL

    83 // Symbian 2nd phase constructor can leave.

    84 // -----------------------------------------------------------------------------

    85 //

    86 void CCamActivePaletteHandler::ConstructL( TBool aCreatePalette )

    87   {

    88   if ( !iController.IsTouchScreenSupported() )

    89       {

    90       iEnv = CEikonEnv::Static();

    91       

    92       if( aCreatePalette )

    93         {

    94         iActivePalette = 

    95           ActivePalette2Factory::CreateActivePaletteUIL( KActivePaletteDrawMode );

    96         iActivePalette->SetObserver( this );

    97         }

    98            

    99       // Get the icon file name

   100       delete iIconFileName;

   101       iIconFileName = NULL;

   102       iIconFileName = HBufC::NewL( KMaxFileName );

   103       TPtr  ptr = iIconFileName->Des();

   104       CamUtility::ResourceFileName( ptr );

   105 

   106 

   107       // get res id for EV comp from psi

   108       CamUtility::GetPsiInt( ECamPsiAPEVCompLegend, iEvCompRes );

   109       if( iEvCompRes == KErrNotSupported )

   110         {

   111         iEvCompRes = R_CAM_CAPTURE_SETUP_MENU_PHOTO_EXPOSURE_ARRAY;

   112         }

   113       }

   114   }

   115 

   116 // -----------------------------------------------------------------------------

   117 // CCamActivePaletteHandler::NewL

   118 // Two-phased constructor.

   119 // -----------------------------------------------------------------------------

   120 //

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

   122   {

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

   124   

   125   CleanupStack::PushL( self );

   126   self->ConstructL( aCreatePalette );

   127   CleanupStack::Pop();

   128 

   129   return self;

   130   }

   131 

   132     

   133 // Destructor

   134 CCamActivePaletteHandler::~CCamActivePaletteHandler()

   135   {

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

   137   delete iIconFileName;

   138   iIconFileName = NULL;

   139 

   140   iItemArray.Close();

   141 

   142   iCurrentValSettingsItem.Close();

   143 

   144   iPreCaptureItems.Close();

   145   delete iToolTipText;

   146 

   147   delete iOneClickUploadTooltip;

   148 

   149   DestroyActivePalette();

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

   151   }

   152 

   153 // -----------------------------------------------------------------------------

   154 // CCamActivePaletteHandler::ActivePalette()

   155 // Return handle to Active Palette

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

   157 // -----------------------------------------------------------------------------

   158 //

   159 MActivePalette2UI* CCamActivePaletteHandler::ActivePalette() const

   160   {

   161   return iActivePalette;

   162   }    

   163 

   164 

   165 /*

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

   167  */

   168 TBool CCamActivePaletteHandler:: IsAPItemFeatureSupportedL( const TInt aItemId ) const

   169   {

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

   171   CCameraUiConfigManager* configMgr = iController.UiConfigManagerPtr();

   172   switch( aItemId )

   173       {

   174       case ECamSettingItemFaceTracking:

   175           {

   176           featureSupported = configMgr->IsFaceTrackingSupported();

   177           break;

   178           }

   179       case ECamSettingItemGotoPhotos:

   180           {

   181           featureSupported = configMgr->IsPhotosSupported();

   182           break;

   183           }

   184       case ECamSettingItemDynamicPhotoFlash:

   185           {

   186           featureSupported = configMgr->IsFlashModeSupported();

   187           break;

   188           }   

   189       case ECamSettingItemDynamicVideoFlash:

   190           {

   191           featureSupported = configMgr->IsVideoLightSupported();

   192           break;

   193           }

   194       case ECamSettingItemDynamicPhotoColourFilter:

   195       case ECamSettingItemDynamicVideoColourFilter:

   196           {

   197           featureSupported = configMgr->IsColorToneFeatureSupported();

   198           break;

   199           }

   200       case ECamSettingItemDynamicPhotoWhiteBalance:

   201       case ECamSettingItemDynamicVideoWhiteBalance:    

   202           {

   203           featureSupported = configMgr->IsWhiteBalanceFeatureSupported();

   204           break;

   205           }

   206       case ECamSettingItemDynamicPhotoLightSensitivity:

   207           {    

   208           featureSupported = configMgr->IsISOSupported();

   209           break;

   210           }

   211       case ECamSettingItemDynamicPhotoExposure:

   212           {

   213           featureSupported = configMgr->IsEVSupported();

   214           break;

   215           }

   216       case ECamSettingItemDynamicPhotoImageSharpness:

   217           {

   218           featureSupported = configMgr->IsSharpnessFeatureSupported();

   219           break;

   220           }

   221       case ECamSettingItemDynamicPhotoContrast:

   222       case ECamSettingItemDynamicVideoContrast:

   223           {

   224           featureSupported = configMgr->IsContrastSupported();

   225           break;

   226           }

   227       case ECamSettingItemDynamicPhotoBrightness:

   228       case ECamSettingItemDynamicVideoBrightness:

   229           {

   230           featureSupported = configMgr->IsBrightnessSupported();

   231           break; 

   232           }

   233       default:

   234           {

   235           break;      

   236           }    

   237       }

   238   return featureSupported;

   239   }

   240 

   241 // -----------------------------------------------------------------------------

   242 // CCamActivePaletteHandler::InstallAPItemsL

   243 // Install ap items from resource

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

   245 // -----------------------------------------------------------------------------

   246 //

   247 void CCamActivePaletteHandler::InstallAPItemsL( TInt aResId )

   248   {  

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

   250 

   251   if ( !iController.IsTouchScreenSupported() )

   252       {

   253       // Clear existing items first	  

   254       iItemArray.Reset();

   255 

   256       if ( iController.UiConfigManagerPtr() &&

   257            iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

   258           {

   259           iCurrentValSettingsItem.Reset();

   260           }

   261 

   262       

   263       // Array for new toolbar items

   264       RArray<TCamActivePaletteItem> newItems;

   265       CleanupClosePushL( newItems );  

   266 

   267       // Static toolbar content - load items from resource

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

   269       ReadToolbarItemsFromResourceL( aResId, newItems );                  

   270       iDynamicToolbar = EFalse;

   271 

   272       TInt nItems = newItems.Count();

   273       

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

   275         {

   276         TCamActivePaletteItem item = newItems[i];

   277         TBool append ( ETrue );

   278         if ( ECamActivePaletteItemTypePostCapture != item.iType )

   279             {

   280             append = IsAPItemFeatureSupportedL( item.iItemId ); 

   281             }

   282         else

   283             {

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

   285             if ( ECamCmdAddToAlbum == item.iCmdId ||

   286                  ECamCmdProperties == item.iCmdId ||

   287                  ECamCmdPhotos == item.iCmdId )

   288                  {

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

   290                  }

   291             else

   292                 {

   293                 }

   294             }

   295 

   296         if ( append )

   297             {

   298             iItemArray.AppendL( item ); 

   299             }

   300         }

   301 

   302       TInt items = iItemArray.Count();

   303         

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

   305         {

   306         TCamAPSettingsItem settingItem;

   307         settingItem.iSettingItem = iItemArray[i].iItemId;

   308         

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

   310           

   311         switch( iItemArray[i].iType )

   312           {

   313           case ECamActivePaletteItemTypeCommand:

   314             {

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

   316             // Command id is used to identify the icon.

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

   318             settingItem.iSettingVal = iItemArray[i].iCmdId;

   319             iIconId = GetBitmapIdFromValueL( settingItem );

   320             break;

   321             }

   322           case ECamActivePaletteItemTypePreCapture:

   323             {

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

   325             // Get initial value & associated icon

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

   327             iIconId = GetBitmapIdFromValueL( settingItem );

   328             break;

   329             }

   330           case ECamActivePaletteItemTypePreCaptureNonSetting:

   331             {                

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

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

   334             iIconId = GetBitmapIdFromValueL( settingItem );

   335             if ( iIconId != KErrNotFound )

   336               {

   337               SetNonSettingItemTooltipL( iItemArray[i] );

   338               }

   339             break;

   340             }

   341           case ECamActivePaletteItemTypePostCapture:

   342             {

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

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

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

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

   347             break;

   348             }

   349           default:

   350             {

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

   352              __ASSERT_DEBUG( EFalse, CamPanic( ECamPanicInvalidActivePaletteItemType ) );

   353             break;

   354             }

   355           } // switch

   356            

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

   358 

   359         // Override tooltip for one-click upload

   360         if ( iOneClickUploadTooltip &&

   361              iItemArray[i].iCmdId == ECamCmdOneClickUpload )

   362             {

   363             delete iToolTipText;

   364             iToolTipText = NULL;

   365             iToolTipText = iOneClickUploadTooltip->AllocL();

   366             }

   367 			

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

   369         // specifically for the items that there values are persisted

   370         if ( iController.UiConfigManagerPtr() &&

   371              iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() )

   372             {

   373             TCamAPSettingsItem tempSettingItem;

   374             tempSettingItem.iSettingItem   = iItemArray[i].iItemId;

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

   376             tempSettingItem.iSettingVal    = -1;

   377             iCurrentValSettingsItem.AppendL( tempSettingItem );

   378             }

   379             

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

   381 

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

   383         } // for

   384        

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

   386         {

   387         CheckFlashItemVisibilityL();

   388         }

   389                           

   390       CleanupStack::PopAndDestroy(); // newItems

   391       }

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

   393   }

   394 

   395 

   396 

   397 

   398 // -----------------------------------------------------------------------------

   399 // InstallOneAPItemL

   400 //

   401 // Helper method to install one AP item.

   402 // -----------------------------------------------------------------------------

   403 //

   404 void 

   405 CCamActivePaletteHandler

   406 ::InstallOneAPItemL( const TCamActivePaletteItem& aItem,

   407                      const TUid&                  aPluginUid,

   408                      const TDesC&                 aToolTipText,

   409                      const TDesC&                 aIconFileName,

   410                            TInt                   aIconId,

   411                            TInt                   aMaskId )

   412   {

   413   // only add items that actually exist

   414   if( iIconId != KErrNotFound )

   415       {

   416       TCamAPGenericPluginParams params( 

   417               TCamAPGenericPluginParams::EGenericCustomResFile,

   418               aIconFileName,

   419               aIconId,

   420               aMaskId,

   421               aToolTipText,

   422               aItem.iCmdId,   // message ID

   423               0 );            // Custom param            

   424       TPckg<TCamAPGenericPluginParams> paramsPckg( params );

   425 

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

   427       iActivePalette->InstallItemL( itemVisible,

   428               aPluginUid, 

   429               paramsPckg );

   430       }

   431   }

   432 

   433 

   434 // -----------------------------------------------------------------------------

   435 // CheckFlashItemVisibilityL

   436 //

   437 // Hide flash AP item if needed.

   438 // -----------------------------------------------------------------------------

   439 //

   440 void CCamActivePaletteHandler::CheckFlashItemVisibilityL()

   441   {

   442   if ( !iController.IsTouchScreenSupported() && 

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

   444       {

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

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

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

   448          

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

   450           ECamSceneSports == iController.IntegerSettingValue( ECamSettingItemDynamicPhotoScene ) )

   451           {

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

   453           iActivePalette->SetItemVisibility( ECamCmdCaptureSetupFlashStill, EFalse );

   454           }

   455        else

   456           {

   457           iActivePalette->SetItemVisibility( ECamCmdCaptureSetupFlashStill, ETrue );    

   458           }

   459       }

   460   }

   461 

   462  

   463 // -----------------------------------------------------------------------------

   464 // CCamActivePaletteHandler::ReturnedFromPretendExitL

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

   466 // -----------------------------------------------------------------------------

   467 //   

   468  void CCamActivePaletteHandler::ReturnedFromPretendExitL()

   469     {

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

   471     if ( !iController.IsTouchScreenSupported() )

   472         {

   473         if ( iActivePalette ) 

   474             {       

   475              ResetToDefaultItem();

   476             }

   477             

   478         UpdateActivePaletteL();

   479         }

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

   481     }

   482 

   483 

   484 

   485 // -----------------------------------------------------------------------------

   486 // CCamActivePaletteHandler::ResetToFirstItem

   487 // Resets highlight to the first AP item

   488 // -----------------------------------------------------------------------------

   489 //   

   490 void CCamActivePaletteHandler::ResetToFirstItem()

   491     {

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

   493     if ( !iController.IsTouchScreenSupported() )

   494         {

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

   496             {

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

   498             } 

   499         }

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

   501     }     

   502 

   503 

   504 

   505 // -----------------------------------------------------------------------------

   506 // CCamActivePaletteHandler::ResetToDefaultItem

   507 // Resets highlight to the default AP item

   508 // -----------------------------------------------------------------------------

   509 //   

   510 void CCamActivePaletteHandler::ResetToDefaultItem()

   511     {

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

   513     if ( !iController.IsTouchScreenSupported() )

   514         {

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

   516         if( !appUi->IsEmbedded() 

   517 /*#ifndef __WINS__

   518             || appUi->IsInCallSend()           

   519 #endif*/

   520           )

   521             {          

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

   523                 {

   524                 // In static toolbar, always reset to second item 

   525                 // First item selected to adjust the visible items

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

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

   528                 } 

   529             }

   530         else

   531             {

   532             ResetToFirstItem();

   533             }

   534         }

   535     PRINT( _L("Camera <= CCamActivePaletteHandler::ResetToDefaultItem"));  

   536     }     

   537   

   538 

   539  

   540 // -----------------------------------------------------------------------------

   541 // CCamActivePaletteHandler::UpdateActivePaletteL

   542 // Force Active palette update

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

   544 // -----------------------------------------------------------------------------

   545 //   

   546  void CCamActivePaletteHandler::UpdateActivePaletteL()

   547   {

   548   PRINT( _L("Camera => CCamActivePaletteHandler::UpdateActivePaletteL"))

   549   if ( !iController.IsTouchScreenSupported() )

   550       {

   551       TBool orientation = iController.UiConfigManagerPtr() && 

   552                           iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported();

   553       if( iUpdatesDisabled )

   554         {

   555         PRINT( _L("Camera <= CCamActivePaletteHandler::UpdateActivePaletteL (updates disabled)"))    

   556         return;

   557         }

   558       

   559       if( !iActivePalette )

   560         {

   561         PRINT( _L("Camera <= CCamActivePaletteHandler::UpdateActivePaletteL no palette"))

   562         return;

   563         }

   564 

   565       HBufC8* package = NULL;

   566       TInt messageId = -1;      

   567       TInt count = iItemArray.Count();

   568       for( TInt i = 0; i < count; i++ )

   569         {

   570         TCamAPSettingsItem settingItem;

   571         

   572         TCamActivePaletteItem& item = iItemArray[i];

   573            

   574         settingItem.iSettingItem = item.iItemId;

   575 

   576         switch (item.iType)

   577           {

   578           case ECamActivePaletteItemTypeCommand:

   579             {

   580             // Tooltip or icon will now change for command type item

   581             break;

   582             }

   583           case ECamActivePaletteItemTypePreCapture:

   584           case ECamActivePaletteItemTypePostCapture:

   585             {

   586             if ( item.iItemId >= 0 )

   587               {

   588               // attempt to get actual setting value

   589               // get handle to controller

   590               settingItem.iSettingVal = iController.IntegerSettingValue( item.iItemId );

   591 

   592               if( !orientation || 

   593                 ( orientation && 

   594                   settingItem.iSettingVal != iCurrentValSettingsItem[i].iSettingVal ) )

   595                   {

   596                   TPckgBuf<TCamAPSettingsItem> buf( settingItem );

   597                   TInt iconId = GetBitmapIdFromValueL( settingItem );

   598 

   599                   if ( iconId != KErrNotFound )

   600                     {

   601                     TCamAPGenericPluginIcon icon( iconId, iconId );

   602                     TPckgC<TCamAPGenericPluginIcon> iconPckg( icon );

   603                     package = iconPckg.AllocLC();

   604                     messageId = EAPGenericPluginChangeIcon;

   605                     }

   606                   }

   607               }

   608             break;

   609             }

   610           case ECamActivePaletteItemTypePreCaptureNonSetting:

   611             {

   612             settingItem.iSettingVal = DetermineNonSettingState( item );

   613 

   614             if( !orientation || 

   615               ( orientation &&

   616                 settingItem.iSettingVal !=  iCurrentValSettingsItem[i].iSettingVal ) )

   617               {

   618               iIconId = GetBitmapIdFromValueL( settingItem );

   619               PRINT1( _L("Camera <> CCamActivePaletteHandler::UpdateActivePaletteL icon id %d"), iIconId);

   620               if( iIconId != KErrNotFound )

   621                 {

   622                 SetNonSettingItemTooltipL( item );

   623                 TCamAPGenericPluginParams params (

   624                         TCamAPGenericPluginParams::EGenericCustomResFile,

   625                         *iIconFileName,      // bitmap filename

   626                         iIconId,           // icon

   627                         iIconId,           // mask

   628                         *iToolTipText, // text

   629                         item.iCmdId,       // message ID

   630                         0 );               // Custom param

   631                 TPckg<TCamAPGenericPluginParams> paramsPckg( params );

   632                 package = paramsPckg.AllocLC();

   633                 messageId = EAPGenericPluginChangeParams;

   634                 }

   635               }

   636             break;

   637             }

   638           default:

   639             {

   640             PRINT( _L("Camera <> CCamActivePaletteHandler::UpdateActivePaletteL: Unknown item, PANIC!!!") );

   641             __ASSERT_DEBUG( EFalse, CamPanic( ECamPanicInvalidActivePaletteItemType ) );

   642             }                                            

   643           } // switch

   644         if ( package )

   645           {

   646           // if the value of the AP item has changed update the local settings value cache

   647           if ( orientation ) 

   648             {

   649             iCurrentValSettingsItem[i].iSettingVal = settingItem.iSettingVal;

   650             }

   651 

   652           // Change item by sending message to the generic plugin

   653           iActivePalette->SendMessage( item.iCmdId, messageId, *package) ;

   654           CleanupStack::PopAndDestroy( package );

   655           package = NULL;

   656           }

   657         } // for

   658 

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

   660         {

   661         CheckFlashItemVisibilityL();

   662         }

   663       

   664       }

   665    

   666   PRINT( _L("Camera <= CCamActivePaletteHandler::UpdateActivePaletteL"))

   667   }

   668 

   669 // -----------------------------------------------------------------------------

   670 // CCamActivePaletteHandler::SetView

   671 // Set current view

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

   673 // -----------------------------------------------------------------------------

   674 //    

   675 void CCamActivePaletteHandler::SetView( CCamViewBase* aView )

   676   {

   677   iView = aView;

   678   }

   679 

   680 // -----------------------------------------------------------------------------

   681 // CCamActivePaletteHandler::SetVisibility

   682 // Set Active palette visiblity

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

   684 // -----------------------------------------------------------------------------

   685 //   

   686 void CCamActivePaletteHandler::SetVisibility( TBool aVisibility )

   687   {

   688   PRINT2(_L("Camera => CCamActivePaletteHandler::SetVisibility from %d to %d"), iVisible, aVisibility)

   689   

   690   if ( !iController.IsTouchScreenSupported() )

   691       {

   692       // Only animate if we're moving to a different state

   693       if ( iVisible != aVisibility && iActivePalette )

   694         {

   695         iVisible = aVisibility;

   696         if ( ECamCapturing == iController.CurrentOperation() || 

   697            (!iStarted && 

   698             !iController.UiConfigManagerPtr()->IsUIOrientationOverrideSupported() ) || 

   699             !aVisibility )

   700             {

   701             iActivePalette->SetPaletteVisibility(iVisible, EFalse);

   702             iStarted = ETrue;

   703             PRINT(_L("AP NO animation"));

   704             }

   705         else

   706             {

   707             iActivePalette->SetPaletteVisibility(iVisible,ETrue,100);

   708             PRINT(_L("AP animation"));

   709             }

   710                    

   711         PERF_MESSAGE_L2( EPerfMessageActivePaletteAnimationStarting );

   712         PRINT(_L("AP animation started"));

   713         }

   714         

   715       if ( iController.IsTouchScreenSupported() )

   716           {

   717           if ( iActivePalette )

   718               {

   719               iActivePalette->SetPaletteVisibility( EFalse, EFalse );

   720               }

   721           }

   722       }

   723   

   724   PRINT(_L("Camera <= CCamActivePaletteHandler::SetVisibility"))

   725   }

   726 

   727 // -----------------------------------------------------------------------------

   728 // CCamActivePaletteHandler::IsVisible

   729 // Return Active palette visiblity

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

   731 // -----------------------------------------------------------------------------

   732 //    

   733 TBool CCamActivePaletteHandler::IsVisible() const

   734   {

   735   return iVisible;

   736   }

   737     

   738 // -----------------------------------------------------------------------------

   739 // CCamActivePaletteHandler::SetVisibility

   740 // Whether AP has requested item

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

   742 // -----------------------------------------------------------------------------

   743 // 

   744 TBool CCamActivePaletteHandler::AccessedViaAP() const

   745   {

   746   return iItemAccessedViaAP;

   747   }

   748         

   749 // -----------------------------------------------------------------------------

   750 // CCamActivePaletteHandler::APOperationComplete

   751 // Inform AP handler AP launched item has completed

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

   753 // -----------------------------------------------------------------------------

   754 //

   755 void CCamActivePaletteHandler::APOperationComplete()

   756   {

   757   iItemAccessedViaAP = EFalse;

   758   }

   759      

   760 // -----------------------------------------------------------------------------

   761 // CCamActivePaletteHandler::HandleAPKeyEventL

   762 // Pass keys events to Active Palette

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

   764 // -----------------------------------------------------------------------------

   765 //        

   766 void 

   767 CCamActivePaletteHandler::HandleAPKeyEventL( const TKeyEvent& /* aKeyEvent */, 

   768                                                    TEventCode /* aType */ )

   769   {

   770   }

   771         

   772 // -----------------------------------------------------------------------------

   773 // CCamActivePaletteHandler::CreateActivePaletteL

   774 // Create the Active Palette

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

   776 // -----------------------------------------------------------------------------

   777 //         

   778                                     

   779 void 

   780 CCamActivePaletteHandler::CreateActivePaletteL(const CCoeControl &aContainerWindow,

   781                                                      MObjectProvider *aMopParent)

   782   {

   783   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMACTIVEPALETTEHANDLER_CREATEACTIVEPALETTEL, "e_CCamActivePaletteHandler_CreateActivePaletteL 1" );

   784   PRINT(_L("Camera => CCamActivePaletteHandler::CreateActivePaletteL"))

   785   PERF_EVENT_START_L2( EPerfEventActivePaletteConstruction );    

   786    

   787   if ( !iController.IsTouchScreenSupported() )

   788       {

   789       if(!iActivePalette)

   790         {

   791         // Variate this according to usage of Direct Screen viewfinder

   792         if ( iController.IsDirectScreenVFSupported() )

   793             {

   794             iActivePalette = ActivePalette2Factory::CreateActivePaletteUIL(EAP2DrawModeCheckerboard);

   795             }

   796         else

   797             {

   798             iActivePalette = ActivePalette2Factory::CreateActivePaletteUIL(KActivePaletteDrawMode);

   799             }

   800         iActivePalette->SetObserver(this);

   801         }

   802       else

   803         {

   804         ClearActivePalette();

   805         }        

   806       iActivePalette->CoeControl()->SetContainerWindowL( aContainerWindow ); 

   807       iActivePalette->CoeControl()->SetMopParent( aMopParent );

   808       iActivePalette->LocateTo(APScreenLocation( TPoint(280, 30) ));

   809       iActivePalette->SetPaletteVisibility(EFalse,EFalse);

   810       iVisible=EFalse;

   811       }

   812    

   813   PERF_EVENT_END_L2( EPerfEventActivePaletteConstruction );                            

   814   PRINT(_L("Camera <= CCamActivePaletteHandler::CreateActivePaletteL"))

   815   OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMACTIVEPALETTEHANDLER_CREATEACTIVEPALETTEL, "e_CCamActivePaletteHandler_CreateActivePaletteL 0" );

   816   }

   817 

   818 // -----------------------------------------------------------------------------

   819 // CCamActivePaletteHandler::DestroyActivePalette

   820 // Deletes the Active Palette

   821 // -----------------------------------------------------------------------------

   822 //

   823 void CCamActivePaletteHandler::DestroyActivePalette()

   824   {

   825   if ( !iController.IsTouchScreenSupported() )

   826       {

   827       delete iActivePalette;

   828       iActivePalette = NULL;

   829       }

   830   }

   831 

   832 //

   833 // -----------------------------------------------------------------------------

   834 // CCamActivePaletteHandler::NotifyItemFocused

   835 // Handle a change of item focus in the active palette

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

   837 // -----------------------------------------------------------------------------

   838 //

   839 void CCamActivePaletteHandler::NotifyItemFocused(TInt /*aPrevItem*/, TInt /*aFocusedItem*/)

   840     {

   841     // We don't care about changes in item focus.

   842     }

   843 

   844 

   845 // 

   846 //

   847 // -----------------------------------------------------------------------------

   848 // CCamActivePaletteHandler::NotifyItemSelected

   849 // Pass keys events to Active Palette

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

   851 // -----------------------------------------------------------------------------

   852 // 

   853 void CCamActivePaletteHandler::NotifyItemSelected(const TActivePalette2EventData & aEvent)

   854   {

   855   PRINT1( _L("Camera => CCamActivePaletteHandler::NotifyItemSelected item (%d)"), aEvent.CurItem() );

   856   

   857   if ( !iController.IsTouchScreenSupported() )

   858       {

   859       if( iView && iVisible )

   860         {       

   861         TRAPD(ignore, iView->HandleCommandL( aEvent.CurItem()) );

   862         

   863         // Handling a command implies a container switch, so we need to switch the activepalette back

   864         // to the system Gc.

   865         iActivePalette->SetGc();

   866           

   867         // Error -14 (KErrInUse) must be handled here or it's ignored and there's no error note   

   868         if( ignore == KErrInUse )

   869           {

   870           PRINT( _L( "Camera <> CCamActivePaletteHandler::NotifyItemSelected KErrInUse" ) );

   871           

   872           // Get the application caption (name)

   873           RApaLsSession ls;

   874           TApaAppInfo appInfo;

   875           TRAPD(err1, ls.Connect() );

   876           if( err1 != KErrNone)

   877               {

   878               ls.Close();

   879               return;

   880               }

   881           TRAPD(err2, ls.GetAppInfo(appInfo, TUid::Uid(KCameraappUID)) );

   882           if( err2 != KErrNone)

   883               {

   884               ls.Close();

   885               return;

   886               }

   887           TApaAppCaption  appCaption = appInfo.iCaption;

   888           ls.Close();

   889           

   890           // Get the correct error description

   891           CTextResolver* iTextResolver = NULL;

   892           

   893           TRAPD(err3, iTextResolver = CTextResolver::NewL());

   894           if( err3 != KErrNone)

   895               {

   896               return;

   897               }

   898           TPtrC buf;

   899           buf.Set( iTextResolver->ResolveErrorString( ignore, CTextResolver::ECtxNoCtxNoSeparator ) );

   900           delete iTextResolver;

   901           iTextResolver = NULL;

   902           

   903           // Compose the full error message

   904           TBuf<100> fullnote;

   905           fullnote.Append(appCaption);

   906           fullnote.Append(':');

   907           fullnote.Append('\n');

   908           fullnote.Append(buf);

   909           

   910           // Display the error note 

   911           CAknErrorNote* dlg = new CAknErrorNote( ETrue );

   912           if(dlg==NULL)

   913               {

   914               return;

   915               }

   916           TRAPD(err4, dlg->ExecuteLD( fullnote ));

   917           if( err4 != KErrNone)

   918               {

   919               return;

   920               }

   921           }

   922         iItemAccessedViaAP = ETrue;

   923         }

   924       }

   925   PRINT( _L("Camera <= CCamActivePaletteHandler::NotifyItemSelected") );

   926   }

   927 

   928 // -----------------------------------------------------------------------------

   929 // CCamActivePaletteHandler::NotifyItemComplete

   930 // 

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

   932 // -----------------------------------------------------------------------------

   933 // 

   934 void CCamActivePaletteHandler::NotifyItemComplete(const TActivePalette2EventData& /*aEvent*/,

   935                                                   const TDesC8& /*aDataDes*/, 

   936                                                   TInt /*aDataInt*/)        

   937     {

   938     }

   939 

   940 // -----------------------------------------------------------------------------

   941 // CCamActivePaletteHandler::NotifyMessage

   942 // 

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

   944 // -----------------------------------------------------------------------------

   945 //                          

   946 void 

   947 CCamActivePaletteHandler::NotifyMessage(

   948     const TActivePalette2EventData& /*aEvent*/,

   949     TInt /*aMessageID*/,

   950     const TDesC8& /*aDataDes*/,

   951     TInt /*aDataInt*/ )   

   952   {

   953   }

   954     

   955 // -----------------------------------------------------------------------------

   956 // CCamActivePaletteHandler::Redraw

   957 //

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

   959 // -----------------------------------------------------------------------------

   960 void CCamActivePaletteHandler::Redraw(const TRect& aArea)

   961   {

   962   if ( iView )

   963     {

   964     iView->RedrawAPArea( aArea );

   965     }

   966   }

   967     

   968 // -----------------------------------------------------------------------------

   969 // CCamActivePaletteHandler::ActivePaletteUpdated

   970 //

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

   972 // -----------------------------------------------------------------------------

   973 void CCamActivePaletteHandler::ActivePaletteUpdated()

   974   {

   975   }         

   976     

   977 // -----------------------------------------------------------------------------

   978 // CCamActivePaletteHandler::LoadPostCaptureResourcesL

   979 // Load resource for post-capture item

   980 // -----------------------------------------------------------------------------

   981 //

   982 void CCamActivePaletteHandler::LoadPostCaptureResourcesL( TInt aResourceId )

   983   {

   984   if ( !iController.IsTouchScreenSupported() )

   985       {

   986       TResourceReader reader;

   987       iEnv->CreateResourceReaderLC(reader, aResourceId);

   988       

   989       // Store tooltip text and icon ID in member variables

   990       TPtrC ptr = reader.ReadTPtrC();

   991       delete iToolTipText;

   992       iToolTipText = NULL;

   993       iToolTipText = ptr.AllocL();

   994       

   995       iIconId = reader.ReadInt16();

   996 

   997       CleanupStack::PopAndDestroy();  // reader

   998       }

   999   }

  1000     

  1001 // -----------------------------------------------------------------------------

  1002 // CCamActivePaletteHandler::PreCaptureArrayId

  1003 // Map settings item to CAM_CAPTURE_SETUP_MENU_ITEM_ARRAY  type resource id 

  1004 // -----------------------------------------------------------------------------

  1005 //

  1006 TInt CCamActivePaletteHandler::PreCaptureArrayId( TInt aSettingItem )

  1007   {

  1008   PRINT( _L("Camera => CCamActivePaletteHandler::PreCaptureArrayId") );

  1009   TBool extLightSensitivitySupported = EFalse;

  1010   TInt resId = KErrNotFound;

  1011   if ( !iController.IsTouchScreenSupported() )

  1012       {

  1013       switch( aSettingItem )

  1014         {

  1015         // -----------------------------------------------------

  1016         case ECamSettingItemDynamicVideoScene:

  1017           resId = R_CAM_CAPTURE_SETUP_MENU_VIDEO_SCENE_ARRAY;

  1018           break;       

  1019         // -----------------------------------------------------

  1020         case ECamSettingItemDynamicVideoWhiteBalance:

  1021           resId = R_CAM_CAPTURE_SETUP_MENU_VIDEO_WHITE_BALANCE_ARRAY;

  1022           break;

  1023         // -----------------------------------------------------

  1024         case ECamSettingItemDynamicVideoExposure:

  1025           break;

  1026         // -----------------------------------------------------

  1027     // Replaced by ECamSettingItemDynamicVideoLightSensitivity

  1028     //    case ECamSettingItemDynamicVideoISO:

  1029     //      break;

  1030         // -----------------------------------------------------

  1031         case ECamSettingItemDynamicVideoColourFilter:

  1032           resId = R_CAM_CAPTURE_SETUP_MENU_VIDEO_COLOURFILTER_ARRAY;

  1033           break;

  1034         // -----------------------------------------------------

  1035         case ECamSettingItemDynamicVideoBrightness:

  1036           break;

  1037         // -----------------------------------------------------

  1038         case ECamSettingItemDynamicVideoContrast:

  1039           break;

  1040         // -----------------------------------------------------

  1041         case ECamSettingItemDynamicVideoColourSaturation:

  1042           break;

  1043         // -----------------------------------------------------

  1044         case ECamSettingItemDynamicPhotoScene:

  1045           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_SCENE_ARRAY;

  1046           break;       

  1047         // -----------------------------------------------------

  1048         case ECamSettingItemDynamicPhotoWhiteBalance:

  1049           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_WHITE_BALANCE_ARRAY;

  1050           break;       

  1051         // -----------------------------------------------------

  1052         case ECamSettingItemDynamicPhotoExposure:

  1053           resId = iEvCompRes;

  1054           break;       

  1055         // -----------------------------------------------------

  1056     // Replaced by ECamSettingItemDynamicPhotoLightSensitivity

  1057     //    case ECamSettingItemDynamicPhotoISO:

  1058     //      break;       

  1059         // -----------------------------------------------------

  1060         case ECamSettingItemDynamicPhotoColourFilter:

  1061           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_COLOURFILTER_ARRAY;

  1062           break;       

  1063         // -----------------------------------------------------

  1064         case ECamSettingItemDynamicPhotoFlash:

  1065           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_FLASH_ARRAY;

  1066           break;       

  1067         // -----------------------------------------------------  

  1068         case ECamSettingItemDynamicVideoFlash:

  1069           resId = R_CAM_CAPTURE_SETUP_MENU_VIDEO_FLASH_ARRAY;

  1070           break;

  1071         // -----------------------------------------------------

  1072         case ECamSettingItemDynamicPhotoBrightness:

  1073           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_BRIGHTNESS_ARRAY;

  1074           break;       

  1075         // -----------------------------------------------------

  1076         case ECamSettingItemDynamicPhotoContrast:

  1077           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_CONTRAST_ARRAY;

  1078           break;       

  1079         // -----------------------------------------------------

  1080         case ECamSettingItemDynamicPhotoImageSharpness:

  1081           resId = R_CAM_CAPTURE_SETUP_MENU_PHOTO_IMAGESHARPNESS_ARRAY;

  1082           break;       

  1083         // -----------------------------------------------------

  1084         case ECamSettingItemDynamicPhotoColourSaturation:

  1085           break;

  1086         // -----------------------------------------------------  

  1087         case ECamSettingItemFaceTracking:

  1088           resId = R_CAM_ACTIVE_PALETTE_PRECAPTURE_FACETRACKING_ARRAY;

  1089           break;

  1090         // -----------------------------------------------------

  1091         case ECamSettingItemSequenceMode:

  1092           resId = R_CAM_ACTIVE_PALETTE_PRECAPTURE_SEQUENCE_MODE_ARRAY;

  1093           break;         

  1094         // -----------------------------------------------------

  1095         case ECamSettingItemVideoModeSelect:

  1096           resId = R_CAM_ACTIVE_PALETTE_PRECAPTURE_VIDEO_MODE_SELECT;

  1097           break;

  1098         // -----------------------------------------------------

  1099         case ECamSettingItemImageModeSelect:

  1100           resId = R_CAM_ACTIVE_PALETTE_PRECAPTURE_IMAGE_MODE_SELECT;

  1101           break;

  1102         case ECamSettingItemSwitchCamera:

  1103             resId = R_CAM_ACTIVE_PALETTE_PRECAPTURE_SWITCH_CAMERA;

  1104             break;

  1105         // -----------------------------------------------------

  1106         case ECamSettingItemDynamicSelfTimer:

  1107           resId = R_CAM_ACTIVE_PALETTE_SELF_TIMER_SELECT;

  1108           break;

  1109         // -----------------------------------------------------

  1110         case ECamSettingItemDynamicPhotoLightSensitivity:

  1111         case ECamSettingItemDynamicVideoLightSensitivity:

  1112           extLightSensitivitySupported = 

  1113              iController.UiConfigManagerPtr()->IsExtendedLightSensitivitySupported();

  1114           if ( extLightSensitivitySupported ) 

  1115               {

  1116               resId = R_CAM_ACTIVE_PALETTE_EXTENDED_LIGHT_SENSITIVITY_SELECT;

  1117               } 

  1118           else 

  1119               {

  1120               resId = R_CAM_ACTIVE_PALETTE_LIGHT_SENSITIVITY_SELECT;

  1121               }

  1122           break;

  1123         // -----------------------------------------------------

  1124         case ECamSettingItemViewfinderGrid:

  1125           resId = R_CAM_ACTIVE_PALETTE_VF_GRID_SET_ARRAY;

  1126           break;

  1127         // -----------------------------------------------------

  1128         case ECamSettingItemGotoPhotos:

  1129             resId = R_CAM_ACTIVE_PALETTE_GOTO_PHOTOS_SET_ARRAY;

  1130             break;

  1131         // -----------------------------------------------------          

  1132         default:

  1133           break;

  1134         // -----------------------------------------------------

  1135         } // switch