FCL/sf/app/photos: comparison photosgallery/viewframework/views/cloudview/src/glxcloudviewcontrol.cpp

equal deleted inserted replaced

-:5b3385a43d68
+:34937ec34dac
 //get the attributes from Cache
 FetchAttributeFromCacheL();
 if ( iLabels.Count ()==listCount && iAttributeContext->RequestCountL (&iMediaList)==0)
 {
-//if we navigate in forward direction, first item should be highlighted.if we are navigating in
-// backwards direction, index is not necessarily zero, it will be restored.
 if ( iUiUtility->ViewNavigationDirection ()== EGlxNavigationForwards && iMediaList.Count ())
 {
 iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
 }
 UpdateRowDataL ();
 }
 //get touch feedback instance
 iTouchFeedback = MTouchFeedback::Instance();
 iPhysics = CAknPhysics::NewL(*this, NULL);
 InitPhysicsL();
+iShowFocus = EFalse;
 }
 // ---------------------------------------------------------------------------
 //VisualLayoutUpdated()
 // ---------------------------------------------------------------------------
 // Destructor
 // ---------------------------------------------------------------------------
 //
 CGlxCloudViewControl::~CGlxCloudViewControl()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::~CGlxCloudViewControl");
 iCloudInfo.Close ();
 iLabels.Close();
 iMediaList.RemoveContext (iAttributeContext);
 }
 GLX_LOG_INFO("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea Exiting layout append");
 iLayoutIndex = 0;
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea layout Count realloc  %d ", iLayout->Count ());
-for (TInt j = 0; j <= iEndRowIndex; j++)
+TInt totalHeight = 0;
+for (TInt j = 0; j <= iCloudInfo.Count() - 1; j++)
 {
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea Drawing row started  %d ", j);
 LayoutVisibleRows (startpoint,iCloudInfo[j].iStartIndex,
 iCloudInfo[j].iEndIndex);
 startpoint.iY += KRowHeight + KNumMinRowSpace;
-}
-TInt totalHeight = 0;
-for (TInt j = 0; j <= iCloudInfo.Count()-1; j++)
-{
 totalHeight+=KRowHeight;
 totalHeight+=KNumMinRowSpace;
 }
 //Set the virtual size of viewport to the total size of anchor.
 // ---------------------------------------------------------------------------
 // OfferEventL()
 // ---------------------------------------------------------------------------
 //
 TBool CGlxCloudViewControl::OfferEventL(const TAlfEvent &aEvent)
-{   TRACER("GLX_CLOUD:: CGlxCloudViewControl::OfferEventL");
+{
+TRACER("GLX_CLOUD:: CGlxCloudViewControl::OfferEventL");
 //check if key inputs needs handling
 TBool consumed = EFalse;
-if ( ( iLabels.Count () == 0 ) )
+if (iLabels.Count() == 0)
 {
 GLX_LOG_INFO( "GLX_CLOUD ::CGlxCloudViewControl::offerkeyeventL no key press returning  ");
 return EFalse; //return as no futher processing is required
 }
+if (aEvent.IsKeyEvent() && iTagsContextMenuControl->ItemMenuVisibility())
+{
+// Hide the context menu, if visible
+ShowContextItemMenuL(EFalse);
+}
 if ( aEvent.IsKeyEvent ()&& aEvent.Code() == EEventKey )
 {
 switch (aEvent.KeyEvent().iCode)
 {
-//@ EABI-7R7FRU Fute failure: Tag views enter key has no functionality.
 case EKeyEnter :
 case EKeyDevice3:
 {
-iObserverEnterKeyEvent.HandleEnterKeyEventL( (TInt)EAknCmdOpen );
+if (iShowFocus)
-consumed= ETrue;
+{
+iShowFocus = EFalse;
+iObserverEnterKeyEvent.HandleEnterKeyEventL(
+(TInt) EAknCmdOpen);
+}
+else
+{
+SetFocusToFirstVisibleItemL();
+}
+consumed = ETrue;
 }
 break;
 case EKeyUpArrow:
 {
-if(iCloudInfo.Count() >1 )
+if (iShowFocus)
 {
-HandleKeyUpL ();
+HandleKeyUpL();
-consumed = ETrue;
+iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+MoveUpIfRequired();
-MoveUpIfRequired();
 }
+else
+{
+SetFocusToFirstVisibleItemL();
+}
+consumed = ETrue;
 }
 break;
 case EKeyDownArrow:
 {
-if (iCloudInfo.Count() > 1)
+if (iShowFocus)
 {
-HandleKeyDownL ();
+HandleKeyDownL();
-consumed = ETrue;
+iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+MoveDownIfRequired();
-MoveDownIfRequired();
+}
-}
+else
+{
+SetFocusToFirstVisibleItemL();
+}
+consumed = ETrue;
 }
 break;
 case EKeyLeftArrow:
 case EKeyPrevious:
 {
-// arabic hebrew change
+if (iShowFocus)
-if ( GlxGeneralUiUtilities::LayoutIsMirrored () )
 {
-if ( iMediaList.FocusIndex() == iMediaList.Count() - 1 )
+// arabic hebrew change
+if (GlxGeneralUiUtilities::LayoutIsMirrored())
 {
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
+if (iMediaList.FocusIndex() == iMediaList.Count() - 1)
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, 0);
+}
+else
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex() + 1);
+}
+iScrollDirection = 0;
 }
 else
 {
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+if (iMediaList.FocusIndex() == 0)
-iMediaList.FocusIndex ()+ 1);
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.Count() - 1);
+}
+else
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex() - 1);
+}
+iScrollDirection = 1;
 }
