/*

* Copyright (c) 2008-2009 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:    Cloud View control class 

 *

*/

// INCLUDE FILES

#include "glxcloudviewcontrol.h" //class header

//AlfT headers

#include <alf/alfanchorlayout.h> // For CAlfAnchorLayout 

#include <alf/alfviewportlayout.h> // For CAlfViewPortLayout

#include <touchfeedback.h>  // For MTouchFeedback

#include <alf/alftextstyle.h>  // For CAlfTextStyle

#include <alf/alftextvisual.h> // For CAlfTextVisual

#include <alf/alftransformation.h>

#include <alf/alfwidgetcontrol.h> // For CAlfWidgetControl

#include <alf/alfroster.h> // For CalfRoster

#include <alf/alfdisplay.h> // For CAlfDisplay

#include <alf/ialfscrollbarmodel.h> // For alfScrollbar model

#include <aknlayoutscalable_uiaccel.cdl.h>

#include <glxuiutility.h>

#include <glxgeneraluiutilities.h>

#include <glxuistd.h>

//AlfT

#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"

//Constants

const TInt KPrimaryFontSize = 21;

//Font sizes

const TInt KFontSmallest = 28;

const TInt KFontSmaller = 32;

const TInt KFontMedium = 36;

const TInt KFontLarger = 40;

const TInt KFontLargest = 44;

const TInt KRowHeight = 72;

const TInt KLeftMargin = 10;

const TInt KNumMinRowSpace = 2;

const TInt KColSpace = 20;

const TInt KRightmargin = 20;

const TInt KMinTagSize = 77;

const TInt KTagScreenHeight = 460;

const TInt KDragHoldTime = 500;

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

// 

CGlxCloudViewControl *CGlxCloudViewControl::NewL(CAlfDisplay& aDisplay,

        CAlfEnv &aEnv, MGlxMediaList& aMediaList, const TDesC& aEmptyText,

        MGlxCloudViewMskObserver& aObserver,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent

        ,CAlfAnchorLayout *aAnchorLayout,MGlxCloudViewLayoutObserver& aLayoutObserver)

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::NewL");

    CGlxCloudViewControl *self = CGlxCloudViewControl::NewLC (aDisplay, aEnv,

            aMediaList, aEmptyText,aObserver,aObserverEnterKeyEvent,aAnchorLayout,aLayoutObserver);

    CleanupStack::Pop (self);

    return self;

    }

// ---------------------------------------------------------------------------

// Two-phased constructor.

// ---------------------------------------------------------------------------

// 

CGlxCloudViewControl *CGlxCloudViewControl::NewLC(CAlfDisplay& aDisplay,

        CAlfEnv &aEnv, MGlxMediaList& aMediaList, const TDesC& aEmptyText,

        MGlxCloudViewMskObserver& aObserver,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent

        ,CAlfAnchorLayout *aAnchorLayout,MGlxCloudViewLayoutObserver& aLayoutObserver)

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::NewLC");

    CGlxCloudViewControl *self = new(ELeave)CGlxCloudViewControl(aEnv,aMediaList,aObserver

            ,aObserverEnterKeyEvent,aLayoutObserver);

    CleanupStack::PushL (self);

    self->ConstructL (aEmptyText,aDisplay,aAnchorLayout);

    return self;

    }

// ---------------------------------------------------------------------------

// Default C++ Constructor

// ---------------------------------------------------------------------------

//

CGlxCloudViewControl::CGlxCloudViewControl(CAlfEnv &aEnv, MGlxMediaList& aMediaList,

        MGlxCloudViewMskObserver& aObserver,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent

        ,MGlxCloudViewLayoutObserver& aLayoutObserver):

        iEnv(aEnv),  iMediaList(aMediaList), iObserver(aObserver)

        ,iObserverEnterKeyEvent(aObserverEnterKeyEvent),iLayoutObserver(aLayoutObserver)

        {

        TRACER("GLX_CLOUD::CGlxCloudViewControl::CGlxCloudViewControl");

        //added for scrollbar widget implementation

        iScrollEventData.mChangedMask = 0;

        iScrollEventData.mViewStartPos = 0;

        iScrollEventData.mSpan = 0;

        iScrollEventData.mViewLength = 0;    

        }

// ---------------------------------------------------------------------------

//ConstructL()

// ---------------------------------------------------------------------------

//

void CGlxCloudViewControl::ConstructL(const TDesC& aEmptyText,CAlfDisplay& aDisplay

        ,CAlfAnchorLayout *aAnchorLayout)

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::ConstructL");

    iUiUtility = CGlxUiUtility::UtilityL ();

    CAlfControl::ConstructL(iEnv);

    BindDisplay (aDisplay);

    //Initializing data for cloud view display 

    iFocusRowIndex = 0; //initially focus row will be zero

    iEmptyText = aEmptyText.AllocL();

    TRect rect;

    AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);

    iScreenHeight = rect.Height ();

    iParentLayout = CAlfLayout::AddNewL(*this, aAnchorLayout);                    

    iTagScreenWidth = rect.Width() - iScrollPaneHandle.iW - KRightmargin;

    if (GlxGeneralUiUtilities::IsLandscape())

        {	

        iTagScreenHeight = rect.Height();	

        }

    else 

        {

        iTagScreenHeight = KTagScreenHeight;

        }                                  

    iViewPortLayout = CAlfViewportLayout::AddNewL(*this, iParentLayout);      

    iLayout=CAlfAnchorLayout::AddNewL (*this,iViewPortLayout);

    iLayout->SetFlags ( EAlfVisualFlagLayoutUpdateNotification); //to get screen change notification

    iViewPortLayout->SetClipping(ETrue); 

    // Set the attribute context

    iAttributeContext = CGlxDefaultAttributeContext::NewL ();

    iAttributeContext->AddAttributeL (KMPXMediaGeneralTitle);

    iAttributeContext->AddAttributeL (KMPXMediaGeneralCount);

    iAttributeContext->SetRangeOffsets( 0, KMaxTInt / 2 );

    iMediaList.AddContextL ( iAttributeContext, KGlxFetchContextPriorityCloudView ); //highest one to use 0 or 1

    iMediaList.AddMediaListObserverL ( this); //make this control as medialist observer

    TInt listCount = iMediaList.Count();

    GLX_LOG_INFO1("GLX_CLOUD ::CGlxCloudViewControl::ConstructL MedialistCount  %d ",

            listCount);

    //Display Empty Cloud View if no tags exists and if the navigation is backwards

    //Since in backward navigation the callback HandlePopulatedL() does not come

    if ( listCount ==0 && (iUiUtility->ViewNavigationDirection ()== EGlxNavigationBackwards) ) 

        {

        DisplayEmptyCloudViewL();

        }

    else	//Setting focus on the 1 st Media List item

        {

        //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(); 

    }

