diff -r 8e5f6eea9c9f -r 5b3385a43d68 photosgallery/viewframework/views/cloudview/inc/glxcloudviewcontrol.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/photosgallery/viewframework/views/cloudview/inc/glxcloudviewcontrol.h Wed Sep 01 12:33:26 2010 +0100 @@ -0,0 +1,654 @@ +/* +* 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 +#include +#include +#include + +//use includes +#include +#include "glxcontainerinfobubble.h" +#include "glxbubbletimer.h" //for timer functionality +#include "glxcloudinfo.h" +#include + +#include +#include //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 ETrue if the event can be processed. Otherwise EFalse. + */ + 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 . 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(); + + + /** + * Set the middle point of the infobuble + **/ + void SetBubleMidPoint(TPoint& aMidPoint); + + /** + * Move the viewport up depending on the condition + * + **/ + void MoveUpIfRequired(); + + /** + * Move the viewport down depending on the condition + **/ + void MoveDownIfRequired(); + + /** + * calculate the mid point of the bubble + **/ + void CalculateBubleMidPoint(); + +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& 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& 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; + + //Parent layout for viewportayout + CAlfAnchorLayout* iViewPortParentLayout; + + //ViewPortLayout + CAlfViewportLayout* iViewPortLayout; + + //Anchor layout for tags + CAlfAnchorLayout *iLayout; + + //medialist not owned + MGlxMediaList& iMediaList; + + //Array of Cloud visuals. + RPointerArray iLabels; + + // Array for information of cloud visuals. + RArray iCloudInfo; + + //Ui Utility + CGlxUiUtility* iUiUtility; + + // Visual for empty string display + CAlfTextVisual *iEmptyString; + + // FocusIndex keeps track of the focussed item + TInt iScrollDirection; + + // FocusIndex keeps track of the focussed row + TInt iFocusRowIndex; + + // EndRowindex keeps track of the end row + TInt iEndRowIndex; + + //keeps track of the end row + TInt iLayoutIndex; + + // Fetch context for list item attributes + CGlxDefaultAttributeContext* iAttributeContext; + + // for storing screen height + TInt iScreenHeight; + + // List event observer + MGlxCloudViewMskObserver& iObserver; + + // stores the text for empty view + HBufC* iEmptyText; + + //Viewport position + TAlfRealPoint iViewPortPosition; + + //observer to inform "open" command cloudviewimp class so that it opens the next view + MGlxEnterKeyEventObserver& iObserverEnterKeyEvent; + + //observer to inform command cloudviewimp class that layout is changed + MGlxCloudViewLayoutObserver& iLayoutObserver; + //Viewport size + TAlfRealSize iViewPortSize; + + //Viewport virtual size + TAlfRealSize iViewPortVirtualSize; + + //Width of the screen in which is available for tags to fit in + TInt iTagScreenWidth; + + //Height of the screen in which is available for tags to fit in + TInt iTagScreenHeight; + + //Touch feedback instance + MTouchFeedback* iTouchFeedback; + + //parent layout for all the layout's + CAlfLayout* iParentLayout; + + //data structure for scrollbar + ScrollModelChangedEventData iScrollEventData; + + //scrollbar element + IAlfWidgetEventHandler *iScrollbarElement; + + //scrollbar widget + IAlfScrollBarWidget *iScrollBarWidget; + + //direction of dragging + TInt iIsDragging; + + TAknWindowLineLayout iScrollPaneHandle; + + //View position w.r.t. viewportposition + (screeenwidth/2, screenheight/2) + TPoint iViewPosition; + + //determins whether dragging is currently going on or not + TBool iDragging; + + //Notes the time before dragging, when pointer down event happens + TTime iStartTime; + + //Notes the last pointer co-ordinates + TPoint iPrev; + + //The pointer coordinates before dragging when pointerDown event happened + TPoint iStart; + + //owning - Physics library object + CAknPhysics* iPhysics; + + //boolean to check whether physics emulation is going on or not + TBool iPhysicsStarted; + + //boolean to check if dragging really happened + TBool iViewDragged; + + /**variable used for providing delay */ + CGlxBubbleTimer* iTimer; + + //Alfcontrol to draw grid layout for handling floating bar menu items + CGlxTagsContextMenuControl* iTagsContextMenuControl; + + /**flag for Timer completion */ + TBool iTimerComplete; + + /**flag to identify the next down event */ + TBool iDownEventReceived; + }; + +#endif // C_GLXCLOUDVIEWCONTROL_H +