FCL/sf/app/homescreen: comparison taskswitcher/taskswitcherui/taskswitcherapp/src/tsfastswaparea.cpp

equal deleted inserted replaced

-:9674c1a575e9
+:b8fae6b8a148
 };
 /** Number of closable applications, to show "close all" option. */
 const TInt KTsMaxClosableApps = 2;
-/** Uid of Active Idle application.
-Used when movind Ai to specified position.*/
-const TUid KAiUid = TUid::Uid( 0x102750F0 );
-/** Position of Ai in fsw grid.*/
-const TInt KAiPosition = 0;
 /** Default grid item to highlight.*/
-const TInt KItemToHighlight = 3;
+const TInt KItemToHighlight = 2;
 const TInt KAppKeyTypeShort = 1;
 const TInt KAppKeyTypeLong = 2;
 const TInt KLayoutItemCount = 4;
 //
 CTsFastSwapArea::CTsFastSwapArea(CCoeControl& aParent,
 CTsDeviceState& aDeviceState,
 CTsEventControler& aEventHandler) :
 iParent(aParent), iDeviceState(aDeviceState), iEvtHandler(aEventHandler),
-iPreviousNoOfItems(0), iIgnoreLayoutSwitch(EFalse)
+iIgnoreLayoutSwitch(EFalse)
 {
 // no implementation required
 }
 // -----------------------------------------------------------------------------
 empty, empty);
 // Text colors
 TRgb textColor;
 AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), textColor,
-KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG6 );
+KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG19 );
 TRgb highlightTextColor;
 AknsUtils::GetCachedColor( AknsUtils::SkinInstance(), highlightTextColor,
 KAknsIIDQsnTextColors, EAknsCIQsnTextColorsCG11 );
 CFormattedCellListBoxData::TColors colors;
-colors.iText = textColor;
+colors.iText =  textColor;
 colors.iBack = iGrid->ItemDrawer()->BackColor();
 colors.iHighlightedText = highlightTextColor;
 colors.iHighlightedBack = iGrid->ItemDrawer()->HighlightedBackColor();
 iGrid->ItemDrawer()->FormattedCellData()->SetSubCellColorsL(1, colors);
+iGrid->SetStrokeColors(textColor, highlightTextColor);
 // Setup grid observers
 if ( obs )
 {
 iGrid->SetObserver( obs );
 iMaxItemsOnScreen--;
 }
 }
 iGridItemWidth = gridItem.Rect().Width();
-iGrid->ItemDrawer()->ColumnData()->SetDrawBackground(EFalse);
 // Update state
 HandleDeviceStateChanged( EDeviceType );
 if( wasHighlight )
 {
 iGrid->ShowHighlight();
 else
 {
 iGrid->HideHighlight();
 }
+	HBufC* text = StringLoader::LoadLC( R_TS_FSW_NO_APPS );
+	iGrid->SetEmptyGridTextL( *text );
+	CleanupStack::PopAndDestroy( text );
 // Make sure that there is an ActivateL call even when we are not
 // called from ConstructL. (in order to have the grid's parent ptr set properly)
 ActivateL();
 }
 // not fully correct but the app will then reappear on the next
 // content-changed notification anyway.
 delete iArray[aIndex];
 iArray.Remove( aIndex );
 NotifyChange();