// ---------------------------------------------------------------------------

//VisualLayoutUpdated()

// ---------------------------------------------------------------------------

//

void CGlxCloudViewControl::VisualLayoutUpdated(CAlfVisual &/* aVisual*/)

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::VisualLayoutUpdated");

    TRect rect;

    AknLayoutUtils::LayoutMetricsRect (AknLayoutUtils::EMainPane, rect);

    if ( (rect.Width() != iTagScreenWidth) && ( rect.Height () != iScreenHeight))

        {

        //set the new screen dimensions

        UpdateLayoutL();

        }

    }

// --------------------------------------------------------------------------- 

// Destructor

// --------------------------------------------------------------------------- 

//

CGlxCloudViewControl::~CGlxCloudViewControl()

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::~CGlxCloudViewControl");

    iCloudInfo.Close ();

    iLabels.Close();

    iMediaList.RemoveContext (iAttributeContext);

    iMediaList.RemoveMediaListObserver (this);

    delete iAttributeContext;

    /*if ( iBubbleContainer )

		{

		iBubbleContainer->SetHost (NULL);

		delete iBubbleContainer;

		}*/

    if ( iUiUtility )

        {

        iUiUtility->Close ();

        }	

    delete iEmptyText;

    }

// --------------------------------------------------------------------------- 

// LayoutVisibleRows()

// --------------------------------------------------------------------------- 

//

TInt CGlxCloudViewControl::LayoutVisibleRows(TPoint aStartPoint,TInt aRowStartIndex

        , TInt aRowEndIndex)

    {

    TRACER("GLX_CLOUD::CGlxCloudViewControl::DrawRow");

    TSize vsize;

    TPoint tl, br;

    tl = aStartPoint;

    br.iY = tl.iY + KRowHeight;

    //drawing in reverse for arabic hebrew support

    if ( GlxGeneralUiUtilities::LayoutIsMirrored ())

        {

        br.iX =  aStartPoint.iX; 

        const TInt KMaxScreenWidth = iTagScreenWidth - iScrollPaneHandle.iW;

        //Set the positions of tags in a row.

        for (TInt j = aRowStartIndex; j <= aRowEndIndex; j++)

            {

            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 -= (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));

            br.iX -= (vsize.iWidth + KColSpace); 

            iLayoutIndex += 1;

            }

        }

    else

        {

        const TInt KMaxScreenWidth = iTagScreenWidth - iScrollPaneHandle.iW;

        for (TInt j = aRowStartIndex; j <= aRowEndIndex; j++)

            {

            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 += 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));

            tl.iX = br.iX;

            iLayoutIndex += 1;

            }

        }

    return 0;

    }

// --------------------------------------------------------------------------- 

// LayoutVisibleArea()

// 

// ---------------------------------------------------------------------------

void 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

    TPoint startpoint;

    // arabic hebrew change

    //If the layout is arabic hebrew then start positioning of tags from end

    if ( GlxGeneralUiUtilities::LayoutIsMirrored ())

        {

        startpoint.iX = iTagScreenWidth - KRightmargin;        

        }

    //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 ());

    for (TInt j = 0; j <= iEndRowIndex; 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.	

    if( totalHeight > iTagScreenHeight )

        {

        iViewPortLayout->SetVirtualSize(TAlfRealSize(iTagScreenWidth,totalHeight ),0); 

        iViewPortVirtualSize.iHeight = totalHeight;

        }

    else

        {

        iViewPortLayout->SetVirtualSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight ),0);

        iViewPortVirtualSize.iHeight = iTagScreenHeight;

        }    

    iViewPortVirtualSize.iWidth = iTagScreenWidth;

    iViewPortLayout->SetViewportSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight), 0);

    iViewPortLayout->SetSize(TAlfRealSize(iTagScreenWidth,iTagScreenHeight), 0);

    iViewPortSize.iWidth = iTagScreenWidth;

    iViewPortSize.iHeight = iTagScreenHeight;	

    iViewPortLayout->SetViewportPos(TAlfRealPoint(0, 0),1000);

    iViewPortPosition.iX =0;

    iViewPortPosition.iY =0;

    iScrollEventData.mSpan = iViewPortVirtualSize.iHeight ;

    iScrollEventData.mViewLength = iViewPortSize.iHeight;

    if(iScrollBarWidget)

        {

        ((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");

    //check if key inputs needs handling

    TBool consumed = EFalse;

    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 ()&& 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 );

                consumed= ETrue;

                }

                break;

            case EKeyUpArrow:

                {             

                if(iCloudInfo.Count() >1 )

                    {

                    HandleKeyUpL ();

                    consumed = ETrue;

                    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

                    {

                    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();

                        }