/*

* 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:    Carousel control class 

 *

*/

#ifndef C_GLXCLOUDVIEWCONTROL_H

#define C_GLXCLOUDVIEWCONTROL_H

// INCLUDES

#include <alf/ialfwidgeteventhandler.h>

#include <osn/ustring.h>

#include <alf/alfscrollevents.h>

#include <alf/ialfscrollbarwidget.h>

//use includes

#include <mglxmedialistobserver.h> 

#include "glxcontainerinfobubble.h"

#include "glxbubbletimer.h" //for timer functionality

#include "glxcloudinfo.h"

#include <alf/alfeventhandler.h>

#include <AknLayout2Def.h>

#include <aknphysicsobserveriface.h> //Physics - Kinetic scrolling listener

using namespace Alf;

// FORWARD DECLARATION

class MMPXViewUtility;

class MGlxUiCommandHandler;

class CAlfAnchorLayout;

class CAlfViewportLayout;

class CAlfControl;

class MGlxMediaList;

class CGlxDefaultAttributeContext;

class MMPXCollectionUtility;

class CGlxContainerInfoBubble;

class MTouchFeedback;

class MGlxCloudViewMskObserver;

class MGlxEnterKeyEventObserver;

class MGlxCloudViewLayoutObserver;

class CAknPhysics;

class CGlxTagsContextMenuControl ;

class MGlxItemMenuObserver;

enum TTagEventType

    {

    ECustomEventFocusDragScroll

    };

/**

 *  CGlxCloudViewControl

 *  Alf-based Cloud control

 *  Creates a weighted list of items based on the associations.

 * 

 */

