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

equal deleted inserted replaced

-:5b238bc8ffb6
+:01504893d9cb
 #include <glxlog.h>			// For Logs
 #include <glxtracer.h>			// For Logs
 #include <glxattributecontext.h> //attribute context
 #include <mglxmedialist.h> //for medialist
+#include "glxcontainerinfobubble.h" //intelligent class for data of infobubble
 #include "glxcloudview.hrh"
 #include "mglxcloudviewmskobserver.h" // For Msk Observer
 #include "mglxenterkeyeventobserver.h" // For enterkey observer
 #include "mglxcloudviewlayoutobserver.h"
 #include "glxtagscontextmenucontrol.h"
 const TInt KFontLarger = 40;
 const TInt KFontLargest = 44;
 const TInt KRowHeight = 72;
 const TInt KLeftMargin = 10;
 const TInt KNumMinRowSpace = 2;
-const TInt KColSpace = 30;
+const TInt KColSpace = 20;
 const TInt KRightmargin = 10;//Aligning Right margin
 const TInt KMinTagSize = 77;
 const TInt KTagScreenHeight = 460;
 const TReal KBoundaryMargin = 0.1; //10% = 10/100 = 0.1
 const TInt KFastCloudMovement = 100; //Transition time to move cloud view
 //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);
 // ---------------------------------------------------------------------------
 //
 TInt CGlxCloudViewControl::LayoutVisibleRows(TPoint aStartPoint,TInt aRowStartIndex
 , TInt aRowEndIndex)
 {
-TRACER("CGlxCloudViewControl::LayoutVisibleRows");
+TRACER("GLX_CLOUD::CGlxCloudViewControl::DrawRow");
 TSize vsize;
 TPoint tl, br;
 tl = aStartPoint;
-br.iX = 0;
 br.iY = tl.iY + KRowHeight;
-const TInt KMaxScreenWidth = iTagScreenWidth - iScrollPaneHandle.iW;
 //drawing in reverse for arabic hebrew support
 if ( GlxGeneralUiUtilities::LayoutIsMirrored ())
 {
-		GLX_LOG_INFO("Mirrorred Layout");
+br.iX =  aStartPoint.iX;
-		//In Mirrored layout, 'BottomRight' considers scrollpane width for each row
+const TInt KMaxScreenWidth = iTagScreenWidth - iScrollPaneHandle.iW;
-br.iX =  aStartPoint.iX  - iScrollPaneHandle.iW;
 //Set the positions of tags in a row.
 for (TInt j = aRowStartIndex; j <= aRowEndIndex; j++)
 {
-vsize = iLabels[j]->TextExtents();
+vsize = iLabels[j]->TextExtents ();
 if ( vsize.iWidth < KMinTagSize )
 {
 vsize.iWidth = KMinTagSize;
 }
 //If the size of the tag is more than the screen size then wrap it
 if (vsize.iWidth > KMaxScreenWidth)
 {
 TAlfRealSize tagSize( KMaxScreenWidth, br.iY );
 iLabels[j]->SetWrapping( CAlfTextVisual::ELineWrapTruncate );
+vsize = iLabels[j]->TextExtents ();
 tl.iX -= aStartPoint.iX;
 tl.iY = aStartPoint.iY;
 br.iX = tagSize.iWidth;
 }
 else
 {
-				tl.iX = br.iX - vsize.iWidth;
+tl.iX -= (vsize.iWidth + KColSpace);
 }
 //Set the anchor points for the tags
 iLayout->SetAnchor (EAlfAnchorTopLeft, iLayoutIndex,
 EAlfAnchorOriginLeft, EAlfAnchorOriginTop,
 EAlfAnchorMetricAbsolute, EAlfAnchorMetricAbsolute,
 TAlfTimedPoint (tl.iX, tl.iY));
 iLayout->SetAnchor (EAlfAnchorBottomRight, iLayoutIndex,
 EAlfAnchorOriginLeft, EAlfAnchorOriginTop,
 EAlfAnchorMetricAbsolute, EAlfAnchorMetricAbsolute,
 TAlfTimedPoint (br.iX, br.iY));
-//Bottom-Right corner for next tag in same row
 br.iX -= (vsize.iWidth + KColSpace);
 iLayoutIndex += 1;
 }
 }
 else
 {
-		GLX_LOG_INFO("NOT Mirrorred Layout");
+const TInt KMaxScreenWidth = iTagScreenWidth - iScrollPaneHandle.iW;
 for (TInt j = aRowStartIndex; j <= aRowEndIndex; j++)
 {
-vsize = iLabels[j]->TextExtents();
+vsize = iLabels[j]->TextExtents ();
 if( vsize.iWidth < KMinTagSize )
 {
 vsize.iWidth = KMinTagSize;
 }
 if (vsize.iWidth > KMaxScreenWidth)
 {
 TAlfRealSize tagSize( KMaxScreenWidth, br.iY );
+TAlfRealPoint startPos( aStartPoint.iX, 0 );
 iLabels[j]->SetWrapping( CAlfTextVisual::ELineWrapTruncate );
 tl.iX = aStartPoint.iX;
 tl.iY = aStartPoint.iY;
 br.iX = tagSize.iWidth;
 }
 else
 {
-br.iX = tl.iX + vsize.iWidth;
+br.iX += vsize.iWidth + KColSpace;
 }
 iLayout->SetAnchor (EAlfAnchorTopLeft, iLayoutIndex,
 EAlfAnchorOriginLeft, EAlfAnchorOriginTop,
 EAlfAnchorMetricAbsolute, EAlfAnchorMetricAbsolute,
 TAlfTimedPoint (tl.iX, tl.iY));
 iLayout->SetAnchor (EAlfAnchorBottomRight, iLayoutIndex,
 EAlfAnchorOriginLeft, EAlfAnchorOriginTop,
 EAlfAnchorMetricAbsolute, EAlfAnchorMetricAbsolute,
 TAlfTimedPoint (br.iX, br.iY));
-//Top-Left Corner for next tag in same row
+tl.iX = br.iX;
-tl.iX += (vsize.iWidth + KColSpace);
 iLayoutIndex += 1;
 }
 }
 return 0;
 }
 // ---------------------------------------------------------------------------
 // LayoutVisibleArea()
 //
 // ---------------------------------------------------------------------------
 void CGlxCloudViewControl::LayoutVisibleArea()
 {
-	TRACER("CGlxCloudViewControl::LayoutVisibleArea");
 //screen height for boundary check:how many rows fit in.
 //find out how many rows can fit in.
 //add upper and lower margin spacing 5 pixels
 //draw the row on screens
 //If the layout is arabic hebrew then start positioning of tags from end
 if ( GlxGeneralUiUtilities::LayoutIsMirrored ())
 {
 startpoint.iX = iTagScreenWidth - KRightmargin;
 }
-//else start from beginning
+//else start from biginning
 else
 {
 startpoint.iX = KLeftMargin;
 }
 startpoint.iY = KNumMinRowSpace;
 //associate the active visuals with anchor layout
 GLX_LOG_INFO("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea Layout reset");
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea layout Count after reset  %d ", iLayout->Count ());
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::::LayoutVisibleArea iCloudInfo[0].iStartIndex  %d ", iCloudInfo[0].iStartIndex);
 TInt endindex = iCloudInfo.Count()-1;
 for (TInt j = iCloudInfo[0].iStartIndex; j <=iCloudInfo[endindex].iEndIndex; j++)
 {
 GLX_LOG_INFO("GLX_CLOUD ::CGlxCloudViewControl::::FindEndRowIndex Entering layout append");
 TAlfTimedValue opacity;
 opacity.SetValueNow(1.0); // immediate change
 iLabels[j]->SetOpacity(opacity);
 }
 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 ());
