diff -r 000000000000 -r 2f259fa3e83a uifw/EikStd/coctlinc/aknedwinphysicshandler.h --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/uifw/EikStd/coctlinc/aknedwinphysicshandler.h Tue Feb 02 01:00:49 2010 +0200 @@ -0,0 +1,353 @@ +/* +* Copyright (c) 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: EikEdwin physics handler +* +*/ + +#ifndef C_AKNEDWINPHYSICSHANDLER_H +#define C_AKNEDWINPHYSICSHANDLER_H + + +#include +#include + +class CAknPhysics; +class CEikEdwin; + +/** + * EikEdwin physics handler. + * + * @lib eikcoctl + * @since S60 v5.2 + */ +NONSHARABLE_CLASS( CAknEdwinPhysicsHandler ) : public CBase, + public MAknPhysicsObserver + { + +public: + + /** + * Two-phased constructor. + */ + static CAknEdwinPhysicsHandler* NewL( CEikEdwin& aEdwin ); + + /** + * Two-phased constructor. + */ + static CAknEdwinPhysicsHandler* NewLC( CEikEdwin& aEdwin ); + /** + * Destructor. + */ + virtual ~CAknEdwinPhysicsHandler(); + +public: + + /** + * Sets view rect. + * + * @param aRect New view rect. + */ + void SetViewRect( const TRect& aRect ); + + /** + * Initializes physics. + */ + void InitPhysicsL(); + + /** + * Moves the scroll index. + * + * @param aPixelsToMove Number of pixels to move. + */ + void MoveScrollIndex( TInt aPixelsToMove ); + + /** + * Returns ETrue if flicking or bouncing is ongoing. + * + * @return ETrue if flicking or bouncing is ongoing. + */ + TBool EmulationOngoing(); + + /** + * Returns drag threshold. + * + * @return drag threshold. + */ + TInt DragThreshold() const; + + /** + * Initialises scrolling. + * + * @param aStartPosition Start position of dragging. + */ + void InitKineticScrolling( const TPoint& aStartPosition ); + + /** + * Handles kinetic scrolling. + * + * @param aPointerEvent Pointer event to handle. + * @param aShouldReturn Set to ETrue if we should return from + * CEikEdwin's HandlePointerEventL after + * call to this function. + */ + void HandleKineticScrolling( const TPointerEvent& aPointerEvent, + TBool& aShouldReturn ); + + /** + * Returns ETrue if selection is started. + * + * @return ETrue if selection is started. + */ + TBool SelectionStarted() const; + + /** + * Returns ETrue if dragging is started. + * + * @return ETrue if dragging is started. + */ + TBool DraggingStarted() const; + + /** + * Returns ETrue if drag threshold is exceeded. + * + * @param aCurrentPosition Current position of dragging. + * @return ETrue if drag threshold is exceeded. + */ + TBool DragThresholdExceeded( const TPoint& aCurrentPosition ) const; + + +public: // From base class MAknPhysicsObserver. + + /** + * Called when view position changes. + * + * @param aNewPosition The new position of the view. + * @param aDrawNow @c ETrue if the screen is to be redrawn, + * otherwise @c EFalse. + * @param aFlags Additional flags, not used currently. + */ + virtual void ViewPositionChanged( const TPoint& aNewPosition, + TBool aDrawNow = ETrue, + TUint aFlags = 0 ); + + /** + * Called when emulation has ended. + */ + virtual void PhysicEmulationEnded(); + + /** + * Returns the observer's view position. + * + * @return Physics observer's view position. + */ + virtual TPoint ViewPosition() const; + +private: + + /** + * C++ constructor. + */ + CAknEdwinPhysicsHandler( CEikEdwin& aEdwin ); + + /** + * Symbian second-phase constructor. + */ + void ConstructL(); + + /** + * Scrolls view to correct position. + * + * @param aAllowBounce If ETrue, it is possible to scroll + * content out of borders. + */ + void ScrollView( TBool aAllowBounce ); + + /** + * Used to scroll view normally (without bounce). + * Called from ScrollView. + * + * @param aPixelsToScroll Number of pixels to scroll + * @param aAllowBounce If this parameter is EFalse and end or + * beginning of content is exceeded, this + * function doesn't scroll over the border. + * If this parameter is ETrue, it is possible + * to scroll out of borders. + */ + void ScrollStep( TInt aPixelsToScroll, TBool aAllowBounce ); + + /** + * Used to scroll view with bounce (there can be empty + * space above or below the content). + * Called from ScrollView. + * + * @param aPixelsToScroll Number of pixels to scroll + * @param aRestOfPixels Number of pixels not scrolled + */ + void ScrollStepWithBounce( TInt aPixelsToScroll, TInt& aRestOfPixels ); + + /** + * Moves world index. + * + * @param aDelta Number of pixels to move. + */ + void MoveWorldIndex( TInt aDelta ); + + /** + * Scrolls rest of pixels. This function is used + * to scroll rest of pixels when end or beginning + * of content has exceeded and bounce starts. + * + * @param aRestOfPixels Number of pixels to scroll. + */ + void ScrollRestOfPixels( TInt aRestOfPixels ); + + /** + * Stops physics. + */ + void StopPhysics(); + + /** + * Blocks/unblocks pointer events. + * + * @param aBlocked Tells if events should be blocked or not. + */ + void BlockEvents( TBool aBlocked ); + + /** + * Returns ETrue if flicking is ongoing. + */ + TBool IsFlicking() const; + + /** + * Returns ETrue if bouncing is ongoing. + */ + TBool IsBouncing() const; + + /** + * Initialises bounce. + * + * @param aBounceDown ETrue if bouncing down. + */ + void InitBounce( TBool aBounceDown ); + + /** + * Handles the pointer event received by edwin. + * + * @param aPointerEvent Pointer event to handle. + */ + void HandlePointerEvent( const TPointerEvent& aPointerEvent ); + + +private: // data + + /** + * Physics handler flags + */ + enum TAknEdwinPhysicsHandlerFlags + { + EFlagUpdatingView, // View updating ongoing + EFlagBouncingUp, // Content bouncing up, empty space below content + EFlagBouncingDown, // Content bouncing down, empty space above content + EFlagDraggingAllowed // Dragging allowed + }; + + /** + * Scroll index. + */ + TInt iWorldIndex; + + /** + * Previous scroll index. + */ + TInt iPreviousWorldIndex; + + /** + * Previous pointer position. + */ + TPoint iPrevPosition; + + /** + * View rect. + */ + TRect iViewRect; + + /** + * ETrue if pointer events are blocked. + */ + TBool iEventsBlocked; + + /** + * If set to ETrue, first pointer down event unblocks pointer events. + */ + TBool iEventUnblockingAllowed; + + /** + * ETrue if drag threshold exceeded. + */ + TBool iDragThresholdExceeded; + + /** + * Pointer down start time. + */ + TTime iStartTime; + + /** + * Physics. + * Own. + */ + CAknPhysics *iPhysics; + + /** + * Physics handler flags. + */ + TBitFlags iFlags; + + /** + * Pointer to edwin. + * Not own. + */ + CEikEdwin& iEdwin; + + /** + * Position where bouncing down started. + */ + TInt iBounceDownIndex; + + /** + * Position where bouncing up started. + */ + TInt iBounceUpIndex; + + /** + * Previous Y-coordinate. + */ + TInt iPreviousYCoordinate; + + /** + * ETrue, if text selection has been started. + */ + TBool iSelectionStarted; + + /** + * ETrue, if dragging of content has been started. + */ + TBool iDraggingStarted; + + /** + * Start position of drag. + */ + TPoint iStartPosition; + }; + +#endif // C_AKNEDWINPHYSICSHANDLER_H