class CGlxCloudViewControl : public CAlfControl,public IAlfWidgetEventHandler

                            ,public MGlxMediaListObserver

                            ,public MAknPhysicsObserver

                            ,public MGlxTimerNotifier

	{

public:

	/** 	

	 *  Perform the two phase construction

	 *  @param aEnv - Env Variable of Alf

	 *  @param aEmptyText - Specifies the text for the empty list

	 *  @param aMediaList - medialist from which attributes will be fetched

	 *  @return Pointer to newly created object

	 */

	static CGlxCloudViewControl *NewL(CAlfDisplay& aDisplay, CAlfEnv &aEnv,

			MGlxMediaList& aMediaList, const TDesC& aEmptyText

			,MGlxCloudViewMskObserver& aObserver

			,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent,

			CAlfAnchorLayout *aAnchorLayout,

			MGlxCloudViewLayoutObserver& aLayoutObserver

			,MGlxItemMenuObserver& aItemMenuObserver);

	/** 	

	 *  Perform the two phase construction

	 *  @param aEnv - Env Variable of Alf

	 *  @param aEmptyText - Specifies the text for the empty list

	 *  @param aMediaList - medialist from which attributes will be fetched

	 *  @return Pointer to newly created object

	 */

	static CGlxCloudViewControl *NewLC(CAlfDisplay& aDisplay, CAlfEnv &aEnv,

			MGlxMediaList& aMediaList, const TDesC& aEmptyText

			,MGlxCloudViewMskObserver& aObserver

			,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent,

			CAlfAnchorLayout *aAnchorLayout,MGlxCloudViewLayoutObserver& aLayoutObserver

			,MGlxItemMenuObserver& aItemMenuObserver);

	/**

	 * Destroy the object and release all memory objects

	 */

	~CGlxCloudViewControl();

public:

    /**

    * Used to identify event handlers that are capable of handling

    * a specified key or custom event. Pointer event handlers cannot be

    * identified directly, since they are dependent on the presentation.

    * Therefore, pointer event handlers should be associated with

    * a custom event ID that can be used to simulate the actual pointer event.

    *

    * @since S60 ?S60_version

    * @param aEvent The event.

    * @return <code>ETrue</code> if the event can be processed. Otherwise <code>EFalse</code>.

    */

    bool accept ( CAlfWidgetControl& aControl, const TAlfEvent& aEvent ) const;

    /**

    * @see IAlfWidgetEventHandler

    */

    virtual AlfEventStatus offerEvent ( CAlfWidgetControl& aControl, const TAlfEvent& aEvent );

    /**

    * Sets AlfWidgetEventHandlerInitData to event handler.

    *

    * @param aData A data structure which contains for example id of the event

    * handler.

    */

    virtual void setEventHandlerData( const AlfWidgetEventHandlerInitData& /*aData*/ )

        {

        }

    /**

    * Defines the widget states, where the event handler is active.

    * By default, if this method is not called, the event handler is expected

    * to be active in all states.

    *

    * @param aStates A bitmask defining the widget states, where the event

    * handler is active. The low 16 bits are reserved for the states

    * defined by the framework in <TODO: add reference>. The high 16 bits are

    * available for states defined by the client code.

    */

    void setActiveStates ( unsigned int aStates );

    IAlfInterfaceBase* makeInterface ( const IfId& aType );

    /**

    * Returns the type of EventHandler. 

    * @see IAlfWidgetEventHandler::AlfEventHandlerType

    *

    * @return The type of event handler.

    */

    AlfEventHandlerType eventHandlerType();

    /**

    * Returns information about the phase in the event handling cycle in

    * which the event hadler will be executed.

    * @see IAlfWidgetEventHandler::AlfEventHandlerExecutionPhase

    *

    * @return Event handler execution phase.

    */

    AlfEventHandlerExecutionPhase eventExecutionPhase();

    /**

    * Returns AlfWidgetEventHandlerInitData.

    *

    * @return  A pointer to AlfWidgetEventHandlerInitData structure which contains

    * for example id of the event handler.

    */

    virtual AlfWidgetEventHandlerInitData* eventHandlerData()

        {

        return NULL;

        }

    /**

    * initialises data for scrollbar model

    * @param scrollbar widget

    */

    void InitializeScrollBar(IAlfScrollBarWidget* aScrollBarWidget);

    /**

     * Hides/shows the grid layout

     * @param aShow - Show value

     */

    void ShowContextItemMenuL(TBool aShow);

public://MGlxTimernotifier

    /**

     * Virtual Function from MGlxTimernotifier

     */

    void TimerCompleteL();

private:

	/** 	

	 *  Perform the two phase construction

	 *  @param  aEvent - key Event to handle

	 *  @return EKeyWasConsumed if key event is processed,

	 *         otherwise EKeyWasNotConsumed

	 */

	TBool OfferEventL(const TAlfEvent &aEvent);

	/** 	

	 *  @function HandleKeyUp

	 * 

	 */

	void HandleKeyUpL();

	/** 	

	 *  @since S60 3.2

	 * 

	 */

	void HandleLayoutFocusChange();

	/** 	

	 *  @since S60 3.2

	 * 

	 */

	void HandleKeyDownL();

	/** 	

	/** 	

	 *  @since S60 3.2

	 * 

	 */

	void UpdateLayout();

	/**     

	 * Displays the empty cloud view when there are no tags to diplay

	 */

	void DisplayEmptyCloudViewL();

	/** 	

	 *  constructor	

	 *  @param aEnv - Env Variable of Alf

	 *  @param aMediaList - medialist from which attributes will be fetched

	 *  @param aMediaList - medialist from which attributes will be fetched

	 */

	CGlxCloudViewControl(CAlfEnv &aEnv,

		MGlxMediaList& aMediaList,MGlxCloudViewMskObserver& aObserver,MGlxEnterKeyEventObserver& aObserverEnterKeyEvent

		,MGlxCloudViewLayoutObserver& aLayoutObserver);

	/** 	

	 *  Perform the two phase construction

	 *  @param  aStartPoint - start point for draeing the row

	 *  @param  aRowHeight - height of the row

	 *  @param  aRowStartIndex - start index of row

	 *  @param  aRowEndIndex- Index upto which items will be drawn

	 *  @return 

	 */

	TInt LayoutVisibleRows(TPoint aStartPoint,TInt aRowStartIndex, TInt

    	aRowEndIndex);

	/** 	

	 *  Perform the two phase construction

	 *  @param  aStartRowIndex - row index 

	 *  @return 

	 */

	void LayoutVisibleArea(/*TInt aStartRowIndex*/);

	/** 	

	 *  returns the rownumber for a particular index.

	 *  @param  aItemIndex - row index 

	 *  @return rownum

	 */

	TInt RowNumber(TInt aItemIndex) const;

	/** 	

	 *  Updates the focus whenever there is a change in focus of the item.

	 */

	void FocusUpdate();

	/** 

 	 *  Perform the second phase of two phase construction

	 *  @param aEmptyText - Specifies the text for the empty list

	 */

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

	        CAlfAnchorLayout *aAnchorLayout,MGlxItemMenuObserver& aItemMenuObserver);

	/** 

	 * Updates Row Structure 

	 * 

	 */

	void UpdateRowDataL();

	/** 

	 * Returns maximum value of usage Count

	 * 

	 */

    TInt MaxUsageCount();

	/** 

	 *  @param aIndex - Media List Index

	 * Returns usage count for a given index

	 * */

	TInt UsageCount(TInt aIndex);

	/** 

	 *  @function FetchAttributeFromCacheL

	 * 

	 * */

	void FetchAttributeFromCacheL();

	 /** 

	 * Utility method to add a TGlxCloudInfo struct into iCloudInfo array 

	 * @param aCloudInfo The next item to add into iCloudinfo

	 * @param aRowHeight value of aCloudInfo.iRowHeight

	 * @param aStartIndex value of aCloudInfo.iStartIndex

	 * @param aEndIndex value of aCloudInfo.iEndIndex

	 * */

	 void AppendToCloudArrayL( TGlxCloudInfo& aCloudInfo, 

	     const TInt& aStartIndex, const TInt& aEndIndex );