-TInt totalHeight = 0;
+for (TInt j = 0; j <= iEndRowIndex; j++)
-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.
 {
 ((IAlfScrollBarModel *)(iScrollBarWidget->model()))->changeData(iScrollEventData.mSpan,
 iScrollEventData.mViewLength,
 0);
 DisplayScrollBar();
 }
+//constructing the bubblecontainer
+CreateBubleContainer();
 iLayout->UpdateChildrenLayout (); //update layout
 HandleLayoutFocusChange ();
 MoveDownIfRequired();
 }
 // ---------------------------------------------------------------------------
 // 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:
 {
-if (iShowFocus)
+iObserverEnterKeyEvent.HandleEnterKeyEventL( (TInt)EAknCmdOpen );
+consumed= ETrue;
+}
+break;
+case EKeyUpArrow:
+{
+if(iCloudInfo.Count() >1 )
 {
-iShowFocus = EFalse;
+HandleKeyUpL ();
-iObserverEnterKeyEvent.HandleEnterKeyEventL(
+consumed = ETrue;
-(TInt) EAknCmdOpen);
+iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+MoveUpIfRequired();
+}
+}
+break;
+case EKeyDownArrow:
+{
+if (iCloudInfo.Count() > 1)
+{
+HandleKeyDownL ();
+consumed = ETrue;
+iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+MoveDownIfRequired();
+}
+}
+break;
+case EKeyLeftArrow:
+case EKeyPrevious:
+{
+// arabic hebrew change
+if ( GlxGeneralUiUtilities::LayoutIsMirrored () )
+{
+if ( iMediaList.FocusIndex() == iMediaList.Count() - 1 )
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
+}
+else
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex ()+ 1);
+}
+iScrollDirection = 0;
 }
 else
 {
-SetFocusToFirstVisibleItemL();
+if ( iMediaList.FocusIndex ()== 0 )
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.Count() - 1 );
+}
+else
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex ()- 1);
+}
+iScrollDirection = 1;
 }
 consumed = ETrue;