-if ( !aSuppressRendering )
-{
+// Hide highlight
-RenderContentL( ETrue );
+if ( iGrid->GridBehaviour() == CTsFastSwapGrid::ETouchOnly )
-}
+{
-// Update item selection on the screen if last item was deleted
+iGrid->HideHighlight();
-TInt newItemCount = GridItemCount();
+}
+// Update selection
+TInt newItemCount = GridItemCount() - 1;
 if ( aIndex == newItemCount )
 {
 newItemCount--;
 iGrid->SetCurrentDataIndex(newItemCount);
 }
 else
 {
-DrawDeferred();
 iGrid->SetCurrentDataIndex(selIdx);
+}
+// Render contect
+if ( !aSuppressRendering )
+{
+RenderContentL( ETrue );
 }
 // Orientation update
 iPrevScreenOrientation = GetCurrentScreenOrientation();
 iOrientationSignalTimer->Cancel();
 }
 if ( changed )
 {
 RenderContentL();
 RestoreSelectedIndex();
-UpdateGrid();
+UpdateGrid( ETrue, EFalse );
 }
 }
 // --------------------------------------------------------------------------
 // CTsFastSwapArea::CanClose
 TSLOG_CONTEXT( HandleFswContentChangedL, TSLOG_LOCAL );
 TSLOG_IN();
 // get current content from fastswap server
 iFSClient->GetContentL( iArray );
-SwapApplicationOrder( iArray );
 #ifdef _DEBUG
 for ( TInt i = 0, ie = iArray.Count(); i != ie; ++i )
 {
 CTsFswEntry* e = iArray[i];
 CleanupStack::PushL( iconArray );
 CDesCArrayFlat* textArray = new ( ELeave ) CDesCArrayFlat( KMaxGranularity );
 CleanupStack::PushL( textArray );
 RArray<TInt> closeItemArray;
 CleanupClosePushL(closeItemArray);
+RArray<TInt> strokeItemArray;
+CleanupClosePushL(strokeItemArray);
 TInt variety = Layout_Meta_Data::IsLandscapeOrientation() ? 1 : 0;
 RArray<TAknLayoutRect> rects;
 CleanupClosePushL(rects);
 rects.ReserveL(KLayoutItemCount);
 GetFastSwapAreaRects(rects);
 TAknLayoutRect gridItem = rects[1];
 CleanupStack::PopAndDestroy(&rects);
 if ( iArray.Count() )
 {
+iGrid->ItemDrawer()->ColumnData()->SetDrawBackground(EFalse);
+static_cast<CTsAppView*>(&iParent)->EnableDragEvents(ETrue);
 if ( AknLayoutUtils::LayoutMirrored() )
 {
 iGrid->SetLayoutL( EFalse, EFalse, ETrue, iArray.Count(), 1, gridItem.Rect().Size(), iGridItemGap );
 }
 else
 {
 iGrid->SetLayoutL( EFalse, ETrue, ETrue, iArray.Count(), 1, gridItem.Rect().Size(), iGridItemGap );
 }
+}
+else
+{
+iGrid->ItemDrawer()->ColumnData()->SetDrawBackground(ETrue);
+static_cast<CTsAppView*>(&iParent)->EnableDragEvents(EFalse);
 }
 for ( TInt i = 0, ie = iArray.Count(); i != ie; ++i )
 {
 const TDesC& appName( iArray[i]->AppName() );
 TSLOG2( TSLOG_INFO, "'%S' screenshot handle %d", &appName, h );
 TInt maskh = 0;
 CFbsBitmap* mask = 0;
 if ( !h )
 {
+// No screenshot, take app icon
 h = iArray[i]->AppIconBitmapHandle();
 maskh = iArray[i]->AppIconMaskHandle();
 TSLOG1( TSLOG_INFO, "using appicon, handle = %d", h );
+}
+else
+{
+// Screenshot exists, mark it for stroke
+strokeItemArray.AppendL(i);
 }
 __ASSERT_DEBUG( h, User::Invariant() );
 bitmap = CopyBitmapL( h, sz );
 CleanupStack::PushL( bitmap );
 if ( maskh )
 delete oldIconArray;
 oldIconArray = NULL;
 }
 iGrid->ItemDrawer()->FormattedCellData()->SetIconArrayL(iconArray);
 iGrid->SetCloseItemsL(closeItemArray);
+iGrid->SetStrokeItemsL(strokeItemArray);
 // Cleanup
+CleanupStack::PopAndDestroy(&strokeItemArray);
 CleanupStack::PopAndDestroy(&closeItemArray);
 CleanupStack::Pop(textArray);
 CleanupStack::Pop(iconArray);
 if( iGrid->ScrollBarFrame() )
 iGrid->ScrollBarFrame()->SetScrollBarVisibilityL(
 CEikScrollBarFrame::EOff, CEikScrollBarFrame::EOff);
 }
 // refresh the items in the grid