private: // from MAknPhysicsObserver

	 /*

	  * Observer to get notified about new position to be displayed in

	  * @param aNewPosition The new point where the virtual port should start from 

	  * @param aDrawNow value to determine whether to draw at new position or not

	  * @param aFags Special value (not used here)

	  */

    void ViewPositionChanged( const TPoint& aNewPosition, TBool aDrawNow, TUint /*aFlags*/ );

    /*

     * Obsrever to get notified whether the physics emulation ended

     */

    void PhysicEmulationEnded();

    /*

     * Observer callback used by CAknPhysics to know our current viewposition

     * (which is with reference to displayable viewportposition + screeenheight/2) 

     * Returns current viewposition point  

     */

    TPoint ViewPosition() const;

private:

    TBool IsLandscape();

    /*

     * Initializes the physcs library with total size, displayable size, etc 

     */

    void InitPhysicsL();

    /** 

	 * Sets focused item color

	 **/

    void SetFocusColor();

   /** 

	 * Move the viewport up depending on the condition

	 *

	 **/ 

    void MoveUpIfRequired();

    /** 

	 * Move the viewport down depending on the condition

	 **/  

    void MoveDownIfRequired();

public:

	void HandleItemAddedL(TInt aStartIndex, TInt aEndIndex,

        MGlxMediaList* aList);

	/**

	 *  Notification that media object is now available for an item 

	 *  @param Index of the item 

	 *  @param aList List that this callback relates to

	 */

	void HandleMediaL(TInt aListIndex, MGlxMediaList* aList);

	/**

	 *  Notification that media item was removed from the list

	 *  @param aStartIndex First item that was removed 

	 *  @param aEndIndex Last item that was removed

	 *  @param aList List that this callback relates to

	 */

	void HandleItemRemovedL(TInt aStartIndex, TInt aEndIndex,

			MGlxMediaList* aList);

	/**

	 *  Notification that media item was changed

	 *  @param aItemIndexes Indexes of items that were changed

	 *  @param aList List that this callback relates to

	 */

	void HandleItemModifiedL(const RArray<TInt>& aItemIndexes,

			MGlxMediaList* aList);

	/**

	 *  Notification that an attribute is available

	 *  @param aItemIndex Index of the for which the thumbnail is available

	 *  @param aAttributes Array of attributes that have become available

	 *  @param aList List that this callback relates to 

	 */

	void HandleAttributesAvailableL(TInt aItemIndex,

			const RArray<TMPXAttribute>& aAttributes, MGlxMediaList* aList);

	/**

	 *  Notification that focus has moved

	 *  @param aType the direction of the focus change

	 *  @param aNewIndex the new index after the focus change

	 *  @param aOldIndex the old index before the focus change

	 *  @param aList List that this callback relates to

	 */

	void HandleFocusChangedL(NGlxListDefs::TFocusChangeType aType, TInt aNewIndex,

			TInt aOldIndex, MGlxMediaList* aList);

	/**

	 *  Notification that an item has been selected/deselected

	 *  @param aIndex Index of the item that has been selected/deselected

	 *  @param aSelected Boolean to indicate selection/deselection

	 *  @param aList List that the selection relates to

	 */

	void HandleItemSelectedL(TInt aIndex, TBool aSelected, MGlxMediaList* aList);

	/**

	 *  Notification from the collection.  E.g. Items added/modified/deleted and progress notifications

	 *  @param aMessage Message notification from the collection

	 *  @param aList List that the notification relates to

	 */

	void HandleMessageL(const CMPXMessage& aMessage, MGlxMediaList* aList);

	/**

	     *  Notification from the collection that the medialist is populated	     

	     *  @param aList List that the notification relates to

	     */

	void HandlePopulatedL(MGlxMediaList* /*aList*/);

	/**

	 *  Notification from the collection.  E.g. Items added/modified/deleted and progress notifications

	 *  @param aIndex Index of the item for which property needs to be set

	 *  @param aScale Scale parameter to decide the properties of item

	 */

	void SetPropertiesL(TInt aIndex, TInt aScale);

	/**

	 *  Called whenever the resolution is changed

	 */

	void VisualLayoutUpdated(CAlfVisual & aVisual);