+TInt focusRowIndex = RowNumber (iMediaList.FocusIndex ());
+if(iFocusRowIndex != focusRowIndex)
+{
+iFocusRowIndex = focusRowIndex;
+if( iScrollDirection == 0 )
+{
+MoveDownIfRequired();
+}
+else
+{
+MoveUpIfRequired();
+}
+}
 }
 break;
-case EKeyUpArrow:
-{
+case EKeyRightArrow:
-if (iShowFocus)
+case EKeyNext:
+{
+// arabic hebrew change
+if ( GlxGeneralUiUtilities::LayoutIsMirrored () )
 {
-HandleKeyUpL();
+if ( iMediaList.FocusIndex ()== 0 )
-iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
-MoveUpIfRequired();
+iMediaList.Count() - 1 );
+}
+else
+{
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
+iMediaList.FocusIndex ()- 1);
+}
+iScrollDirection = 1;
 }
 else
 {
-SetFocusToFirstVisibleItemL();
+if ( iMediaList.FocusIndex ()== iMediaList.Count() - 1 )
-}
-consumed = ETrue;
-}
-break;
-case EKeyDownArrow:
-{
-if (iShowFocus)
-{
-HandleKeyDownL();
-iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
-MoveDownIfRequired();
-}
-else
-{
-SetFocusToFirstVisibleItemL();
-}
-consumed = ETrue;
-}
-break;
-case EKeyLeftArrow:
-case EKeyPrevious:
-{
-if (iShowFocus)
-{
-// arabic hebrew change
-if (GlxGeneralUiUtilities::LayoutIsMirrored())
 {
-if (iMediaList.FocusIndex() == iMediaList.Count() - 1)
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute, 0);
-{
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute, 0);
-}
-else
-{
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
-iMediaList.FocusIndex() + 1);
-}
-iScrollDirection = 0;
 }
 else
 {
-if (iMediaList.FocusIndex() == 0)
+iMediaList.SetFocusL (NGlxListDefs::EAbsolute,
-{
+iMediaList.FocusIndex ()+ 1);
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
-iMediaList.Count() - 1);
-}
-else
-{
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
-iMediaList.FocusIndex() - 1);
-}
-iScrollDirection = 1;
 }
-TInt focusRowIndex = RowNumber(iMediaList.FocusIndex());
+iScrollDirection = 0;
-if (iFocusRowIndex != focusRowIndex)
+}
-{
+TInt focusRowIndex = RowNumber (iMediaList.FocusIndex ());
-iFocusRowIndex = focusRowIndex;
-if (iScrollDirection == 0)
+if( iFocusRowIndex != focusRowIndex )
 {
-MoveDownIfRequired();
+iFocusRowIndex = focusRowIndex;
-}
+if( iScrollDirection == 1 )
-else
+{
-{
+MoveUpIfRequired();
-MoveUpIfRequired();
+}
-}
+else
+{
+MoveDownIfRequired();
 }
 }
-else
+}
-{
-SetFocusToFirstVisibleItemL();
-}
 consumed = ETrue;
-}
-break;
-case EKeyRightArrow:
-case EKeyNext:
-{
-if (iShowFocus)
-{
-// 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)
-{
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute, 0);
-}
-else
-{
-iMediaList.SetFocusL(NGlxListDefs::EAbsolute,
-iMediaList.FocusIndex() + 1);
-}
-iScrollDirection = 0;
-}
-TInt focusRowIndex = RowNumber(iMediaList.FocusIndex());
-if (iFocusRowIndex != focusRowIndex)
-{
-iFocusRowIndex = focusRowIndex;
-if (iScrollDirection == 1)
-{
-MoveUpIfRequired();
-}
-else
-{
-MoveDownIfRequired();
-}
-}
-}
-else
-{
-SetFocusToFirstVisibleItemL();
-}
-consumed = ETrue;
-}
 break;
 default:
 break;
 }
 }
 iScrollDirection = 1;
 }
 // ---------------------------------------------------------------------------
 // HandleKeyDown()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::HandleKeyDownL()
 //
 void CGlxCloudViewControl::HandleLayoutFocusChange()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::HandleLayoutFocusChange");