-if(iPreviousNoOfItems < iArray.Count())
+iGrid->HandleItemAdditionL();
-{
-iGrid->HandleItemAdditionL();
-}
-else if(iPreviousNoOfItems > iArray.Count())
-{
-iGrid->HandleItemRemovalL();
-}
-iPreviousNoOfItems = iArray.Count();
 iEvtHandler.ReInitPhysicsL( GridWorldSize(), ViewSize(), ETrue );
 UpdateGrid( ETrue, !aSuppressAnimation );
 TSLOG_OUT();
 }
 User::LeaveIfError( bmp->Duplicate( aFbsHandle ) );
 // do not always use aSize, preserving the aspect ratio is quite
 // important when showing app icons instead of screenshots
 TSize sz = CalculateSizePreserveRatio( aSize, bmp->SizeInPixels() );
 User::LeaveIfError( ret->Create( sz, bmp->DisplayMode() ) );
 AknIconUtils::ScaleBitmapL( sz, ret, bmp );
 CleanupStack::PopAndDestroy( bmp );
 TSLOG_CONTEXT( CTsFastSwapArea::HandleSwitchToForegroundEvent, TSLOG_LOCAL );
 TSLOG_IN();
 // Reset grid
 TRAP_IGNORE( ReCreateGridL() );
+if ( iDeviceState.DeviceType() == CTsDeviceState::EFullTouch )
+{
+iGrid->HideHighlight();
+}
+else
+{
+iGrid->ShowHighlight();
+}
 // get the current task list
 HandleFswContentChanged();
 // and then start listening for changes
 iFSClient->Subscribe( *this );