-iScrollDirection = 0;
+TInt focusRowIndex = RowNumber(iMediaList.FocusIndex());
+if (iFocusRowIndex != focusRowIndex)
+{
+iFocusRowIndex = focusRowIndex;
+if (iScrollDirection == 0)
+{
+MoveDownIfRequired();
+}
+else
+{
+MoveUpIfRequired();
+}
+}
 }
 else
 {
-if ( iMediaList.FocusIndex ()== 0 )
+SetFocusToFirstVisibleItemL();
+}
+consumed = ETrue;
+}
+break;
+case EKeyRightArrow:
+case EKeyNext:
+{
+if (iShowFocus)
+{
+// arabic hebrew change
+if (GlxGeneralUiUtilities::LayoutIsMirrored())
 {
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+if (iMediaList.FocusIndex() == 0)
-iMediaList.Count() - 1 );
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.Count() - 1);
+}
+else
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex() - 1);
+}
+iScrollDirection = 1;
 }
 else
 {
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+if (iMediaList.FocusIndex() == iMediaList.Count() - 1)
-iMediaList.FocusIndex ()- 1);
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, 0);
+}
+else
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex() + 1);
+}
+iScrollDirection = 0;
 }
-iScrollDirection = 1;
+TInt focusRowIndex = RowNumber(iMediaList.FocusIndex());
-}
-consumed = ETrue;
+if (iFocusRowIndex != focusRowIndex)
-TInt focusRowIndex = RowNumber (iMediaList.FocusIndex ());
+{
-if(iFocusRowIndex != focusRowIndex)
+iFocusRowIndex = focusRowIndex;
-{
+if (iScrollDirection == 1)
-iFocusRowIndex = focusRowIndex;
+{
-if( iScrollDirection == 0 )
+MoveUpIfRequired();
-{
+}
-MoveDownIfRequired();
+else
+{
+MoveDownIfRequired();
+}
 }
-else
-{
-MoveUpIfRequired();
-}
-}
-}
-break;
-case EKeyRightArrow:
-case EKeyNext:
-{
-// arabic hebrew change
-if ( GlxGeneralUiUtilities::LayoutIsMirrored () )
-{
-if ( iMediaList.FocusIndex ()== 0 )
-{
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
-iMediaList.Count() - 1 );
-}
-else
-{
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
-iMediaList.FocusIndex ()- 1);
-}
-iScrollDirection = 1;
 }
 else
 {
-if ( iMediaList.FocusIndex ()== iMediaList.Count() - 1 )
+SetFocusToFirstVisibleItemL();
-{
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
-}
-else
-{
-iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
-iMediaList.FocusIndex ()+ 1);
-}
-iScrollDirection = 0;
 }