-if ((iShowFocus || !iUiUtility->IsPenSupported()) && (iLabels.Count() - 1
+if ( iLabels.Count()-1 >= iMediaList.FocusIndex())
->= iMediaList.FocusIndex()))
 {
 //to highlight focused element
 SetFocusColor();
 }
 }
 // ---------------------------------------------------------------------------
 // FocusUpdate()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::FocusUpdate()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::FocusUpdate");
-iFocusRowIndex = RowNumber(iMediaList.FocusIndex());
+GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::FocusUpdate HighLighted RowNum  %d ",iFocusRowIndex);
-GLX_LOG_INFO1("GLX_CLOUD::FocusUpdate iFocusRowIndex=%d",
+GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::FocusUpdate End RowNumn %d ",iCloudInfo.Count()-1);
-iFocusRowIndex);
+iFocusRowIndex = RowNumber (iMediaList.FocusIndex ());
+iEndRowIndex = iCloudInfo.Count()-1;
 LayoutVisibleArea();
 }
 // ---------------------------------------------------------------------------
 // ResetLayout()
 // ---------------------------------------------------------------------------
 //
 iLabels[i] = NULL;
 }
 iLabels.Reset();
 }
 // ---------------------------------------------------------------------------
 // GetRownum()
 // ---------------------------------------------------------------------------
 //
 TInt CGlxCloudViewControl::RowNumber(TInt aItemIndex) const