-if ( iDeviceState.DeviceType() == CTsDeviceState::EFullTouch )
-{
-iGrid->HideHighlight();
-}
-else
-{
-iGrid->ShowHighlight();
-}
 RestoreSelectedIndex();
 UpdateGrid(EFalse, EFalse);
 iRedrawTimer->Cancel();
 iRedrawTimer->After(KRedrawTime);
 TKeyResponse CTsFastSwapArea::OfferKeyEventL(
 const TKeyEvent& aKeyEvent,
 TEventCode aType )
 {
 iKeyEvent = ETrue;
-iGrid->SetTactileFeedbackSupport(EFalse);
 // handle the 'clear' key
 if ( aType == EEventKey && aKeyEvent.iCode == EKeyBackspace )
 {
 TInt idx = SelectedIndex();
 if ( idx >= 0 )
 // -----------------------------------------------------------------------------
 //
 void CTsFastSwapArea::HandlePointerEventL( const TPointerEvent& aPointerEvent )
 {
 iKeyEvent = EFalse;
-iGrid->SetTactileFeedbackSupport(ETrue);
 if(aPointerEvent.iType == TPointerEvent::EButton1Down)
 {
 iTapEvent = aPointerEvent;
 }
 }
 void CTsFastSwapArea::RestoreSelectedIndex()
 {
 iSavedSelectedIndex = KErrNotFound;
 if ( GridItemCount() )
 {
-// highlight second recent item (that has index 2) if possible
+// highlight second recent item (that has index 1) if possible
 TInt highlightItem = 0;
 TInt count = GridItemCount();
 while( highlightItem < count
 && highlightItem < KItemToHighlight )
 {
 void CTsFastSwapArea::NotifyChange()
 {
 if ( iDcObserver )
 {
 iDcObserver->DataChanged( this, Count() );
-}
-}
-// -----------------------------------------------------------------------------
-// CTsFastSwapArea::SwapApplicationOrder
-// -----------------------------------------------------------------------------
-//
-void CTsFastSwapArea::SwapApplicationOrder(
-RPointerArray<CTsFswEntry>& aArray )
-{
-for ( TInt i = 0; i < aArray.Count(); ++i )
-{
-if( aArray[i]->AppUid() == KAiUid )
-{
-CTsFswEntry* homescreenEntry(0);
-homescreenEntry = aArray[i];
-aArray.Remove(i);
-aArray.Insert(homescreenEntry, KAiPosition);
-break;
-}
 }
 }
 // -----------------------------------------------------------------------------
 // CTsFastSwapArea::PreferredImageSize
 //
 TSize CTsFastSwapArea::CalculateSizePreserveRatio(
 const TSize& aTargetAreaSize,
 const TSize& aSourceSize )
 {
-TSize sz;
+const TReal
-if ( aSourceSize.iWidth > aSourceSize.iHeight )
+resizedAspectRatio(aTargetAreaSize.iWidth/(TReal)aTargetAreaSize.iHeight);
-{
+const TReal
-sz.iWidth = aTargetAreaSize.iWidth;
+orginalAspectRatio(aSourceSize.iWidth/(TReal)aSourceSize.iHeight);
-TReal ratio = aSourceSize.iWidth / (TReal) aSourceSize.iHeight;
+//this condition avoid empty margins ( bigger output ). to realy fit area change it
-sz.iHeight = sz.iWidth / ratio;
+const TReal scaleFactor =
-}
+( orginalAspectRatio > resizedAspectRatio ) ?
-else
+(aTargetAreaSize.iHeight /(TReal)aSourceSize.iHeight) ://scale by height
-{
+(aTargetAreaSize.iWidth /(TReal)aSourceSize.iWidth) ;//scale by width
-sz.iHeight = aTargetAreaSize.iHeight;
+return TSize(aSourceSize.iWidth * scaleFactor, aSourceSize.iHeight * scaleFactor);
-TReal ratio = aSourceSize.iHeight / (TReal) aSourceSize.iWidth;
-sz.iWidth = sz.iHeight / ratio;
-}
-return sz;
 }
 // --------------------------------------------------------------------------
 // CTsFastSwapArea::SelectNextItem
 // --------------------------------------------------------------------------
 //
 void CTsFastSwapArea::SelectNextItem()
 {
 iKeyEvent = ETrue;
-iGrid->SetTactileFeedbackSupport(EFalse);
 TBool forceRedraw(ETrue);
 TBool animate(ETrue);
 TInt selectedItem = SelectedIndex();
 selectedItem++;
 if ( selectedItem == GridItemCount() )
 // Check if view is outside of grid world
 TPoint absViewPos = ViewPos();
 absViewPos.iX -= Rect().Width() / 2;
 if( !iEvtHandler.IsPhysicsRunning() &&
-( absViewPos.iX < 0 || absViewPos.iX + Rect().Width() > GridWorldSize().iWidth )
+( absViewPos.iX < 0 ||( absViewPos.iX + Rect().Width() > GridWorldSize().iWidth && GridItemCount() ) )
 )
 {
 // View is outside of grid world - update view
 iUpdateGridTimer->Cancel();
 iUpdateGridTimer->After(aRedrawDelay);
 MoveOffset(targetPoint, ETrue);
 iEvtHandler.StopAnimation();
 }
 if ( aForceRedraw )
 {
+iParent.DrawDeferred();
 iGrid->DrawNow();
 }
 }
 }
 // CTsFastSwapArea::HandleAppKey
 // --------------------------------------------------------------------------
 //
 void CTsFastSwapArea::HandleAppKey(TInt aType)
 {
-if( aType == KAppKeyTypeShort )
+if ( iArray.Count() )
 {
-if(iGrid->IsHighlightVisible())
+if( aType == KAppKeyTypeShort )
 {
-SelectNextItem();
+if(iGrid->IsHighlightVisible())
-}
+{
-else
+SelectNextItem();
-{
+}
-iGrid->ShowHighlight();
+else
-}
+{
-}
+iGrid->ShowHighlight();
-else if( aType == KAppKeyTypeLong )
+}
-{
+}
-SwitchToApp( SelectedIndex() );
+else if( aType == KAppKeyTypeLong )
+{
+SwitchToApp( SelectedIndex() );
+}
+}
+else
+{
+TRAP_IGNORE( iEikonEnv->EikAppUi()->HandleCommandL(EAknSoftkeyExit) );
 }
 }
 // --------------------------------------------------------------------------
 // CTsFastSwapArea::MoveOffset
 currentXPos -= Rect().Width() / 2;
 TRect gridViewRect = Rect();
 gridViewRect.iTl.iX = -currentXPos;
 // Take edge offset into account
 gridViewRect.iTl.iX += Rect().iTl.iX;
-if(GridItemCount() <= iMaxItemsOnScreen)
+if(GridItemCount() && GridItemCount() <= iMaxItemsOnScreen)
 {
 // Center view
 gridViewRect.iTl.iX += ( Rect().Width() - GridItemCount() * iGridItemWidth ) / 2;
 }
+DrawDeferred();
 iGrid->SetRect( gridViewRect );
-DrawDeferred();
 iLogicalViewPosOffset = 0;
 }
 else
 {
 // Update logical view position
 // CTsFastSwapArea::Tap
 // --------------------------------------------------------------------------
 //
 void CTsFastSwapArea::TapL(const TPoint& aPoint)
 {
-if(Rect().Contains(aPoint))
+if(Rect().Contains(aPoint) && iArray.Count())
 {
 //provide tap pointer event to grid
 iGrid->HandlePointerEventL(iTapEvent);
 iHighlightTimer->Cancel();
 iHighlightTimer->After(KHighlighActivationTime);
 // --------------------------------------------------------------------------
 //
 void CTsFastSwapArea::LongTapL(const TPoint& aPoint)
 {
 TInt index(KErrNotFound);
-if( iGrid->GridView()->XYPosToItemIndex(aPoint,index) )
+if( iGrid->GridView()->XYPosToItemIndex(aPoint,index) && iArray.Count() )
 {
 iGrid->SetCurrentItemIndex(index);
 SaveSelectedIndex();
 if ( !ShowPopupL(iSavedSelectedIndex, aPoint) )
 {
 {
 	if( aEvent.State() == EAknTouchGestureFwStop)
 		{
 		CenterItem( KUpdateGridTime );
 		}
-iGrid->SetTactileFeedbackSupport(ETrue);
 iGrid->HideHighlight();
 }
 // -----------------------------------------------------------------------------
 // CTsFastSwapArea::ViewSize
 {
 TPoint retVal;
 retVal.iY = iGrid->Rect().iTl.iY + Rect().Height() / 2;
 retVal.iX = - (iGrid->Rect().iTl.iX - Rect().iTl.iX) + Rect().Width() / 2 ;
 TInt gridItemCount = iGrid->Model()->ItemTextArray()->MdcaCount();
-if( gridItemCount <= iMaxItemsOnScreen)
+if(gridItemCount && gridItemCount <= iMaxItemsOnScreen)
 {
 // View centered
 retVal.iX += ( Rect().Width() - gridItemCount * iGridItemWidth ) / 2;
 }
 retVal.iX += iLogicalViewPosOffset;
 // -----------------------------------------------------------------------------
 //
 TPoint CTsFastSwapArea::ItemViewPosition( TInt aItemIdx )
 {
 TPoint retVal = Rect().iTl;
-if ( aItemIdx == 0 )
+if ( aItemIdx < 0 )
+{
+// No items
+retVal.iX = 0;
+}
+else if ( aItemIdx == 0 )
 {
 // First item
 if( AknLayoutUtils::LayoutMirrored() )
 {
 if ( GridItemCount() > iMaxItemsOnScreen )

branch	RCL_3
changeset 30	b8fae6b8a148
parent 16	9674c1a575e9
child 34	d05a55b217df