uifw/EikStd/coctlsrc/EIKMENUP.CPP
branchRCL_3
changeset 23 3d340a0166ff
parent 18 0aa5fbdfbc30
child 25 941195f2d488
equal deleted inserted replaced
18:0aa5fbdfbc30 23:3d340a0166ff
   141     void StartCascadeMenuAppearTransition();
   141     void StartCascadeMenuAppearTransition();
   142 
   142 
   143     /**
   143     /**
   144      * Prepares cascade menu for item specific commands.
   144      * Prepares cascade menu for item specific commands.
   145      */
   145      */
   146     void PrepareCascadeForItemCommands();
   146     void PrepareCascadeForItemCommandsL();
   147 
   147 
   148     /**
   148     /**
   149      * Returns ETrue if this menu pane belongs to a CS menu.
   149      * Returns ETrue if this menu pane belongs to a CS menu.
   150      * 
   150      * 
   151      * @return ETrue if this menu pane belongs to a CS menu.
   151      * @return ETrue if this menu pane belongs to a CS menu.
   235         {
   235         {
   236         ESingleClickEnabled,
   236         ESingleClickEnabled,
   237         EHideItemSpecificCommands,
   237         EHideItemSpecificCommands,
   238         EContextSensitive,
   238         EContextSensitive,
   239         ESkipScrollbarUpdate,
   239         ESkipScrollbarUpdate,
   240         EHighlightEnabled
   240         EHighlightEnabled,
       
   241         EHideViewSpecificCommands
   241         };
   242         };
   242 
   243 
   243     /**
   244     /**
   244      * Menu pane extension flags.
   245      * Menu pane extension flags.
   245      */
   246      */
   837     CEikMenuPane* cascadeMenuPane = iControl->iCascadeMenuPane;
   838     CEikMenuPane* cascadeMenuPane = iControl->iCascadeMenuPane;
   838     if ( cascadeMenuPane )
   839     if ( cascadeMenuPane )
   839         {
   840         {
   840         cascadeMenuPane->SetParent( iControl );
   841         cascadeMenuPane->SetParent( iControl );
   841         GfxTransEffect::Begin( cascadeMenuPane, KGfxControlAppearAction );
   842         GfxTransEffect::Begin( cascadeMenuPane, KGfxControlAppearAction );
       
   843         if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
       
   844             {
       
   845             ImmediateFeedback( ETouchFeedbackSubMenuOpened,
       
   846                                             ETouchFeedbackVibra );
       
   847             }
   842         cascadeMenuPane->StartDisplayingMenuPane( iControl->iHotKeyTable,
   848         cascadeMenuPane->StartDisplayingMenuPane( iControl->iHotKeyTable,
   843                                                   iControl->Position(),
   849                                                   iControl->Position(),
   844                                                   NULL,
   850                                                   NULL,
   845                                                   0,
   851                                                   0,
   846                                                   EPopupTargetBottomLeft );
   852                                                   EPopupTargetBottomLeft );
  1246         }
  1252         }
  1247 		
  1253 		
  1248     iFlags.Clear( EHideItemSpecificCommands );
  1254     iFlags.Clear( EHideItemSpecificCommands );
  1249     iFlags.Clear( EContextSensitive );
  1255     iFlags.Clear( EContextSensitive );
  1250     iFlags.Clear( EHighlightEnabled );
  1256     iFlags.Clear( EHighlightEnabled );
       
  1257     iFlags.Clear( EHideViewSpecificCommands );
  1251     _AKNTRACE_FUNC_EXIT;
  1258     _AKNTRACE_FUNC_EXIT;
  1252     }
  1259     }
  1253 
  1260 
  1254 
  1261 
  1255 // -----------------------------------------------------------------------------
  1262 // -----------------------------------------------------------------------------
  1327 //
  1334 //
  1328 void CEikMenuPaneExtension::ImmediateFeedback(
  1335 void CEikMenuPaneExtension::ImmediateFeedback(
  1329     TTouchLogicalFeedback aType,
  1336     TTouchLogicalFeedback aType,
  1330     TTouchFeedbackType aFbType  = TTouchFeedbackType( ETouchFeedbackAudio |
  1337     TTouchFeedbackType aFbType  = TTouchFeedbackType( ETouchFeedbackAudio |
  1331                                                       ETouchFeedbackVibra ))
  1338                                                       ETouchFeedbackVibra ))
  1332     {   
  1339     {
  1333     if ( iFeedback )
  1340     if( iFeedback && AknLayoutUtils::PenEnabled() )
  1334         {
  1341         {
  1335         iFeedback->InstantFeedback( iControl, aType, aFbType, TPointerEvent() );
  1342         iFeedback->InstantFeedback( iControl, aType, aFbType, TPointerEvent() );
  1336         }
  1343         }
  1337     }
  1344     }
  1338 
  1345 
  1339 
  1346 
  1340 // -----------------------------------------------------------------------------
  1347 // -----------------------------------------------------------------------------
  1341 // CEikMenuPaneExtension::PrepareCascadeForItemCommands
  1348 // CEikMenuPaneExtension::PrepareCascadeForItemCommandsL
  1342 // -----------------------------------------------------------------------------
  1349 // -----------------------------------------------------------------------------
  1343 //
  1350 //
  1344 void CEikMenuPaneExtension::PrepareCascadeForItemCommands()
  1351 void CEikMenuPaneExtension::PrepareCascadeForItemCommandsL()
  1345     {
  1352     {
  1346     if ( iFlags.IsSet( ESingleClickEnabled )
  1353     if ( iFlags.IsSet( ESingleClickEnabled )
  1347             && iControl->iOwner
  1354             && iControl->iOwner
  1348             && iControl->iOwner->iExtension )
  1355             && iControl->iOwner->iExtension )
  1349         {
  1356         {
  1352             {
  1359             {
  1353             iFlags.Set( EContextSensitive );
  1360             iFlags.Set( EContextSensitive );
  1354             }
  1361             }
  1355         else if ( ownerFlags.IsSet( EHideItemSpecificCommands ) )
  1362         else if ( ownerFlags.IsSet( EHideItemSpecificCommands ) )
  1356             {
  1363             {
  1357             iControl->SetItemCommandsDimmed();
  1364             iControl->SetItemCommandsStateL( ETrue );
  1358             }
  1365             }
  1359         }
  1366         }
  1360     }
  1367     }
  1361 
  1368 
  1362 
  1369 
  1793 //
  1800 //
  1794 EXPORT_C CEikMenuPane::~CEikMenuPane()
  1801 EXPORT_C CEikMenuPane::~CEikMenuPane()
  1795     {
  1802     {
  1796     _AKNTRACE_FUNC_ENTER;
  1803     _AKNTRACE_FUNC_ENTER;
  1797     AKNTASHOOK_REMOVE();
  1804     AKNTASHOOK_REMOVE();
       
  1805 
       
  1806     if ( iIsDeleted )
       
  1807         {
       
  1808         *iIsDeleted = ETrue;
       
  1809         iIsDeleted = NULL;
       
  1810         }
       
  1811     
  1798     CloseCascadeMenu();
  1812     CloseCascadeMenu();
  1799     if ( !ItemArrayOwnedExternally() )
  1813     if ( !ItemArrayOwnedExternally() )
  1800         {
  1814         {
  1801         delete iItemArray;
  1815         delete iItemArray;
  1802         iItemArray  = NULL;
  1816         iItemArray  = NULL;
  2244     if (iEditMenuObserver)
  2258     if (iEditMenuObserver)
  2245         {
  2259         {
  2246         iEditMenuObserver->DynInitMenuPaneL( aCascadeMenuId, iCascadeMenuPane );
  2260         iEditMenuObserver->DynInitMenuPaneL( aCascadeMenuId, iCascadeMenuPane );
  2247         }
  2261         }
  2248 
  2262 
  2249     iCascadeMenuPane->iExtension->PrepareCascadeForItemCommands();
  2263     iCascadeMenuPane->iExtension->PrepareCascadeForItemCommandsL();
  2250     iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
  2264     iCascadeMenuPane->iExtension->EnableHighlight( EFalse );
  2251     iCascadeMenuPane->FilterDimmedItems();
  2265     iCascadeMenuPane->FilterDimmedItems();
  2252 
  2266 
  2253     // cascade menu launch animation
  2267     // cascade menu launch animation
  2254     if ( iExtension->iRedirectionListener )
  2268     if ( iExtension->iRedirectionListener )
  2257         }
  2271         }
  2258     else
  2272     else
  2259         {
  2273         {
  2260         iExtension->StartCascadeMenuAppearTransition();
  2274         iExtension->StartCascadeMenuAppearTransition();
  2261         }
  2275         }
  2262 
  2276     iExtension->ImmediateFeedback( ETouchFeedbackPopUp,
  2263     TTouchLogicalFeedback fbLogicalType = ETouchFeedbackPopUp;
       
  2264     if ( CAknTransitionUtils::TransitionsEnabled( AknTransEffect::EComponentTransitionsOff ) )
       
  2265         {
       
  2266         fbLogicalType = ETouchFeedbackSubMenuOpened;
       
  2267         }
       
  2268     iExtension->ImmediateFeedback( fbLogicalType,
       
  2269                                        ETouchFeedbackVibra );
  2277                                        ETouchFeedbackVibra );
  2270     _AKNTRACE_FUNC_EXIT;
  2278     _AKNTRACE_FUNC_EXIT;
  2271     }
  2279     }
  2272 
  2280 
  2273 // -----------------------------------------------------------------------------
  2281 // -----------------------------------------------------------------------------
  3097         // 'this' might be destroyed by calling iMenuObserver->ProcessCommandL(
  3105         // 'this' might be destroyed by calling iMenuObserver->ProcessCommandL(
  3098         // commandId ), so need to avoid crash
  3106         // commandId ), so need to avoid crash
  3099         CEikMenuPane* menu = iOwner ? iOwner : this;
  3107         CEikMenuPane* menu = iOwner ? iOwner : this;
  3100         MCoeControlObserver* observer = menu->Observer();
  3108         MCoeControlObserver* observer = menu->Observer();
  3101 
  3109 
  3102         if ( commandId != EAknCmdTaskSwapper )
  3110         if ( commandId >= EAknCmdMarkingModeEnter 
       
  3111                 && commandId <= EAknCmdMarkingModeUnmarkAll )
       
  3112             {
       
  3113             CEikMenuBar* menuBar = static_cast<CEikMenuBar*>( Parent() );
       
  3114             if ( menuBar && menuBar->MenuPane() == this )
       
  3115                 {
       
  3116                 static_cast<MEikCommandObserver*>(
       
  3117                         menuBar)->ProcessCommandL( commandId );
       
  3118                 }
       
  3119             ReportCanceled();
       
  3120             }
       
  3121         else if ( commandId != EAknCmdTaskSwapper )
  3103             {
  3122             {
  3104             _AKNTRACE( "commandId = %d",  commandId );
  3123             _AKNTRACE( "commandId = %d",  commandId );
       
  3124             TBool isDeleted = EFalse;
       
  3125             iIsDeleted = &isDeleted;
  3105             iMenuObserver->ProcessCommandL( commandId ); 
  3126             iMenuObserver->ProcessCommandL( commandId ); 
       
  3127 
       
  3128             if ( !isDeleted )
       
  3129                 {
       
  3130                 CEikMenuBar* menuBar = static_cast<CEikMenuBar*>( Parent() );
       
  3131                 if ( menuBar && menuBar->MenuPane() == this )
       
  3132                     {
       
  3133                     static_cast<MEikCommandObserver*>(
       
  3134                             menuBar)->ProcessCommandL( commandId );
       
  3135                     }
       
  3136                 }            
       
  3137 
       
  3138             iIsDeleted = NULL;
  3106             }
  3139             }
  3107         else
  3140         else
  3108             {
  3141             {
  3109             ReportCanceled();
  3142             ReportCanceled();
  3110             return;
  3143             return;
  4012                 iExtension->CalculateParentEvent( aPointerEvent, parentEvent);
  4045                 iExtension->CalculateParentEvent( aPointerEvent, parentEvent);
  4013                 _AKNTRACE( "[%s]", "HandlePointerEventL return 6" );
  4046                 _AKNTRACE( "[%s]", "HandlePointerEventL return 6" );
  4014                 _AKNTRACE_FUNC_EXIT;
  4047                 _AKNTRACE_FUNC_EXIT;
  4015                 return iOwner->HandlePointerEventL( parentEvent );
  4048                 return iOwner->HandlePointerEventL( parentEvent );
  4016                 }
  4049                 }
  4017             iExtension->iDownOnMenuArea = EFalse;
       
  4018 
  4050 
  4019             iExtension->iPanningActive = EFalse;
  4051             iExtension->iPanningActive = EFalse;
  4020             if ( !(iExtension->iSct &&  iExtension->iSct->Rect().Contains( iExtension->iStartPoint ) ) )
  4052             if ( !(iExtension->iSct &&  iExtension->iSct->Rect().Contains( iExtension->iStartPoint ) ) 
       
  4053                 && iExtension->iDownOnMenuArea )
  4021                 {
  4054                 {
  4022                 TPoint drag = iExtension->iStartPoint - aPointerEvent.iPosition;
  4055                 TPoint drag = iExtension->iStartPoint - aPointerEvent.iPosition;
  4023                 if ( iExtension->iPhysics->StartPhysics( 
  4056                 if ( iExtension->iPhysics->StartPhysics( 
  4024                     drag, iExtension->iStartTime ) )
  4057                     drag, iExtension->iStartTime ) )
  4025                     {
  4058                     {
  4026                     iExtension->iFlickActive = ETrue;
  4059                     iExtension->iFlickActive = ETrue;
  4027                     iExtension->ResetPressedHighlight();
  4060                     iExtension->ResetPressedHighlight();
  4028                     }
  4061                     }
  4029                 }
  4062                 }
       
  4063              iExtension->iDownOnMenuArea = EFalse;
  4030             if ( iExtension->HighlightTimerActive() &&
  4064             if ( iExtension->HighlightTimerActive() &&
  4031                  !iExtension->iPressedDown )
  4065                  !iExtension->iPressedDown )
  4032                 {
  4066                 {
  4033                 // Complete the timer here if it's still running
  4067                 // Complete the timer here if it's still running
  4034                 // when up event is received.
  4068                 // when up event is received.
  4373                 aPointerEvent.iPosition;
  4407                 aPointerEvent.iPosition;
  4374             TInt threshold = drag.iY;      
  4408             TInt threshold = drag.iY;      
  4375             if( Abs( threshold ) > iExtension->iPhysics->DragThreshold() 
  4409             if( Abs( threshold ) > iExtension->iPhysics->DragThreshold() 
  4376                 && iExtension->iDownOnMenuArea )
  4410                 && iExtension->iDownOnMenuArea )
  4377                 {
  4411                 {
       
  4412                 iExtension->EnableHighlight( EFalse );
  4378                 iExtension->iButtonDownItem = KErrNotFound;
  4413                 iExtension->iButtonDownItem = KErrNotFound;
  4379                 iExtension->ResetPressedHighlight();
  4414                 iExtension->ResetPressedHighlight();
  4380                 iExtension->iNextHighlightItem = KErrNotFound;
  4415                 iExtension->iNextHighlightItem = KErrNotFound;
  4381                 iExtension->iPanningActive = ETrue;
  4416                 iExtension->iPanningActive = ETrue;
  4382                 iExtension->EnableHighlight( EFalse );
       
  4383                 }    
  4417                 }    
  4384                          
  4418                          
  4385             if ( iExtension->iPanningActive && iExtension->iDownOnMenuArea )
  4419             if ( iExtension->iPanningActive && iExtension->iDownOnMenuArea )
  4386                 {
  4420                 {
  4387                 TPoint delta( 
  4421                 TPoint delta( 
  6512     return menuPane;
  6546     return menuPane;
  6513     }
  6547     }
  6514 
  6548 
  6515 
  6549 
  6516 // -----------------------------------------------------------------------------
  6550 // -----------------------------------------------------------------------------
  6517 // CEikMenuPane::SetItemCommandsDimmed
  6551 // CEikMenuPane::SetItemCommandsStateL
  6518 // -----------------------------------------------------------------------------
  6552 // -----------------------------------------------------------------------------
  6519 //
  6553 //
  6520 void CEikMenuPane::SetItemCommandsDimmed()
  6554 void CEikMenuPane::SetItemCommandsStateL( TBool aDimmed )
  6521     {
  6555     {
  6522     if ( iExtension && iExtension->iFlags.IsSet(
  6556     if ( iExtension && iExtension->iFlags.IsSet(
  6523             CEikMenuPaneExtension::ESingleClickEnabled ) )
  6557             CEikMenuPaneExtension::ESingleClickEnabled ) )
  6524         {
  6558         {
  6525         iExtension->iFlags.Set(
  6559         if ( aDimmed )
  6526                 CEikMenuPaneExtension::EHideItemSpecificCommands );
  6560             {
       
  6561             iExtension->iFlags.Set(
       
  6562                     CEikMenuPaneExtension::EHideItemSpecificCommands );
       
  6563             }
       
  6564         else
       
  6565             {
       
  6566             iExtension->iFlags.Set(
       
  6567                     CEikMenuPaneExtension::EHideViewSpecificCommands );
       
  6568             }
  6527         for ( TInt i = 0; i < iItemArray->Count(); ++i )
  6569         for ( TInt i = 0; i < iItemArray->Count(); ++i )
  6528             {
  6570             {
  6529             CEikMenuPaneItem* item = iItemArray->At( i );
  6571             CEikMenuPaneItem* item = iItemArray->At( i );
  6530             if ( item->iData.iFlags & EEikMenuItemAction
  6572             TBool itemSpecificItem(
       
  6573                     item->iData.iFlags & EEikMenuItemAction
  6531                     || item->iData.iFlags & EEikMenuItemSpecific
  6574                     || item->iData.iFlags & EEikMenuItemSpecific
  6532                     || item->iData.iFlags & EEikMenuItemSpecificListQuery )
  6575                     || item->iData.iFlags & EEikMenuItemSpecificListQuery );
       
  6576             // Dim item specific items
       
  6577             if ( aDimmed && itemSpecificItem )
  6533                 {
  6578                 {
  6534                 item->iData.iFlags |= EEikMenuItemDimmed;
  6579                 item->iData.iFlags |= EEikMenuItemDimmed;
       
  6580                 }
       
  6581             // Dim items not item specific
       
  6582             else if ( !aDimmed
       
  6583                         && ( !itemSpecificItem
       
  6584                         || item->iData.iFlags & EEikMenuItemAction ) )
       
  6585                 {
       
  6586                 item->iData.iFlags |= EEikMenuItemDimmed;
       
  6587                 if ( item->iData.iCascadeId ) 
       
  6588                     {
       
  6589                     // i is not updated in AddCascadeMenuItemsToMenuL so going 
       
  6590                     // through added items again here. Then it goes through
       
  6591                     // also submenus of submenus. 
       
  6592                     AddCascadeMenuItemsToMenuL(
       
  6593                             item->iData.iCascadeId, ETrue, EFalse, NULL, i );
       
  6594                     }
  6535                 }
  6595                 }
  6536             }
  6596             }
  6537         }
  6597         }
  6538     }
  6598     }
  6539 
  6599 
  6558             // If menu item is not list query and it has cascade menu
  6618             // If menu item is not list query and it has cascade menu
  6559             // add cascade menu items to menu data directly
  6619             // add cascade menu items to menu data directly
  6560             if ( !( item->iData.iFlags & EEikMenuItemSpecificListQuery )
  6620             if ( !( item->iData.iFlags & EEikMenuItemSpecificListQuery )
  6561                     && item->iData.iCascadeId )
  6621                     && item->iData.iCascadeId )
  6562                 {
  6622                 {
  6563                 AddCascadeMenuItemsToActionMenuL(
  6623                 AddCascadeMenuItemsToMenuL(
  6564                         item->iData.iCascadeId, EFalse, aMenuData );
  6624                         item->iData.iCascadeId, EFalse, ETrue, &aMenuData );
  6565                 }
  6625                 }
  6566             // If menu item is list query or it does not have cascade menu
  6626             // If menu item is list query or it does not have cascade menu
  6567             else
  6627             else
  6568                 {
  6628                 {
  6569                 aMenuData.AddMenuItemToDataArrayL(
  6629                 aMenuData.AddMenuItemToDataArrayL(
  6575         // If item is not item specific, add its item specific cascade menu
  6635         // If item is not item specific, add its item specific cascade menu
  6576         // items if the item itself isn't dimmed.
  6636         // items if the item itself isn't dimmed.
  6577         else if ( item->iData.iCascadeId && 
  6637         else if ( item->iData.iCascadeId && 
  6578                 !( item->iData.iFlags & EEikMenuItemDimmed ) )
  6638                 !( item->iData.iFlags & EEikMenuItemDimmed ) )
  6579             {
  6639             {
  6580             AddCascadeMenuItemsToActionMenuL(
  6640             AddCascadeMenuItemsToMenuL(
  6581                     item->iData.iCascadeId, ETrue, aMenuData );
  6641                     item->iData.iCascadeId, ETrue, ETrue, &aMenuData );
  6582             }
  6642             }
  6583         }
  6643         }
  6584     }
  6644     }
  6585 
  6645 
  6586 
  6646 
  6587 // -----------------------------------------------------------------------------
  6647 // -----------------------------------------------------------------------------
  6588 // CEikMenuPane::AddCascadeMenuItemsToActionMenuL
  6648 // CEikMenuPane::AddCascadeMenuItemsToMenuL
  6589 // -----------------------------------------------------------------------------
  6649 // -----------------------------------------------------------------------------
  6590 //
  6650 //
  6591 void CEikMenuPane::AddCascadeMenuItemsToActionMenuL(
  6651 void CEikMenuPane::AddCascadeMenuItemsToMenuL(
  6592         TInt aCascadeId,
  6652         TInt aCascadeId,
  6593         TBool aItemSpecific,
  6653         TBool aItemSpecific,
  6594         CAknItemActionMenuData& aMenuData )
  6654         TBool aAddToItemActionMenu,
       
  6655         CAknItemActionMenuData* aMenuData,
       
  6656         TInt aItemIndex )
  6595     {
  6657     {
  6596     if ( aCascadeId && iCoeEnv->IsResourceAvailableL( aCascadeId ) )
  6658     if ( aCascadeId && iCoeEnv->IsResourceAvailableL( aCascadeId ) )
  6597         {
  6659         {
  6598         CEikMenuPane* cascadeMenu =
  6660         CEikMenuPane* cascadeMenu =
  6599             CEikMenuPane::NewItemCommandMenuL( iMenuObserver );
  6661             CEikMenuPane::NewItemCommandMenuL( iMenuObserver );
  6608             if ( ( aItemSpecific
  6670             if ( ( aItemSpecific
  6609                     && CEikMenuPaneExtension::ItemSpecificCommand( *item ) )
  6671                     && CEikMenuPaneExtension::ItemSpecificCommand( *item ) )
  6610                 || ( !aItemSpecific
  6672                 || ( !aItemSpecific
  6611                         && !( item->iData.iFlags & EEikMenuItemDimmed ) ) )
  6673                         && !( item->iData.iFlags & EEikMenuItemDimmed ) ) )
  6612                 {
  6674                 {
  6613                 aMenuData.AddMenuItemToDataArrayL(
  6675                 if ( aAddToItemActionMenu )
  6614                         item->iData.iCommandId,
  6676                     {
  6615                         item->iData.iCascadeId,
  6677                     aMenuData->AddMenuItemToDataArrayL(
  6616                         item->iData.iText );
  6678                             item->iData.iCommandId,
       
  6679                             item->iData.iCascadeId,
       
  6680                             item->iData.iText );
       
  6681                     }
       
  6682                 else 
       
  6683                     {
       
  6684                     InsertMenuItemL( item->iData, ++aItemIndex );
       
  6685                     }
  6617                 }
  6686                 }
  6618             }
  6687             }
  6619         CleanupStack::PopAndDestroy( cascadeMenu );
  6688         CleanupStack::PopAndDestroy( cascadeMenu );
  6620         }
  6689         }
  6621     }
  6690     }