-	{
+{
-	TRACER("GLX_CLOUD::CGlxCloudViewControl::GetRownum");
-	//Get the rownumber of the given item index.
+TRACER("GLX_CLOUD::CGlxCloudViewControl::GetRownum");
-	TInt i;
+//Get the rownumber of the given item index.
-	for (i = 0; i < iCloudInfo.Count(); i++)
+TInt i;
-		{
+for (i = 0; i < iCloudInfo.Count (); i++)
-		if ((aItemIndex >= iCloudInfo[i].iStartIndex) && (aItemIndex
+{
-				<= iCloudInfo[i].iEndIndex))
+if ( (aItemIndex >= iCloudInfo[i].iStartIndex) && (aItemIndex <=iCloudInfo[i].iEndIndex))
-			break;
+break;
-		}
+}
-	return i;
+return i;
-	}
+}
 // ---------------------------------------------------------------------------
 // FetchAttributeFromCacheL()
 // ---------------------------------------------------------------------------
 //
 // get the title and set it to the text visual
 iLabels[i]->SetTextL( item.Title() );
 }
 }
 //medialist Observers
 // ---------------------------------------------------------------------------
 // HandleItemAddedL().
 // ---------------------------------------------------------------------------
 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();
 }
 // ---------------------------------------------------------------------------
 // HandleMediaL().
 // ---------------------------------------------------------------------------
 //
 {
 //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
 // ---------------------------------------------------------------------------
 //UpdateRowDataL()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::UpdateRowDataL()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::UpdateRowData()");
 TInt rowStartingTagIndex = 0;
 TInt lastRowStartTagIndex = 0;
 //Setting the Font Styles based on association counts
 //Finding the maximum value of image association
 //Determining the Font(Style) for each visual
-TInt maxCount = MaxUsageCount (); //Maximum Association count
+TInt maxCount= MaxUsageCount (); //Maximum Association count
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::UpdateRowData  mediaCount %d ", maxCount);
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::UpdateRowData  iLabels.Count()  %d ",iLabels.Count());
 if ( 0 == maxCount )
 {
 return; //do not proceed if max count is zero
 {
 rowHeight = currentTagSize.iHeight;
 }
 // Current row width will be progressively incremented to fit as many tags as possible
-rowWidth += currentTagSize.iWidth + KColSpace;
+rowWidth += currentTagSize.iWidth + 10;
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::UpdateRowData   currentTagSize.iWidth %d ", currentTagSize.iWidth);
 GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::UpdateRowData  rowWidth %d ", rowWidth);
 // If the tag size crosses the Screen Size, Then wrap it.
 if ( currentTagSize.iWidth > KMaxScreenWidth )
 // If the current row's width is overflowing the screen width
 // then we must fit the current visual into the next row.
 // Do that check now and adjust accordingly.
 // Fix for EAHN-7BZD78 is to exclude the gap value between the row's tags from the logic
-else if ( rowWidth - KColSpace > KMaxScreenWidth )
+else if ( rowWidth - 10 > KMaxScreenWidth )
 {
 GLX_LOG_INFO("GLX_CLOUD :: CGlxCloudViewControl::UpdateRowData Row added");
 lastRowStartTagIndex = currentTagIndex - 1;
 AppendToCloudArrayL( cloudInfo,rowStartingTagIndex, lastRowStartTagIndex );
 lastRowStartTagIndex++;
 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;
 }
 // ---------------------------------------------------------------------------
-// AppendToCloudArrayL()
+// SetFocusColor()
 // ---------------------------------------------------------------------------
 //
-void CGlxCloudViewControl::AppendToCloudArrayL(TGlxCloudInfo& aCloudInfo,
+void CGlxCloudViewControl::AppendToCloudArrayL(
-const TInt& aStartIndex, const TInt& aEndIndex)
+TGlxCloudInfo& aCloudInfo,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()
 {
-TRACER("GLX_CLOUD::CGlxCloudViewControl::SetFocusColor");
+iLabels[iMediaList.FocusIndex()]->SetColor (KAknsIIDQsnHighlightColors ,EAknsCIQsnHighlightColorsCG3);
-if (iMediaList.Count())
+}
-{
-iLabels[iMediaList.FocusIndex()]->SetColor(
-KAknsIIDQsnHighlightColors, EAknsCIQsnHighlightColorsCG3);
+// ---------------------------------------------------------------------------
-}
+// SetBubleMidPoint()
-}
+// ---------------------------------------------------------------------------
+//
-// ---------------------------------------------------------------------------
+void  CGlxCloudViewControl::SetBubleMidPoint(TPoint& aMidPoint)
-// ResetFocusColor()
+{
-// ---------------------------------------------------------------------------
+TRACER("GLX_CLOUD::CGlxCloudViewControl::SetBubleMidPoint");
-//
+//Substract the viewport position so as to set the buble at the right position on the screen
-void CGlxCloudViewControl::ResetFocusColor()
+aMidPoint.iX-=iViewPortPosition.iX;
-{
+aMidPoint.iY-=iViewPortPosition.iY;
-TRACER("GLX_CLOUD::CGlxCloudViewControl::ResetFocusColor");
+}
-if (iMediaList.Count())
-{
+// ---------------------------------------------------------------------------
-iLabels[iMediaList.FocusIndex()]->SetColor(KAknsIIDQsnTextColors,
+// CreateBubleContainer()
-EAknsCIQsnTextColorsCG6);
+// ---------------------------------------------------------------------------
-}
+//
+void CGlxCloudViewControl::CreateBubleContainer()
+{
 }
 // ---------------------------------------------------------------------------
 // MoveUpIfRequired()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::MoveUpIfRequired()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::MoveUpIfRequired");
-TInt focusIndex = iMediaList.FocusIndex();
 //get the focused item's position
 TPoint point;
-iLayout->ChildPos(focusIndex,point);
+iLayout->ChildPos(iMediaList.FocusIndex(),point);
 TSize size;
-iLayout->ChildSize(focusIndex,size);
+iLayout->ChildSize(iMediaList.FocusIndex(),size);
+TInt focus = iMediaList.FocusIndex();
-TInt rownumber = RowNumber(focusIndex);
+TInt rownumber = RowNumber(focus);
 //if the focused item is not visible then move the viewport
 if(point.iY < iViewPortPosition.iY)
 {
 //set the new position of viewport
-TInt offset = iViewPortPosition.iY - point.iY;
+TInt offeset = iViewPortPosition.iY - point.iY;
-iViewPortPosition.iY-=offset;
+iViewPortPosition.iY-=offeset;
 if( (iViewPortPosition.iY < 0) )
 {
 iViewPortPosition.iY = 0;
 }
 }
 iViewPortLayout->SetViewportPos(iViewPortPosition, KSlowCloudMovement);
 iScrollEventData.mViewStartPos = iViewPortPosition.iY;
 Scroll();
 }
 // ---------------------------------------------------------------------------
 // MoveDownIfRequired()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::MoveDownIfRequired()
 {
 TRACER("GLX_CLOUD::CGlxCloudViewControl::MoveDownIfRequired");
-TInt focusIndex = iMediaList.FocusIndex();
 //get the focused item's position
 TPoint point;
-iLayout->ChildPos(focusIndex, point);
+iLayout->ChildPos(iMediaList.FocusIndex(),point);
 TSize size;
-iLayout->ChildSize(focusIndex, size);
+iLayout->ChildSize(iMediaList.FocusIndex(),size);
+//if the focused visual is not visible then move the viewport
-//Reset viewport position for cases:
+if(point.iY+size.iHeight > iViewPortPosition.iY+iViewPortSize.iHeight )
-//case 1)Focus index is first item
+{
-if (focusIndex == 0)
+//set the new position of viewport
-{
+TInt offeset = (point.iY+size.iHeight) - (iViewPortPosition.iY+iViewPortSize.iHeight);
-		iViewPortPosition.iY = 0;
+iViewPortPosition.iY+=offeset;
-		}
+if( (iViewPortPosition.iY > iViewPortVirtualSize.iHeight) )
-//case 2)Focused item is in last screen
+{
-else if( point.iY > (iViewPortVirtualSize.iHeight - iViewPortSize.iHeight))
+iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
-{
+}
-iViewPortPosition.iY = iViewPortVirtualSize.iHeight - iViewPortSize.iHeight;
+}
-}
+//if its key event then it should be cyclic
-else
+else if (iMediaList.FocusIndex() == 0)
 {
-iViewPortPosition.iY = point.iY + KNumMinRowSpace;
+iViewPortPosition.iY = 0;
 }
-//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;
 }
 // ---------------------------------------------------------------------------
-// InitializeScrollBar()
+// attachScrollBar()
 // ---------------------------------------------------------------------------
 //
-void CGlxCloudViewControl::InitializeScrollBar(
+void CGlxCloudViewControl::InitializeScrollBar(IAlfScrollBarWidget* aScrollBarWidget)
-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() ) );
-TInt totalHeight = 0;
+// To set the scrollbar visibility, it's enough to set the opacity
-for (TInt index = 0; index <= iCloudInfo.Count() - 1; index++)
+// of baselayout. No need to set the opacity of thumb separately.
-{
+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
 {
 TRect rect;
 AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);
 if ((rect.Width() != (iTagScreenWidth + KRightmargin)) || (rect.Height() != iScreenHeight))
 {
-		//set the new screen dimensions
+//set the new screen dimensions
-		iScreenHeight = rect.Height();
+iScreenHeight=rect.Height();
-		iTagScreenWidth = rect.Width() - KRightmargin;
+iTagScreenWidth = rect.Width()- KRightmargin;
-		if (IsLandscape())
+if(IsLandscape())
-			{
+{
-			iTagScreenHeight = rect.Height();
+iTagScreenHeight = rect.Height();
-			}
+}
-		else
+else
-			{
+{
-			iTagScreenHeight = KTagScreenHeight;
+iTagScreenHeight = KTagScreenHeight;
-			}
+}
-		iViewPortLayout->SetSize(
+iViewPortLayout->SetSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight), 0);
-				TAlfRealSize(iTagScreenWidth, iTagScreenHeight), 0);
+//delete all layout associations
-		//delete all layout associations
+if ( iCloudInfo.Count ()!= 0)//check for the empty cloud view
-		if (iCloudInfo.Count() != 0)//check for the empty cloud view
+{
-			{
+UpdateLayout();
-			UpdateLayout();
+FetchAttributeFromCacheL();
-			FetchAttributeFromCacheL();
+//generate row structures and draw rows on screen
-			//generate row structures and draw rows on screen
+UpdateRowDataL ();
-			UpdateRowDataL();
+InitPhysicsL();
-			InitPhysicsL();
+}
-			}
+}
-		}
 }
 // ---------------------------------------------------------------------------
 // InitPhysicsL()
 // ---------------------------------------------------------------------------
 else
 {
 return EFalse;
 }
 }
 // ---------------------------------------------------------------------------
 // TimerCompleteL()
 // ---------------------------------------------------------------------------
 //
 void CGlxCloudViewControl::TimerCompleteL()
 ((focussedItemRect.iBr.iY - focussedItemRect.iTl.iY )/2);
 TRect rect;
 AknLayoutUtils::LayoutMetricsRect(AknLayoutUtils::EMainPane, rect);
-//only if not dragged and physics hasnt started
+if(!iPhysicsStarted)//only if 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 75	01504893d9cb
parent 64	34937ec34dac