-TInt focusRowIndex = RowNumber (iMediaList.FocusIndex ());
+consumed = ETrue;
-if( iFocusRowIndex != focusRowIndex )
-{
-iFocusRowIndex = focusRowIndex;
-if( iScrollDirection == 1 )
-{
-MoveUpIfRequired();
-}
-else
-{
-MoveDownIfRequired();
-}
-}
 }
-consumed = ETrue;
 break;
 default:
 break;
 }
 //
 void CGlxCloudViewControl::HandleLayoutFocusChange()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::HandleLayoutFocusChange");
-if ( iLabels.Count()-1 >= iMediaList.FocusIndex())
+if ((iShowFocus || !iUiUtility->IsPenSupported()) && (iLabels.Count() - 1
+>= iMediaList.FocusIndex()))
 {
 //to highlight focused element
 SetFocusColor();
 }
 }
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::FocusUpdate()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::FocusUpdate");
-GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::FocusUpdate HighLighted RowNum  %d ",iFocusRowIndex);
+iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
-GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::FocusUpdate End RowNumn %d ",iCloudInfo.Count()-1);
+GLX_LOG_INFO1("GLX_CLOUD::FocusUpdate iFocusRowIndex=%d",
-iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+iFocusRowIndex);
-iEndRowIndex = iCloudInfo.Count()-1;
 LayoutVisibleArea();
 }
 // ---------------------------------------------------------------------------
 // ResetLayout()
 if (iAttributeContext->RequestCountL(aList) == 0 )
 {
 //reset the layout and get the items from cache
 UpdateLayout(); //remove all the visuals from the layout.layout is empty now.
 iCloudInfo.Close (); //row information is reset
-//get the new array contents from cache.no need to reset the array as the number
-//of items in array will remain same.
-FetchAttributeFromCacheL();
-UpdateRowDataL (); //updates the row data and reassigns font sizes and draw the layout on screen.
 }
 InitPhysicsL();
 }
 {
 //get the new array contents from cache.no need to reset the array as the number
 //of items in array will remain same.
 UpdateLayout(); //remove all the visuals from the layout.layout is empty now.
 FetchAttributeFromCacheL();
-//if we navigate in forward direction, first item should be highlighted.if we are navigating in
-// backwards direction, index is not necessarily zero, it will be restored.
 if ( iUiUtility->ViewNavigationDirection ()== EGlxNavigationForwards && iMediaList.Count ())
 {
 iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
 }
 //generate row structures and draw rows on screen
 AppendToCloudArrayL( cloudInfo,lastRowStartTagIndex, KLabelsCount - 1 );
 }
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::UpdateRowData  iCloudInfo.count loop exit  %d ", iCloudInfo.Count());
 FocusUpdate (); //Start screen drawing
-iEndRowIndex = iCloudInfo.Count()-1;
 }
 // ---------------------------------------------------------------------------
 // SetProperties
 // ---------------------------------------------------------------------------
 }
 return usageCount;
 }
 // ---------------------------------------------------------------------------
-// SetFocusColor()
+// AppendToCloudArrayL()
 // ---------------------------------------------------------------------------
 //
-void CGlxCloudViewControl::AppendToCloudArrayL(
+void CGlxCloudViewControl::AppendToCloudArrayL(TGlxCloudInfo& aCloudInfo,
-TGlxCloudInfo& aCloudInfo,const TInt& aStartIndex, const TInt& aEndIndex )
+const TInt& aStartIndex, const TInt& aEndIndex)
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::AppendToCloudArrayL");
 aCloudInfo.iStartIndex = aStartIndex;
 aCloudInfo.iEndIndex = aEndIndex;
 iCloudInfo.AppendL( aCloudInfo );
 // ---------------------------------------------------------------------------
 // SetFocusColor()
 // ---------------------------------------------------------------------------
 //
