/*
* Copyright (c) 2007 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:
* Version : %version: MM_71.1.17.1.70.2.1 % << Don't touch! Updated by Synergy at check-out.
*
*/
#include <e32keys.h>
#include <e32math.h>
#include <AknsDrawUtils.h>
#include <layoutmetadata.cdl.h>
#include <aknlongtapdetector.h>
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
#include <aknlistloadertfx.h>
#include <aknlistboxtfxinternal.h>
#include <aknlistboxtfx.h>
#endif
#include "mmwidgetcontainer.h"
#include "mmlistboxmodel.h"
#include "mmmarqueeadapter.h"
#include "mmwidgetobserver.h"
#include "mmvisibilityobserver.h"
#include "mmlistboxcontainer.h"
#include "mmgridcontainer.h"
#include "mmlistboxitemdrawer.h"
#include "mmmarqueeadapter.h"
#include "mmfloatingitem.h"
#include "hnsuitemodel.h"
#include "hnitemsorder.h"
#include "menudebug.h"
#include "mmdraweranimator.h"
#include "hnglobals.h"
#include "mmpostevaluationprocessor.h"
#include "mmgrid.h"
#include "mmlongtapobserver.h"
class CMmTemplateLibrary;
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TMmWidgetPosition::TMmWidgetPosition()
: iVerticalItemOffset( 0 )
, iTopItemIndex( KErrNotFound )
, iValid( EFalse )
, iLandscape( EFalse )
, iHighlightedItemId( KErrNotFound )
{
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMmWidgetContainer* CMmWidgetContainer::NewGridContainerL( const TRect& aRect,
MObjectProvider* aObjectProvider, CMmTemplateLibrary* aLibrary )
{
return CMmGridContainer::NewL( aRect, aObjectProvider, aLibrary );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CMmWidgetContainer* CMmWidgetContainer::NewListBoxContainerL( const TRect& aRect,
MObjectProvider* aObjectProvider, CMmTemplateLibrary* aTemplateLibrary )
{
return CMmListBoxContainer::NewL( aRect, aObjectProvider, aTemplateLibrary );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::ConstructL()
{
iBgContext = CAknsBasicBackgroundControlContext::NewL(
KAknsIIDQsnBgAreaMainAppsGrid, Rect(), EFalse );
iLongTapDetector = CAknLongTapDetector::NewL( this );
iLongTapDetector->EnableLongTapAnimation( ETrue );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMmWidgetContainer::CMmWidgetContainer()
: iMarqueeAdapter( NULL )
, iLongTapInProgress( EFalse )
, iDragOccured( EFalse )
, iBgContext( NULL )
, iIsFaded( EFalse )
, iHasFocus( ETrue )
, iInForeground( ETrue )
, iLongTapDetector( NULL )
, iAllowMove( EFalse )
, iRecipientId( KErrNotFound )
, iEventParameters( NULL )
, iDialogOpened( EFalse )
, iHighlightVisibleBeforeLongTap( EFalse )
{
iWidgetPositionCache.iValid = EFalse;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
CMmWidgetContainer::~CMmWidgetContainer()
{
AknsUtils::DeregisterControlPosition( this );
AknsUtils::DeregisterControlPosition( this->iWidget );
delete iBgContext;
delete iPostProcessor;
delete iLongTapDetector;
delete iEventParameters;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::EnableLongTapAnimation( TBool aEnable )
{
if( iLongTapDetector )
{
iLongTapDetector->EnableLongTapAnimation( aEnable );
// cancel longTap timer, avoid showing popupmenu
if( !aEnable )
{
TRAP_IGNORE( iLongTapDetector->CancelAnimationL() );
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SizeChanged()
{
if( iWidget && iWidgetRect != Rect() )
{
CMmTemplateLibrary * templateLibrary =
static_cast<CMmListBoxItemDrawer*> (
Widget()->View()->ItemDrawer() )->TemplateLibrary();
if( Rect() != templateLibrary->GetParentRect(
Layout_Meta_Data::IsLandscapeOrientation() ) )
{
templateLibrary->CleanAndClearCache();
}
iWidget->View()->SetViewRect( Rect() );
iWidget->SetRect( Rect() );
iWidgetRect = Rect();
}
if( iBgContext )
{
TRect rect = iCoeEnv->ScreenDevice()->SizeInPixels();
iBgContext->SetRect( rect );
SetItemDrawerAndViewBgContext( iBgContext );
}
AknsUtils::RegisterControlPosition( this );
AknsUtils::RegisterControlPosition( this->iWidget );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::Draw( const TRect& /*aRect*/) const
{
// do nothing
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TTypeUid::Ptr CMmWidgetContainer::MopSupplyObject( TTypeUid aId )
{
if( aId.iUid == MAknsControlContext::ETypeId && iBgContext )
{
return MAknsControlContext::SupplyMopObject( aId, iBgContext );
}
return CCoeControl::MopSupplyObject( aId );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleButtonDownL(const TPointerEvent& aPointerEvent )
{
iTapPoint = aPointerEvent.iPosition;
iLastDragPoint = aPointerEvent.iPosition;
iLastDragHighlight = GetHighlight();
if( !iWidget->View()->XYPosToItemIndex(
aPointerEvent.iPosition, iDraggedIndex ) )
{
iDraggedIndex = KErrNotFound;
}
iItemRelativeTapPoint = aPointerEvent.iPosition - iWidget->View()->ItemPos(
iDraggedIndex );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleButtonUpL( const TPointerEvent& /*aPointerEvent*/)
{
iTapPoint = TPoint( 0, 0 );
CancelDragL( EFalse );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleResourceChange( TInt aType )
{
if ( aType == KEikDynamicLayoutVariantSwitch ||
aType == KAknsMessageSkinChange )
{
static_cast<CMmListBoxItemDrawer*> ( iDrawer )->InvalidateCache();
CMmTemplateLibrary * templateLibrary =
static_cast<CMmListBoxItemDrawer*>( iDrawer )->TemplateLibrary();
templateLibrary->CleanAndClearCache();
}
TBool highlightVisibleBefore = iWidget->IsVisible() && IsHighlightVisible();
// fix ou1cimx1#344006 error; when we close dialog - if highlight had been
// visible/invisible before dialog has been opened, we restore highlight visibility flag.
if( !iIsFaded && iDialogOpened)
{
iDialogOpened = EFalse;
if(highlightVisibleBefore != iHighlightVisibleBeforeLongTap)
{
TRAP_IGNORE( SetHighlightVisibilityL( iHighlightVisibleBeforeLongTap) );
}
highlightVisibleBefore = iHighlightVisibleBeforeLongTap;
}
CCoeControl::HandleResourceChange( aType );
if( highlightVisibleBefore )
{
TRAP_IGNORE( SetHighlightVisibilityL( ETrue ) );
}
if( aType == KEikDynamicLayoutVariantSwitch && !IsHighlightVisible() )
{
TRAP_IGNORE( SetDefaultHighlightL( EFalse ) );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::ItemIconZoomL( TInt /*aItemIndex */)
{
TInt index = GetHighlight();
if( index != iDraggedIndex )
{
iDrawer->AnimateItemZoomInL( index );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C CHnSuiteModel* CMmWidgetContainer::GetSuiteModelL()
{
return GetMmModel()->GetSuiteModel();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleDragL( const TPointerEvent& aPointerEvent,
TBool aAbortAnimation )
{
DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: iLastDragHighlight = %d ",
iLastDragHighlight ));
TInt highlight = GetHighlight();
DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: highlight = %d ", highlight ));
TPoint dragDelta( iLastDragPoint - aPointerEvent.iPosition );
TInt dragSpeed = dragDelta.iX * dragDelta.iX + dragDelta.iY * dragDelta.iY;
TBool tooFast = ( dragSpeed > MmEffects::KDragSpeedIgnoreThreshold );
if( iLastDragHighlight != highlight )
{
iDragAndDropObserver->HandleDragOverL( GetHighlight() );
}
TPoint centerPoint( aPointerEvent.iPosition );
if( WidgetType() == EGridWidget )
{ // move item's TL corner by half width/height to center item horizontally.
centerPoint.iX -= ( iWidget->View()->ItemSize( highlight ).iWidth / 2 );
centerPoint.iY -= ( iWidget->View()->ItemSize( highlight ).iHeight / 2 );
}
else
{ // move item's T of corner by relative tap point to align left horizontally.
centerPoint.iX -= iItemRelativeTapPoint.iX;
// move item's L of corner by half height to center item horizontally.
centerPoint.iY -= ( iWidget->View()->ItemSize( highlight ).iHeight / 2 );
}
if( !tooFast )
{
TSize itemSize = iWidget->View()->ItemSize( highlight );
TPoint itemPos = iWidget->View()->ItemPos( highlight );
if ( PointInItemReorderAreaL( highlight, aPointerEvent.iPosition ) )
{
CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( highlight ));
if( iDrawer->GetAnimator()->IsReadyForNewAnimation() && !aAbortAnimation
&& onItemModel->GetItemType() != EItemTypeParentFolder
&& iDraggedIndex != highlight )
{
GetMmModel()->ReorderModelL( iDraggedIndex, highlight );
AnimateShiftL( highlight );
iDrawer->SetDraggedIndexL( highlight, centerPoint );
iDraggedIndex = highlight;
iDragAndDropObserver->HandleDraggedIndexUpdatedL( highlight );
}
}
}
if ( DeltaSquare( iTapPoint, aPointerEvent.iPosition ) > KDragDelta
&& !iDrawer->IsDraggable() )
{
if( !tooFast )
{
iDrawer->AnimateDragItemStartL( iDraggedIndex, centerPoint );
}
iDrawer->SetDraggedIndexL( iDraggedIndex, centerPoint );
iDrawer->SetDraggableL( ETrue );
}
else if( iDrawer->IsDraggable() )
{
iDrawer->SetDraggedPointL( centerPoint );
}
DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: iLastDragHighlight = %d ", iLastDragHighlight ));
DEBUG(("\t_Mm_:CMmWidgetContainer::HandleDragL: highlight = %d ", highlight ));
iLastDragPoint = aPointerEvent.iPosition;
iLastDragHighlight = highlight;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::AnimateShiftL( TInt aHighlight )
{
TInt lowerVal = (iDraggedIndex < aHighlight)? iDraggedIndex : aHighlight;
TInt higherVal = (iDraggedIndex < aHighlight)? aHighlight : iDraggedIndex;
TInt switchOperation = ( iDraggedIndex < aHighlight ) ? EFalse : ETrue;
for( TInt iter( lowerVal ); iter < higherVal; iter++ )
{
TInt from = iter + 1;
TInt to = iter;
if( switchOperation )
{
from = iter;
to = iter + 1;
}
iDrawer->AnimateItemSwapL( from, to );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::CancelDragL( TBool aAnimate )
{
if( aAnimate )
{
iDrawer->AnimateDragItemTransitionL();
}
SetHighlightAfterDrag();
iDraggedIndex = -1;
iDrawer->SetDraggedIndexL( iDraggedIndex, TPoint( 0, 0 ) );
SetDraggableL( EFalse );
TInt dragFloatingItem( KErrNotFound );
TInt dragStartFloatingItem( KErrNotFound );
do
{
dragFloatingItem = iDrawer->GetFloatingItemIndex( EDrag );
iDrawer->RemoveFloatingItem( dragFloatingItem );
dragStartFloatingItem = iDrawer->GetFloatingItemIndex( EDragStart );
iDrawer->RemoveFloatingItem( dragStartFloatingItem );
}
while( dragFloatingItem != KErrNotFound || dragStartFloatingItem != KErrNotFound);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::IsFolderL( TInt aItemIndex )
{
TBool result = EFalse;
CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
if( model )
{
CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( aItemIndex ));
if( onItemModel )
{
result = onItemModel->GetItemType() == EItemTypeParentFolder
|| onItemModel->GetItemType() == EItemTypeFolder;
}
}
return result;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::IsNoItemDragged()
{
TBool noItemDragged = EFalse;
noItemDragged = ( KErrNotFound == iDraggedIndex ) ? ETrue : noItemDragged;
CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
if( !noItemDragged && model )
{
CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex( iDraggedIndex ));
if( onItemModel )
{
noItemDragged = ( onItemModel->GetItemType() == EItemTypeParentFolder );
}
}
return noItemDragged;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetHasFocusL( TBool aHasFocus )
{
if( !!aHasFocus != !!iHasFocus ) // logical Ex-OR
{
iHasFocus = aHasFocus;
StartOrStopMarquee();
}
if( !aHasFocus )
{
SetHighlightVisibilityL( EFalse );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetIsFaded( TBool aIsFaded )
{
if( !!aIsFaded != !!iIsFaded ) // logical Ex-OR
{
iIsFaded = aIsFaded;
StartOrStopMarquee();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::LongTapInProgress() const
{
return iLongTapInProgress;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMmWidgetContainer::AllowMove() const
{
return iAllowMove;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetAllowMove( TBool aAllowMove )
{
iAllowMove = aAllowMove;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetTriggerMoveItemL( const TInt aRecipientId,
CLiwGenericParamList* aEventParameters )
{
iRecipientId = aRecipientId;
if( !iEventParameters )
{
iEventParameters = CLiwGenericParamList::NewL();
}
else
{
iEventParameters->Reset();
}
iEventParameters->AppendL(*aEventParameters);
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::TriggerMoveItemL()
{
if( iRecipientId != KErrNotFound && iDragAndDropObserver )
{
iDragAndDropObserver->HandleTriggerMoveItemL( iRecipientId,
iEventParameters );
iRecipientId = KErrNotFound;
iEventParameters->Reset();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetExDialogOpened( TBool aOpened )
{
iDialogOpened = aOpened;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TMmWidgetPosition CMmWidgetContainer::WidgetPositionCache() const
{
return iWidgetPositionCache;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::IsDeleteLocked( TInt aItemIndex )
{
TBool result = ETrue;
CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
if( model )
{
CHnItemModel* onItemModel = model->GetItemModel( model->IdByIndex(
aItemIndex ) );
if( onItemModel )
{
result = onItemModel->IsDeleteLocked();
}
}
return result;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::ManageFolderZoomingL( TBool aDraggedItemOverIcons )
{
TBool isAnimated( EFalse );
for( int i = 0; i < iDrawer->GetFloatingItemCount(); i++ )
{
TMmFloatingItem& current = iDrawer->GetFloatingItemAtIndex( i );
if( /*current.GetFloatingItemType() != EZoomTransition &&*/
current.GetFloatingItemType() != EPostHighlightChangeRefreshItem
&& current.GetDrawnItemIndex() == GetHighlight() )
{
isAnimated = ETrue;
break;
}
}
if( !isAnimated )
{
if( GetHighlight() != iDraggedIndex
&& IsFolderL( GetHighlight() )
&& !IsDeleteLocked( GetHighlight() )
&& iDrawer->IsDraggable() )
{
iDrawer->AnimateItemZoomInL( GetHighlight() );
}
}
isAnimated = EFalse;
for( int i = 0; i < iDrawer->GetFloatingItemCount(); i++ )
{
TMmFloatingItem& current = iDrawer->GetFloatingItemAtIndex( i );
if( current.GetFloatingItemType() != EZoomTransition
&& current.GetFloatingItemType() != EPostHighlightChangeRefreshItem
&& current.GetDrawnItemIndex() == iLastDragHighlight )
{
isAnimated = ETrue;
break;
}
}
if( !isAnimated )
{
if( ( !aDraggedItemOverIcons && IsFolderL( iLastDragHighlight ) )
|| iLastDragHighlight != Widget()->CurrentItemIndex() )
{
iDrawer->AnimateItemZoomOutL( iLastDragHighlight );
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandlePointerEventsInEditModeL(
const TPointerEvent& aPointerEvent, TBool aAbortAnimations )
{
TInt pointedItem = KErrNotFound;
TBool draggedItemOverIcons = iWidget->View()->XYPosToItemIndex(
aPointerEvent.iPosition, pointedItem );
if( aPointerEvent.iType == TPointerEvent::EButton1Down )
{
//TODO: PROTO OF 2PHASE HIGHLIGHT EDITMODE BEHAVIOUR
// if (!IsFolderL(pointedItem))
// {
// iDrawer->ClearFlags( CListItemDrawer::EPressedDownState );
// }
HandleButtonDownL( aPointerEvent );
iDragAndDropObserver->HandleDragStartL( GetHighlight() );
}
else if( ( aPointerEvent.iType == TPointerEvent::EDrag
|| aPointerEvent.iType == TPointerEvent::EButtonRepeat )
&& iDraggedIndex != KErrNotFound )
{
//TODO: PROTO OF 2PHASE HIGHLIGHT EDITMODE BEHAVIOUR
// if (!IsFolderL(pointedItem))
// {
// iDrawer->SetFlags( CListItemDrawer::EPressedDownState );
// }
TPointerEvent pointerEvent = aPointerEvent;
if( WidgetType() == EListWidget )
{
pointerEvent.iPosition.iX =
iWidget->View()->ItemPos( pointedItem ).iX
+ iItemRelativeTapPoint.iX;
}
if( GetHighlight() != Widget()->CurrentItemIndex() )
{
SetHighlightL( Widget()->CurrentItemIndex() );
}
ManageFolderZoomingL( draggedItemOverIcons );
HandleDragL( pointerEvent, aAbortAnimations );
}
else if( aPointerEvent.iType == TPointerEvent::EButton1Up && iDrawer->IsDraggable() )
{
if( !draggedItemOverIcons )
{
SetManualHighlightL( iDraggedIndex );
}
iDragAndDropObserver->HandleDragStopL( GetHighlight() );
iAllowMove = EFalse ;
HandleButtonUpL( aPointerEvent );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandlePointerEventL(const TPointerEvent& aPointerEvent )
{
if ( iMarqueeAdapter && aPointerEvent.iType == TPointerEvent::EButton1Down )
{
iMarqueeAdapter->StopMarqueeDrawing();
}
TInt index = KErrNotFound;
TBool itemExists = iWidget->View()->XYPosToItemIndex( aPointerEvent.iPosition, index );
if( iLongTapDetector )
{
if( aPointerEvent.iType == TPointerEvent::EButton1Down )
{
iLongTapDetector->EnableLongTapAnimation( itemExists &&
GetMmModel()->GetNumberOfSpecificMenuItemsL( index ) > 0 );
}
TPointerEvent longTapPointerEvent = aPointerEvent;
if( aPointerEvent.iType == TPointerEvent::EButtonRepeat )
{
longTapPointerEvent.iType = TPointerEvent::EDrag;
}
iLongTapDetector->PointerEventL( longTapPointerEvent );
}
if ( aPointerEvent.iType == TPointerEvent::EButton1Down
&& itemExists )
{
SetHighlightL( index );
}
else if( aPointerEvent.iType == TPointerEvent::EDrag
// the line below is needed to enable edit mode in the list widget
// because behaviour in the grid and list is different
|| (aPointerEvent.iType == TPointerEvent::EButtonRepeat && WidgetType() == EGridWidget ))
{
if( itemExists )
{
if( GetHighlight() != index )
{
SetHighlightVisibilityL( EFalse );
if( IsEditMode() )
{
SetHighlightL( index );
}
}
}
else
{
iDragOccured = ETrue;
SetHighlightVisibilityL( EFalse );
}
}
CCoeControl::HandlePointerEventL( aPointerEvent );
TInt lastTopItemIndex = Widget()->TopItemIndex();
TBool abortAnimation = lastTopItemIndex != Widget()->TopItemIndex();
if( abortAnimation )
{
iDrawer->GetAnimator()->CancelAnimationsL();
}
if( IsEditMode() && iDragAndDropObserver )
{
HandlePointerEventsInEditModeL( aPointerEvent, abortAnimation );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TRect CMmWidgetContainer::GetItemRectL( TInt aItemIndex )
{
User::LeaveIfNull( iWidget );
TPoint pos = iWidget->View()->ItemPos( aItemIndex );
TSize size = iDrawer->GetItemSize( aItemIndex, EFalse );
return TRect( pos.iX, pos.iY, pos.iX + size.iWidth, pos.iY + size.iHeight );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetDraggableL( TBool aDraggable )
{
iDrawer = STATIC_CAST(CMmListBoxItemDrawer*, iWidget->View()->ItemDrawer());
iDrawer->SetDraggableL( aDraggable );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::IsEditMode() const
{
return iIsEditMode;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetEditModeL( TBool aIsEditMode )
{
iIsEditMode = aIsEditMode;
iAllowMove = EFalse;
StartOrStopMarquee();
ASSERT(iDrawer);
iDrawer->SetEditModeL( aIsEditMode );
if( !AknLayoutUtils::PenEnabled() && aIsEditMode )
{
iDraggedIndex = iWidget->CurrentItemIndex();
ScrollViewIfNeededL(); //only edit mode non-touch
}
// scrollbar does not work when scrolling is disabled
// iWidget->DisableScrolling( aIsEditMode );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetHighlightVisibilityL( TBool aEnable )
{
if( ( !!aEnable != !!iPreviousHighlightVisibility ) // Ex-OR
|| ( !!aEnable != !!IsHighlightVisible() ) ) // Ex-OR
{
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(
iDrawer->Gc() );
#endif
if( !aEnable )
{
iWidget->View()->ItemDrawer()->SetFlags(
CListItemDrawer::ESingleClickDisabledHighlight );
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
if( transApi )
{
transApi->Remove( MAknListBoxTfxInternal::EListHighlight );
}
#endif
}
else
{
iWidget->View()->ItemDrawer()->ClearFlags(
CListItemDrawer::ESingleClickDisabledHighlight );
}
if( IsVisible() && !aEnable )
{
TInt highlight = GetHighlight();
CListBoxView* view = Widget()->View();
Widget()->DrawNow( TRect( view->ItemPos( highlight ),
view->ItemSize( highlight ) ) );
}
iPreviousHighlightVisibility = aEnable;
}
}
// -----------------------------------------------------------------------------
//
// ----------------------------------------------------------------------------
//
EXPORT_C TBool CMmWidgetContainer::IsHighlightVisible()
{
return !( iWidget->View()->ItemDrawer()->Flags()
& CListItemDrawer::ESingleClickDisabledHighlight );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMmWidgetContainer::IsDraggable()
{
iDrawer = STATIC_CAST(CMmListBoxItemDrawer*, iWidget->View()->ItemDrawer());
return iDrawer->IsDraggable();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMmWidgetContainer::CountComponentControls() const
{
return 1;
}
// -----------------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------------
//
CCoeControl* CMmWidgetContainer::ComponentControl( TInt aIndex ) const
{
switch( aIndex )
{
case 0:
return iWidget;
default:
return NULL;
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmWidgetContainer::NumberOfItems()
{
return GetMmModel()->NumberOfItems();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetObserver( MMmWidgetObserver* aObserver )
{
//iWidget->SetListBoxObserver( aObserver );
iListBoxObserver = aObserver;
iKeyEventObserver = aObserver;
iDragAndDropObserver = aObserver;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmWidgetContainer::GetPreviousHighlight()
{
return iPreviousHighlight;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TInt CMmWidgetContainer::GetHighlight()
{
return iCurrentHighlight;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetManualHighlightL( TInt aItemIndex,
TBool aRedraw )
{
SetHighlightL( aItemIndex );
if( aItemIndex >= 0 && aItemIndex < GetMmModel()->NumberOfItems() )
{
if( aItemIndex != iWidget->CurrentItemIndex() )
{
iWidget->View()->SetCurrentItemIndex( aItemIndex );
}
if( aRedraw )
{
iWidget->SetCurrentItemIndex( aItemIndex );
iWidget->DrawNow();
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetHighlightL( TInt aItemIndex )
{
ASSERT( aItemIndex >= KErrNotFound );
if( aItemIndex == KErrNotFound )
{
iCurrentHighlight = iPreviousHighlight = KErrNotFound;
SetDefaultHighlightL( EFalse );
}
else if( aItemIndex >= 0 && aItemIndex < GetMmModel()->NumberOfItems() )
{
iPreviousHighlight = iCurrentHighlight;
iCurrentHighlight = aItemIndex;
if( IsHighlightVisible() && iPreviousHighlight != iCurrentHighlight )
{
HideOptionsMenuIfDisplayed();
}
CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
if( suiteModel )
{
suiteModel->SetSuiteHighlightL( iCurrentHighlight );
}
}
if( IsEditMode() )
{
TMmFloatingItem postDragCurrent( GetHighlight(),
Widget()->View()->ItemPos( GetHighlight() ),
EPostHighlightChangeRefreshItem,
MmEffects::KNoAnimationFramesCount, Widget()->View() );
iDrawer->AddFloatingItemL( postDragCurrent );
if( GetPreviousHighlight() != GetHighlight() )
{
TMmFloatingItem postDragPrevious( GetPreviousHighlight(),
Widget()->View()->ItemPos( GetPreviousHighlight() ),
EPostHighlightChangeRefreshItem,
MmEffects::KNoAnimationFramesCount, Widget()->View() );
iDrawer->AddFloatingItemL( postDragPrevious );
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::PointInItemReorderAreaL(
TInt aItemIndex, TPoint aPoint )
{
TRect itemRect = GetItemRectL( aItemIndex );
itemRect.Shrink( MmEffects::KShiftRatio * itemRect.Width(),
MmEffects::KShiftRatio * itemRect.Height() );
return itemRect.Contains( aPoint );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HideOptionsMenuIfDisplayed()
{
CEikMenuBar* menuBar = CEikonEnv::Static()->AppUiFactory()->MenuBar();
if( menuBar && menuBar->IsDisplayed() )
{
menuBar->StopDisplayingMenuBar();
}
}
// -----------------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetFlag( TInt /*Flag*/)
{
}
// -----------------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------------
//
CEikListBox* CMmWidgetContainer::Widget()
{
return iWidget;
}
// -----------------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------------
//
TKeyResponse CMmWidgetContainer::OfferKeyEventL(const TKeyEvent &aKeyEvent,
TEventCode aType)
{
TKeyResponse resp = EKeyWasNotConsumed;
TBool highlightVisibleWhenEventReceived = IsHighlightVisible();
if( IsEditMode() && IsDraggable() )
return resp;
resp = HandleKeyEventL( aKeyEvent, aType );
if( iMarqueeAdapter && ( aType == EEventKeyDown ) )
{
iMarqueeAdapter->StopMarqueeDrawing();
}
if( !AknLayoutUtils::PenEnabled() && iIsEditMode )
{
if( ( GetHighlight() + ColumnsInCurrentView() > NumberOfItems() - 1 )
&& aKeyEvent.iScanCode == EStdKeyDownArrow )
// the second condition is needed to block moving item down when there is no item below the moved item.
{
return resp;
}
if( aType == EEventKey )
{
TInt prevIndex = GetHighlight();
static_cast<CMmListBoxItemDrawer*>(iDrawer)->SetHighlightShown( EFalse );
resp = iWidget->OfferKeyEventL( aKeyEvent, aType );
static_cast<CMmListBoxItemDrawer*>(iDrawer)->SetHighlightShown( ETrue );
SetHighlightL( iWidget->CurrentItemIndex() );
ScrollViewIfNeededL(); //only edit mode non-touch
if ( prevIndex != GetHighlight()
&& KErrNotFound != prevIndex )
{
iDraggedIndex = prevIndex;
iDragAndDropObserver->HandleDragStartL( iDraggedIndex );
GetMmModel()->ReorderModelL( iDraggedIndex, GetHighlight() );
iDrawer->AnimateItemSwapL( iDraggedIndex, GetHighlight() );
AnimateShiftL( GetHighlight() );
}
return resp;
}
}
if( resp == EKeyWasNotConsumed )
{
resp = iWidget->OfferKeyEventL( aKeyEvent, aType );
}
if( iKeyEventObserver )
{
resp = iKeyEventObserver->HandleKeyPressedL( aKeyEvent, aType );
}
if ( ( aKeyEvent.iScanCode == EStdKeyDevice3 ||
aKeyEvent.iScanCode == EStdKeyEnter ||
aKeyEvent.iScanCode == EStdKeyNkpEnter ) && aType == EEventKeyDown )
{
if( highlightVisibleWhenEventReceived )
{
iAllowLongPress = EFalse;
}
else
{
iAllowLongPress = ETrue;
SetHighlightVisibilityL( ETrue );
SetDefaultHighlightL( ETrue );
HandleForegroundGainedL();
}
}
return resp;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMmWidgetContainer::ColumnsInCurrentView()
{
//should be overridden by deriving classes
return NumberOfItems();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMmWidgetContainer::RowsInCurrentView()
{
//should be overridden by deriving classes
CListBoxView *view = ( (CListBoxView* ) Widget()->View() );
return view->NumberOfItemsThatFitInRect( Rect() );//Widget()->View()->ViewRect());
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleRockerPressL()
{
TKeyEvent ke;
ke.iScanCode = EStdKeyNull;
ke.iCode = EStdKeyNull;
ke.iModifiers = 0;
ke.iRepeats = 0;
if( iKeyEventObserver )
{
iKeyEventObserver->HandleKeyPressedL( ke, EEventUser );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TKeyResponse CMmWidgetContainer::HandleKeyEventL( const TKeyEvent &aKeyEvent,
TEventCode aType )
{
TKeyResponse resp = EKeyWasNotConsumed;
TBool arrowKeyPressed = aKeyEvent.iScanCode == EStdKeyRightArrow
|| aKeyEvent.iScanCode == EStdKeyLeftArrow
|| aKeyEvent.iScanCode == EStdKeyUpArrow
|| aKeyEvent.iScanCode == EStdKeyDownArrow;
TBool arrowHasHandling = ( aKeyEvent.iScanCode == EStdKeyRightArrow
&& WidgetType() != EListWidget )
|| ( aKeyEvent.iScanCode == EStdKeyLeftArrow
&& WidgetType() != EListWidget )
|| aKeyEvent.iScanCode == EStdKeyUpArrow
|| aKeyEvent.iScanCode == EStdKeyDownArrow;
// handle arrow: draw highlight when arrow used
if( arrowHasHandling )
{
if( !IsHighlightVisible() )
{
if( aType == EEventKey || aType == EEventKeyUp )
{
SetHighlightVisibilityL( ETrue );
SetDefaultHighlightL( ETrue );
}
// override avkon's default highlight setting
resp = EKeyWasConsumed;
}
else
{
// this block is used to set the highlight only once for each event
if( aKeyEvent.iRepeats > 0 )
{
// if repeated key events we move focus on EEventKey
if( aType == EEventKey )
{
SetHighlightL( iWidget->CurrentItemIndex() );
}
}
else
{
// if single event we move focus on EEventKeyUp
if( aType == EEventKeyUp )
{
SetHighlightL( iWidget->CurrentItemIndex() );
}
}
}
}
else if( arrowKeyPressed )
{
// ignore left and right arrows in list
resp = EKeyWasConsumed;
}
// rocker select (short press)
else if ( ( aKeyEvent.iScanCode == EStdKeyDevice3 ) && ( aType == EEventKeyDown ) )
{
HandleRockerPressL();
resp = EKeyWasConsumed;
}
else if ( iAllowLongPress && aType == EEventKey && aKeyEvent.iRepeats > 0 &&
( aKeyEvent.iScanCode == EStdKeyDevice3
|| aKeyEvent.iScanCode == EStdKeyEnter
|| aKeyEvent.iScanCode == EStdKeyNkpEnter ) )
{
HandleRockerPressL();
resp = EKeyWasConsumed;
iAllowLongPress = EFalse;
}
return resp;
}
// -----------------------------------------------------------------------------
//
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetSuiteModelL( CHnSuiteModel* aModel )
{
CHnSuiteModel* prevModel = GetMmModel()->GetSuiteModel();
TInt numberOfItemsBefore( 0 );
numberOfItemsBefore = GetMmModel()->NumberOfItems();
GetMmModel()->SetSuiteModelL( aModel );
TBool highlightVisibleBefore = iWidget->IsVisible() && IsHighlightVisible();
// This needs to be in place (disabling redraw)
// to udpate widget internal state, however to wait for
// drawing until all highlight set matters are solved.
iWidget->MakeVisible( EFalse );
if( GetMmModel()->NumberOfItems() >= numberOfItemsBefore )
{
HandleItemAdditionL();
}
else
{
HandleItemRemovalL();
}
if( prevModel && aModel )
{
SetupWidgetLayoutL();
}
iWidget->MakeVisible( ETrue );
if( highlightVisibleBefore )
{
SetHighlightVisibilityL( ETrue );
}
Widget()->View()->ItemDrawer()->ClearFlags(
CListItemDrawer::EPressedDownState );
iPostProcessor->StartAt( iWidget->BottomItemIndex() + 1 );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::SetupDrawer()
{
iDrawer = STATIC_CAST(CMmListBoxItemDrawer*, iWidget->View()->ItemDrawer());
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C THnSuiteWidgetType CMmWidgetContainer::WidgetType()
{
return EUnspecified;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::RemoveLiwObjects()
{
// there is only one place where LIW objects can be (co)owned in mmwidgets
// and that place is item drawer's cache
iDrawer->TrimCacheSize( 0 );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::HandleBackgroundGainedL()
{
iInForeground = EFalse;
StartOrStopMarquee();
CancelDragL();
// Fix for EMWK-7NYKRJ
// Matrix Menu: Scrollbar highligted when App Key is pressed while it is held
if( AknLayoutUtils::PenEnabled() )
{
CEikScrollBar* scrollBar =
iWidget->ScrollBarFrame()->VerticalScrollBar();
if( scrollBar && scrollBar->IsVisible() )
{
TPointerEvent fakeButton1UpEvent;
fakeButton1UpEvent.iType = TPointerEvent::EButton1Up;
fakeButton1UpEvent.iModifiers = 0;
scrollBar->HandlePointerEventL( fakeButton1UpEvent );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::HandleForegroundGainedL()
{
iInForeground = ETrue;
StartOrStopMarquee();
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
TInt CMmWidgetContainer::DeltaSquare( const TPoint aTapPoint,
const TPoint aPos )
{
TInt delta( KErrNotFound );
TInt height = aTapPoint.iY - aPos.iY;
TInt width = aTapPoint.iX - aPos.iX;
if( WidgetType() == EListWidget )
{
delta = height * height + height * height;
}
else
{
delta = height * height + width * width;
}
return delta;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::CancelDragL()
{
if( iIsEditMode && iDrawer )
{
if( iDrawer->GetFloatingItemIndex( EDrag ) != KErrNotFound
|| iDrawer->GetFloatingItemIndex( EDragStart ) != KErrNotFound )
{
CancelDragL( EFalse );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::HandleItemAdditionL()
{
// only the the descended method should be invoked.
// this is needed to avoid codescanner warning
User::Leave( KErrNotSupported );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::HandleItemRemovalL()
{
// only the the descended method should be invoked.
// this is needed to avoid codescanner warning
User::Leave( KErrNotSupported );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::StopMovingL()
{
if( !AknLayoutUtils::PenEnabled() && iDragAndDropObserver )
iDragAndDropObserver->HandleDragStopL( GetHighlight() );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::ScrollViewIfNeededL()
{
if( ( iWidget->BottomItemIndex() / ColumnsInCurrentView()
- iWidget->TopItemIndex() / ColumnsInCurrentView() ) <= 1 )
{
return;
}
TBool needToScrollUp =
GetHighlight() - iWidget->TopItemIndex() < ColumnsInCurrentView()
&& iWidget->TopItemIndex() != 0;
TBool needToScrollDown =
iWidget->BottomItemIndex() - GetHighlight() < ColumnsInCurrentView()
&& iWidget->BottomItemIndex() / ColumnsInCurrentView()
!= ( NumberOfItems() - 1 ) / ColumnsInCurrentView();
if( WidgetType() == EGridWidget )
{
// TODO: temporary - invisible partial items in MCL grid :/
needToScrollDown =
iWidget->BottomItemIndex() - ColumnsInCurrentView() - GetHighlight() < ColumnsInCurrentView()
&& ( iWidget->BottomItemIndex() / ColumnsInCurrentView() ) - 1
!= ( NumberOfItems() - 1 ) / ColumnsInCurrentView()
&& iWidget->BottomItemIndex() - iWidget->TopItemIndex()
> ColumnsInCurrentView() * RowsInCurrentView();
}
if( needToScrollUp )
{
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iDrawer->Gc() );
if( transApi )
{
transApi->SetMoveType( MAknListBoxTfxInternal::EListScrollUp );
}
#endif
iDrawer->RemoveFloatingItems();
iWidget->View()->VScrollTo(
iWidget->TopItemIndex() - ColumnsInCurrentView() );
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
if( transApi )
{
transApi->Draw( Rect() );
}
#endif
UpdateViewScrollBarThumbs();
}
else if( needToScrollDown )
{
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal( iDrawer->Gc() );
if( transApi )
{
transApi->SetMoveType( MAknListBoxTfxInternal::EListScrollDown );
}
#endif
iDrawer->RemoveFloatingItems();
iWidget->View()->VScrollTo(
iWidget->TopItemIndex() + ColumnsInCurrentView() );
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
if( transApi )
{
transApi->Draw( Rect() );
}
#endif
UpdateViewScrollBarThumbs();
}
}
//----------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::UpdateViewScrollBarThumbs()
{
}
//----------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::StartOrStopMarquee()
{
if( iMarqueeAdapter )
{
TBool marqueeShouldBeEnabled = iHasFocus && iInForeground
&& !iIsFaded && !IsEditMode();
// logical Ex-OR
if ( !!marqueeShouldBeEnabled != !!iMarqueeAdapter->IsMarqueeEnabled() )
{
if( !marqueeShouldBeEnabled )
{
iMarqueeAdapter->StopMarqueeDrawing();
}
iMarqueeAdapter->EnableMarquee( marqueeShouldBeEnabled );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::SetHighlightAfterDrag()
{
if( AknLayoutUtils::PenEnabled()
&& iDraggedIndex != KErrNotFound
&& iDraggedIndex != Widget()->CurrentItemIndex()
&& iDraggedIndex < NumberOfItems() )
{
TBool isFolder( EFalse );
CHnSuiteModel* model = GetMmModel()->GetSuiteModel();
CHnItemModel* onItemModel = model->GetItemModel(
model->IdByIndex( Widget()->CurrentItemIndex() ));
if( onItemModel )
{
isFolder = onItemModel->GetItemType() == EItemTypeParentFolder
|| onItemModel->GetItemType() == EItemTypeFolder;
}
if( !isFolder )
{
Widget()->View()->SetCurrentItemIndex( iDraggedIndex );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::ValidateWidgetCurrentItemIndex()
{
if( Widget()->CurrentItemIndex() >= GetMmModel()->NumberOfItems()
|| Widget()->CurrentItemIndex() == KErrNotFound )
{
iCurrentHighlight = GetMmModel()->NumberOfItems();
if( iCurrentHighlight > 0 )
{
Widget()->View()->SetCurrentItemIndex( --iCurrentHighlight );
}
else
{
iCurrentHighlight = KErrNotFound;
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::CacheWidgetPosition()
{
iWidgetPositionCache.iVerticalItemOffset = VerticalItemOffset();
iWidgetPositionCache.iTopItemIndex = Widget()->TopItemIndex();
iWidgetPositionCache.iLandscape
= Layout_Meta_Data::IsLandscapeOrientation();
iWidgetPositionCache.iHighlightedItemId = KErrNotFound;
TInt highlightedItemIndex = Widget()->CurrentItemIndex();
CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
if( suiteModel && highlightedItemIndex != KErrNotFound
&& suiteModel->GetSuiteHighlight() == highlightedItemIndex
&& ItemIsVisible( highlightedItemIndex ) )
{
iWidgetPositionCache.iHighlightedItemId =
suiteModel->IdByIndex( highlightedItemIndex );
}
iWidgetPositionCache.iValid = ETrue;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::RestoreWidgetPosition()
{
if( iWidgetPositionCache.iValid )
{
if( iWidgetPositionCache.iLandscape
== Layout_Meta_Data::IsLandscapeOrientation() )
{
// If view position was cached during boundary effect, correct the
// cached position.
if( iWidgetPositionCache.iTopItemIndex == 0
&& iWidgetPositionCache.iVerticalItemOffset > 0 )
{
iWidgetPositionCache.iVerticalItemOffset = 0;
// This corrects the position cached during the upper boundary
// effect. AlignBottomOfViewL will take care of lower boundary
// effect.
}
Widget()->View()->SetTopItemIndex(iWidgetPositionCache.iTopItemIndex);
SetVerticalItemOffset( iWidgetPositionCache.iVerticalItemOffset );
TRAP_IGNORE( AlignBottomOfViewL() );
// Important: If an item that was previously highlighted and visible is
// still highlighted and yet somehow is not visible after the position
// has been restored, fix the problem by scrolling the view until that
// item is visible again:
CHnSuiteModel* suiteModel = GetMmModel()->GetSuiteModel();
if( suiteModel && IsHighlightVisible() )
{
TInt highlightedItemIndex = suiteModel->GetSuiteHighlight();
TInt highlightedItemId = highlightedItemIndex != KErrNotFound ?
suiteModel->IdByIndex( highlightedItemIndex ) : KErrNotFound;
if ( highlightedItemId != KErrNotFound
&& highlightedItemId == iWidgetPositionCache.iHighlightedItemId
&& !ItemIsVisible( highlightedItemIndex ) )
{
TRAP_IGNORE( ScrollToItemL( highlightedItemIndex ) );
}
}
}
else
{
TRAP_IGNORE( ScrollToItemL(Widget()->CurrentItemIndex()) );
}
iWidgetPositionCache.iValid = EFalse;
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::MakeVisible( TBool aVisible )
{
if( !aVisible )
{
RestoreWidgetPosition();
CacheWidgetPosition();
iDrawer->RemoveFloatingItems();
}
else if( aVisible )
{
RestoreWidgetPosition();
}
CCoeControl::MakeVisible( aVisible );
iWidget->MakeVisible( aVisible );
if( !aVisible )
{
TRAP_IGNORE( SetHighlightVisibilityL( EFalse ) );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::ResetWidgetPosition()
{
iWidgetPositionCache.iVerticalItemOffset = 0;
iWidgetPositionCache.iTopItemIndex = 0;
iWidgetPositionCache.iValid = EFalse;
iWidgetPositionCache.iHighlightedItemId = KErrNotFound;
Widget()->SetTopItemIndex( 0 );
SetVerticalItemOffset( 0 );
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::NumberOfItemsChangedL( TItemsChangeType aChange )
{
if( AknLayoutUtils::PenEnabled() )
{
CacheWidgetPosition();
Widget()->View()->SetDisableRedraw( ETrue );
HandleNumberOfItemsChangedL( aChange );
Widget()->View()->SetDisableRedraw( EFalse );
RestoreWidgetPosition();
}
else
{
// there is no need to cache and restore widget position in non-touch;
// moreover, it can cause some problems with scrolling when adding
// new folder
HandleNumberOfItemsChangedL( aChange );
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleNumberOfItemsChangedL( TItemsChangeType aChange )
{
SetHighlightVisibilityL( EFalse );
if( aChange == EItemsAdded )
{
// force update scrollbar to go down
if( WidgetType() == EGridWidget && NumberOfItems() > 0)
Widget()->SetCurrentItemIndex( NumberOfItems() - 1 );
HandleItemAdditionL();
}
else if( aChange == EItemsRemoved )
{
HandleItemRemovalL();
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::AlignBottomOfViewL()
{
TInt scrollConsumed( EFalse );
TInt pixelsToScroll( 0 );
if( NumberOfItems() > 0 )
{
pixelsToScroll = CalcBottomPixelsToScroll();
}
if( pixelsToScroll != 0 )
{
ScrollInPixelsL( pixelsToScroll );
scrollConsumed = ETrue;
}
return scrollConsumed;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TInt CMmWidgetContainer::CalcBottomPixelsToScroll()
{
const TInt firstItemIndex( 0 );
TInt lastItemIndex = NumberOfItems() - 1;
TInt viewHeight = Widget()->View()->ViewRect().Height();
TInt lastItemBottomY = Widget()->View()->ItemPos( lastItemIndex ).iY
+ Widget()->ItemHeight();
TInt pixelsToScroll( 0 );
if( Widget()->ScrollBarFrame()->VerticalScrollBar()->IsVisible() )
{
pixelsToScroll = Min( 0, lastItemBottomY - viewHeight );
}
else
{
pixelsToScroll = Widget()->View()->ItemPos( firstItemIndex ).iY;
}
return pixelsToScroll;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
TBool CMmWidgetContainer::ItemIsVisible( TInt aItemIndex ) const
{
return iWidget->View()->ItemIsVisible( aItemIndex );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMmWidgetContainer::ItemIsFullyVisible( TInt aIndex )
{
return ItemIsVisible( aIndex )
&& !Widget()->View()->ItemIsPartiallyVisible( aIndex );
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::ScrollInPixelsL( TInt aPixels )
{
SetupScrollingEffectsL( aPixels > 0 );
if( AknLayoutUtils::PenEnabled() )
{
Widget()->HandlePhysicsScrollEventL( aPixels );
}
else
{
// non-touch avkon doesn't seem to support scrolling by given
// amount of pixels
TInt delta = aPixels / Widget()->View()->ItemHeight();
Widget()->View()->VScrollTo( Widget()->TopItemIndex()
+ delta * ColumnsInCurrentView() );
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C TBool CMmWidgetContainer::ScrollToItemL( TInt aIndex )
{
TInt scrollConsumed( EFalse );
if( aIndex >= 0 && aIndex <= NumberOfItems() )
{
scrollConsumed = AlignBottomOfViewL();
if ( !scrollConsumed && Widget()->View()->ItemIsPartiallyVisible(aIndex))
{
// the case when the item is partially visible at top or
// bottom of screen. The view is scrolled the offset to
// make the item entirely visible.
TInt offsetBottom = Widget()->View()->ItemPos( aIndex ).iY
+ Widget()->ItemHeight()
- Widget()->View()->ViewRect().Height();
TInt offsetTop = Widget()->View()->ItemPos( aIndex ).iY;
TBool takeTop = Abs( offsetTop ) < Abs( offsetBottom );
TInt offset = ( takeTop ) ? offsetTop : offsetBottom;
if( offset != 0 )
{
ScrollInPixelsL( offset );
scrollConsumed = ETrue;
}
}
else if( !Widget()->View()->ItemIsVisible( aIndex ) )
{
// the case when the item is not visible on screen
SetupScrollingEffectsL( aIndex > Widget()->BottomItemIndex() );
Widget()->ScrollToMakeItemVisible( aIndex );
AlignBottomOfViewL();
scrollConsumed = ETrue;
}
}
return scrollConsumed;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::SetupScrollingEffectsL( TBool aDown )
{
#ifdef RD_UI_TRANSITION_EFFECTS_LIST
MAknListBoxTfxInternal *transApi = CAknListLoader::TfxApiInternal(
iDrawer->Gc() );
if( transApi )
{
MAknListBoxTfxInternal::TMovementType movementType;
movementType = ( aDown == (TInt ) ETrue )
? MAknListBoxTfxInternal::EListScrollDown
: MAknListBoxTfxInternal::EListScrollUp;
transApi->SetMoveType( movementType );
}
#endif
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::PrepareForGarbage()
{
// This is called when the suite model is destoyed and the container is set to be destroyed
// by the garbage collector. There should be no redraws done to the widget in this period
// because this will cause the screen to be redrawn only containing the balnk background.
// Before garbage cleanup an asynchronous redraw event may intend to redraw the widget.
// SetDisableRedraw() prevents redrawing. Animator is also prepared for garbage so there is
// no instance which can enable redraw of the widget.
Widget()->View()->SetDisableRedraw( ETrue );
iDrawer->RemoveFloatingItems();
// Prapares the animator for garbage, which means it blocks any animator drawing.
iDrawer->GetAnimator()->PrepareForGarbage();
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleLongTapEventL( const TPoint& aPenEventLocation,
const TPoint& aPenEventScreenLocation )
{
TInt index( KErrNotFound );
if( iWidget->View()->XYPosToItemIndex( aPenEventLocation, index ) )
{
iHighlightVisibleBeforeLongTap = iPreviousHighlightVisibility;
SetHighlightVisibilityL( ETrue );
iLongTapInProgress = ETrue;
if( iLongTapObserver )
{
iLongTapObserver->HandleLongTapEventL( aPenEventScreenLocation );
}
}
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::SetLongTapObserver( MMmLongTapObserver* aObserver )
{
iLongTapObserver = aObserver;
}
// -----------------------------------------------------------------------------
//
// -----------------------------------------------------------------------------
//
EXPORT_C void CMmWidgetContainer::EndLongTapL( TBool aStopTimer )
{
if( iLongTapInProgress )
{
iLongTapInProgress = EFalse;
if( aStopTimer && !iIsFaded )
{
SetHighlightVisibilityL( EFalse );
}
}
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CMmWidgetContainer::HandleListBoxEventL( CEikListBox* aListBox,
TListBoxEvent aEventType )
{
// handle same behaviour in edit mode and normal mode
switch( aEventType )
{
case MEikListBoxObserver::EEventPenDownOnItem:
{
iDragOccured = EFalse;
break;
}
case MEikListBoxObserver::EEventItemSingleClicked:
break;
case MEikListBoxObserver::EEventItemDraggingActioned:
{
iDragOccured = ETrue;
break;
}
}
// handle different behaviour in edit mode and normal mode
if( !IsEditMode() )
{
switch( aEventType )
{
case MEikListBoxObserver::EEventFlickStarted:
case MEikListBoxObserver::EEventPanningStarted:
{
static_cast<CMmListBoxItemDrawer*>(
Widget()->View()->ItemDrawer() )->
EnableCachedDataUse( ETrue );
break;
}
case MEikListBoxObserver::EEventFlickStopped:
{
static_cast<CMmListBoxItemDrawer*>(
Widget()->View()->ItemDrawer() )->
EnableCachedDataUse( EFalse );
DrawView();
break;
}
case MEikListBoxObserver::EEventPanningStopped:
{
static_cast<CMmListBoxItemDrawer*>(
Widget()->View()->ItemDrawer() )->
EnableCachedDataUse( EFalse );
break;
}
}
}
else
{
switch( aEventType )
{
case MEikListBoxObserver::EEventFlickStopped:
{
// this fixes some problems with messed edit mode
// caused by kinetic scrolling
iDrawer->GetAnimator()->SetNextRedrawToWholeScreen();
break;
}
}
}
if ( aEventType == MEikListBoxObserver::EEventItemSingleClicked
&& iListBoxObserver && !iLongTapInProgress && !iDrawer->IsDraggable()
&& !iDragOccured )
{
iListBoxObserver->HandleListBoxEventL( aListBox, aEventType );
}
}
//End of file