private:

	 /**

	 * Handle the pointer event

	 * @param aEvent event describing the gesture 

	 */

	TBool HandlePointerEventL( const TAlfEvent &aEvent );

	/**

	 *  Handles the drag events

	 *  @param pointer event generated because of drag

	 *  @return returns whether the pointer event is consumed or not

	 */

	TBool HandleDragL(const TPointerEvent& aPointerEvent);

	/**

	 *  checks the visual on which the drag event is generated

	 *  @param position where the drag event has ocuured

	 *  @return the index of the visual that needs to be focused 

	 */

	TInt GetAbsoluteIndex(const TPoint& aPosition);

	/**

	 *  Checks which visual lies below/above the focused item and sets the focus

	 *  @param the row number that needs to be checked for getting the overlaping visual

	 */	

	void SetRelativeFocusL(TInt aRowNumber);

     /**

	 *  Updates layout when orientation is changed

	 */

	void UpdateLayoutL(); 

private:

    /**

     *  Send the scroll custom event to scrollbar widget

     */

    void Scroll();

    /**

     *  decide the scrollbar new position

     *  @param number of steps which is used to determine the amout to be scrolled

     */

    void UpdateScrollBar(TInt aNumberOfSteps, TBool aDiff = ETrue);

    /**

     *  Display the scrollbar only if there are items

     *  @param visibility

     */

    void DisplayScrollBar();

private:

	// The Alf Environment 

	CAlfEnv& iEnv;