-void  CGlxCloudViewControl::SetFocusColor()
+void CGlxCloudViewControl::SetFocusColor()
 {
-iLabels[iMediaList.FocusIndex()]->SetColor (KAknsIIDQsnHighlightColors ,EAknsCIQsnHighlightColorsCG3);
+TRACER("GLX_CLOUD::CGlxCloudViewControl::SetFocusColor");
-}
+if (iMediaList.Count())
+{
-// ---------------------------------------------------------------------------
+iLabels[iMediaList.FocusIndex()]->SetColor(
-// SetBubleMidPoint()
+KAknsIIDQsnHighlightColors, EAknsCIQsnHighlightColorsCG3);
-// ---------------------------------------------------------------------------
+}
-//
+}
-void  CGlxCloudViewControl::SetBubleMidPoint(TPoint& aMidPoint)
-{
+// ---------------------------------------------------------------------------
-TRACER("GLX_CLOUD::CGlxCloudViewControl::SetBubleMidPoint");
+// ResetFocusColor()
-//Substract the viewport position so as to set the buble at the right position on the screen
+// ---------------------------------------------------------------------------
-aMidPoint.iX-=iViewPortPosition.iX;
+//
-aMidPoint.iY-=iViewPortPosition.iY;
+void CGlxCloudViewControl::ResetFocusColor()
+{
+TRACER("GLX_CLOUD::CGlxCloudViewControl::ResetFocusColor");
+if (iMediaList.Count())
+{
+iLabels[iMediaList.FocusIndex()]->SetColor(KAknsIIDQsnTextColors,
+EAknsCIQsnTextColorsCG6);
+}
 }
 // ---------------------------------------------------------------------------
 // MoveUpIfRequired()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::MoveUpIfRequired()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::MoveUpIfRequired");
+TInt focusIndex = iMediaList.FocusIndex();
 //get the focused item's position
 TPoint point;
-iLayout->ChildPos(iMediaList.FocusIndex(),point);
+iLayout->ChildPos(focusIndex,point);
 TSize size;
-iLayout->ChildSize(iMediaList.FocusIndex(),size);
+iLayout->ChildSize(focusIndex,size);
-TInt focus = iMediaList.FocusIndex();
-TInt rownumber = RowNumber(focus);
+TInt rownumber = RowNumber(focusIndex);
 //if the focused item is not visible then move the viewport
 if(point.iY < iViewPortPosition.iY)
 {
 //set the new position of viewport
-TInt offeset = iViewPortPosition.iY - point.iY;
+TInt offset = iViewPortPosition.iY - point.iY;
-iViewPortPosition.iY-=offeset;
+iViewPortPosition.iY-=offset;
 if( (iViewPortPosition.iY < 0) )
 {
 iViewPortPosition.iY = 0;
 }
 }
 // MoveDownIfRequired()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::MoveDownIfRequired()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::MoveDownIfRequired");
+TInt focusIndex = iMediaList.FocusIndex();
 //get the focused item's position
 TPoint point;
-iLayout->ChildPos(iMediaList.FocusIndex(),point);
+iLayout->ChildPos(focusIndex, point);
 TSize size;
-iLayout->ChildSize(iMediaList.FocusIndex(),size);
+iLayout->ChildSize(focusIndex, size);
-//if the focused visual is not visible then move the viewport
-if(point.iY+size.iHeight > iViewPortPosition.iY+iViewPortSize.iHeight )
+//Reset viewport position for cases:
-{
+//case 1)Focus index is first item
-//set the new position of viewport
+if (focusIndex == 0)
-TInt offeset = (point.iY+size.iHeight) - (iViewPortPosition.iY+iViewPortSize.iHeight);
+{
-iViewPortPosition.iY+=offeset;
+		iViewPortPosition.iY = 0;
-if( (iViewPortPosition.iY > iViewPortVirtualSize.iHeight) )
+		}
-{
+//case 2)Focused item is in last screen
-iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
+else if( point.iY > (iViewPortVirtualSize.iHeight - iViewPortSize.iHeight))
-}
+{
-}
+iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
-//if its key event then it should be cyclic
+}
-else if (iMediaList.FocusIndex() == 0)
+else
 {
-iViewPortPosition.iY = 0;
+iViewPortPosition.iY = point.iY + KNumMinRowSpace;
 }
+//Validate the viewport position
+if ((iViewPortPosition.iY > iViewPortVirtualSize.iHeight))
+{
+		iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
+}
+GLX_LOG_INFO1("GLX_CLOUD::MoveDownIfRequired() iViewPortPosition.iY:%d",
+iViewPortPosition.iY);
 iViewPortLayout->SetViewportPos(iViewPortPosition, KSlowCloudMovement);
 iScrollEventData.mViewStartPos = iViewPortPosition.iY;
 if(iScrollBarWidget)
 {
 Scroll();
 }
 }
-// ---------------------------------------------------------------------------
-// MoveDownIfRequired()
-// ---------------------------------------------------------------------------
-//
-void CGlxCloudViewControl::CalculateBubleMidPoint()
-{
-TRACER("GLX_CLOUD::CGlxCloudViewControl::CalculateBubleMidPoint");
-TPoint midpoint;
-TAlfRealRect focussedItemRect;
-TRect mainPaneRect;
-AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, mainPaneRect);
-CAlfVisual& visual = iLayout->Visual( iMediaList.FocusIndex() );
-focussedItemRect = visual.DisplayRect();
-if( GlxGeneralUiUtilities::LayoutIsMirrored () )
-{
-midpoint.iX = focussedItemRect.iBr.iX +
-((focussedItemRect.iTl.iX - focussedItemRect.iBr.iX )/2);
-}
-else
-{
-midpoint.iX=focussedItemRect.iTl.iX +
-((focussedItemRect.iBr.iX - focussedItemRect.iTl.iX )/2);
-}
-midpoint.iY=focussedItemRect.iTl.iY+
-((focussedItemRect.iBr.iY - focussedItemRect.iTl.iY )/2);
-TPoint anchorRect;
-//Get the position of anchor layout
-iViewPortLayout->ChildPos (0, anchorRect);
-//Add the differance to the midpoint
-midpoint.iX+=anchorRect.iX;
-midpoint.iY+=anchorRect.iY;
-//Substract from the viewport position the viewport position
-SetBubleMidPoint(midpoint);
-}
 // ---------------------------------------------------------------------------
 // HandlePointerEventL()
 // ---------------------------------------------------------------------------
 //
 TBool CGlxCloudViewControl::HandlePointerEventL( const TAlfEvent &aEvent )
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::HandlePointerEventL");
 CAlfVisual* tappedvisual = aEvent.Visual();
 TBool consumed = EFalse;
 //if the tapped visual is same as the visual in the layout then focus that visual
 if(layoutvisual == tappedvisual)
 {
 iTouchFeedback->InstantFeedback(ETouchFeedbackBasic);
 iMediaList.SetFocusL (NGlxListDefs::EAbsolute, index);
+iShowFocus = ETrue;
+HandleLayoutFocusChange();
 //Start the timer to interpret longpress events
 iTimerComplete = EFalse;
 iTimer->Cancel ();//cancels any outstanding requests
 iTimer->SetDelay (KLongPressTimer);
 consumed = HandleDragL(aEvent.PointerEvent());
 }
 else if (iDownEventReceived && aEvent.PointerUp())
 {
+if (!iTagsContextMenuControl->ItemMenuVisibility())
+{
+iShowFocus = EFalse;
+ResetFocusColor();
+}
 iDownEventReceived = EFalse;
 Display()->Roster().SetPointerEventObservers(0, *this);
 consumed = ETrue;
 //If the long press timer is completed , and if upevent is received.. ignore it
 if (layoutvisual == tappedvisual)
 {
 TInt focus = iMediaList.FocusIndex();
 if (index != focus)
 {
-iTouchFeedback->InstantFeedback( ETouchFeedbackBasic );
 TInt focusrowindex = iFocusRowIndex;
 iMediaList.SetFocusL(NGlxListDefs::EAbsolute, index);
-SetFocusColor();
 iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
 if( iFocusRowIndex > focusrowindex)
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::HandleDragL,b4 movedown");
 }
 return false;
 }
 // ---------------------------------------------------------------------------
-// attachScrollBar()
+// InitializeScrollBar()
 // ---------------------------------------------------------------------------
 //
-void CGlxCloudViewControl::InitializeScrollBar(IAlfScrollBarWidget* aScrollBarWidget)
+void CGlxCloudViewControl::InitializeScrollBar(
+IAlfScrollBarWidget* aScrollBarWidget)
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::InitializeScrollBar");
 iScrollBarWidget = aScrollBarWidget;
 ((IAlfScrollBarModel *) (iScrollBarWidget->model()))->initializeData(
 iScrollEventData.mSpan, iScrollEventData.mViewLength, 0);
+Scroll();
 DisplayScrollBar();
 }
 // ---------------------------------------------------------------------------
 // Scroll()
 // ---------------------------------------------------------------------------
 // DisplayScrollBar()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::DisplayScrollBar()
 {
+TRACER("GLX_CLOUD::CGlxCloudViewControl::DisplayScrollBar()");
 if (iScrollBarWidget)
 {
 IAlfElement* vertBaseElement =(iScrollBarWidget->control()->findElement ("BaseElement"));
 IAlfScrollBarDefaultBaseElement* scrollbarbaselement=static_cast<IAlfScrollBarDefaultBaseElement*> (
 vertBaseElement->makeInterface (IAlfScrollBarDefaultBaseElement::type() ) );
-// To set the scrollbar visibility, it's enough to set the opacity
+TInt totalHeight = 0;
-// of baselayout. No need to set the opacity of thumb separately.
+for (TInt index = 0; index <= iCloudInfo.Count() - 1; index++)
-if (iScrollEventData.mSpan)
+{
+totalHeight += KRowHeight;
+totalHeight += KNumMinRowSpace;
+}
+// To set the scrollbar visibility, it's enough to set the opacity
+// of baselayout. No need to set the opacity of thumb separately.
+// Set the scrollbar visibility only
+// when visuals height exceeds the screen height
+if (iScrollEventData.mSpan && totalHeight > iTagScreenHeight)
 {
 //make scroll bar visible
+GLX_LOG_INFO("GLX_CLOUD: Make scrollbar visible!");
 scrollbarbaselement->setOpacity(1.0);
 }
 else
 {
 //make scroll bar invisible
 ((focussedItemRect.iBr.iY - focussedItemRect.iTl.iY )/2);
 TRect rect;
 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);
-if(!iPhysicsStarted)//only if physics hasnt started
+//only if not dragged and physics hasnt started
+if (!iPhysicsStarted && !iViewDragged)
 {
 iTagsContextMenuControl->SetViewableRect(rect);
 iTagsContextMenuControl->ShowItemMenuL(ETrue);
 iTagsContextMenuControl->SetDisplay(midpoint);
 }
 // ShowContextItemMenuL()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::ShowContextItemMenuL(TBool aShow)
 {
+TRACER("GLX_CLOUD::ShowContextItemMenuL");
+GLX_LOG_INFO1("GLX_CLOUD::ShowContextItemMenuL() aShow=%d", aShow);
 iTagsContextMenuControl->ShowItemMenuL(aShow);
 if(!aShow)
 {
 iViewPortLayout->UpdateChildrenLayout(0);
+iShowFocus = EFalse;
+ResetFocusColor();
+}
+}
+// ---------------------------------------------------------------------------
+// SetFocusToFirstVisibleItemL()
+// ---------------------------------------------------------------------------
+//
+void CGlxCloudViewControl::SetFocusToFirstVisibleItemL()
+{
+TRACER("GLX_CLOUD::CGlxCloudViewControl::SetFocusToFirstVisibleItemL()");
+iShowFocus = ETrue;
+TInt visIndex = GetAbsoluteIndex(TPoint(KLeftMargin + KLeftMargin,
+KColSpace));
+GLX_LOG_INFO1("GLX_CLOUD::SetFocusToFirstVisibleItemL() visIndex=%d", visIndex);
+if (visIndex != KErrNotFound)
+{
+iMediaList.SetFocusL(NGlxListDefs::EAbsolute, visIndex);
+MoveUpIfRequired();
+}
+else
+{
+HandleLayoutFocusChange();
 }
 }
 //End of file

branch	RCL_3
changeset 64	34937ec34dac
parent 60	5b3385a43d68
child 75	01504893d9cb