X-Git-Url: http://review.tizen.org/git/?p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git;a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Fdecorator%2Ftext-decorator.cpp;h=2e8570faa1eeead7cf5720bcb1732615bda09b15;hp=32e3becd14020deb9c8b53dceee3550f510d3ba2;hb=005f449f3648e36e0cc997735b58b0ebb7a6390b;hpb=caa46059c4cd1c18f380b81487f83a395846e5df diff --git a/dali-toolkit/internal/text/decorator/text-decorator.cpp b/dali-toolkit/internal/text/decorator/text-decorator.cpp index 32e3bec..2e8570f 100644 --- a/dali-toolkit/internal/text/decorator/text-decorator.cpp +++ b/dali-toolkit/internal/text/decorator/text-decorator.cpp @@ -24,7 +24,7 @@ #include #include #include -#include +#include #include #include #include @@ -32,8 +32,8 @@ #include #include #include -#include -#include +#include +#include #include #include #include @@ -72,21 +72,28 @@ Integration::Log::Filter* gLogFilter( Integration::Log::Filter::New(Debug::NoLog namespace { -const char* DEFAULT_GRAB_HANDLE_IMAGE( DALI_IMAGE_DIR "insertpoint-icon.png" ); +const char* DEFAULT_GRAB_HANDLE_IMAGE_RELEASED( DALI_IMAGE_DIR "insertpoint-icon.png" ); +const char* DEFAULT_GRAB_HANDLE_IMAGE_PRESSED( DALI_IMAGE_DIR "insertpoint-icon-pressed.png" ); const char* DEFAULT_SELECTION_HANDLE_ONE( DALI_IMAGE_DIR "text-input-selection-handle-left.png" ); const char* DEFAULT_SELECTION_HANDLE_TWO( DALI_IMAGE_DIR "text-input-selection-handle-right.png" ); -//const char* DEFAULT_SELECTION_HANDLE_ONE_PRESSED( DALI_IMAGE_DIR "text-input-selection-handle-left-press.png" ); -//const char* DEFAULT_SELECTION_HANDLE_TWO_PRESSED( DALI_IMAGE_DIR "text-input-selection-handle-right-press.png" ); const Dali::Vector3 DEFAULT_GRAB_HANDLE_RELATIVE_SIZE( 1.5f, 2.0f, 1.0f ); const Dali::Vector3 DEFAULT_SELECTION_HANDLE_RELATIVE_SIZE( 1.5f, 1.5f, 1.0f ); +const Dali::Vector4 LIGHT_BLUE( 0.07f, 0.41f, 0.59f, 1.0f ); // The text highlight color. + const unsigned int CURSOR_BLINK_INTERVAL = 500u; // Cursor blink interval const float TO_MILLISECONDS = 1000.f; -const float TO_SECONDS = 1.f / 1000.f; +const float TO_SECONDS = 1.f / TO_MILLISECONDS; const float DISPLAYED_HIGHLIGHT_Z_OFFSET( -0.05f ); +const unsigned int SCROLL_TICK_INTERVAL = 50u; + +const float SCROLL_THRESHOLD = 10.f; +const float SCROLL_SPEED = 300.f; +const float SCROLL_DISTANCE = SCROLL_SPEED * SCROLL_TICK_INTERVAL * TO_SECONDS; + /** * structure to hold coordinates of each quad, which will make up the mesh. */ @@ -151,10 +158,19 @@ namespace Text struct Decorator::Impl : public ConnectionTracker { + enum ScrollDirection + { + SCROLL_NONE, + SCROLL_RIGHT, + SCROLL_LEFT, + SCROLL_TOP, + SCROLL_BOTTOM + }; + struct CursorImpl { CursorImpl() - : color( Dali::Color::WHITE ), + : color( Dali::Color::BLACK ), position(), cursorHeight( 0.0f ), lineHeight( 0.0f ) @@ -167,11 +183,15 @@ struct Decorator::Impl : public ConnectionTracker float lineHeight; }; - struct SelectionHandleImpl + struct HandleImpl { - SelectionHandleImpl() + HandleImpl() : position(), lineHeight( 0.0f ), + grabDisplacementX( 0.f ), + grabDisplacementY( 0.f ), + active( false ), + visible( false ), flipped( false ) { } @@ -179,26 +199,28 @@ struct Decorator::Impl : public ConnectionTracker ImageActor actor; Actor grabArea; - Image pressedImage; - Image releasedImage; - Vector2 position; float lineHeight; ///< Not the handle height - bool flipped; + float grabDisplacementX; + float grabDisplacementY; + bool active : 1; + bool visible : 1; + bool flipped : 1; }; Impl( Dali::Toolkit::Internal::Control& parent, Observer& observer ) : mTextControlParent( parent ), mObserver( observer ), mBoundingBox( Rect() ), - mHighlightColor( 0.07f, 0.41f, 0.59f, 1.0f ), // light blue + mHighlightColor( LIGHT_BLUE ), mActiveCursor( ACTIVE_CURSOR_NONE ), mCursorBlinkInterval( CURSOR_BLINK_INTERVAL ), mCursorBlinkDuration( 0.0f ), - mGrabDisplacementX( 0.0f ), - mGrabDisplacementY( 0.0f ), - mActiveGrabHandle( false ), - mActiveSelection( false ), + mHandleScrolling( HANDLE_TYPE_COUNT ), + mScrollDirection( SCROLL_NONE ), + mScrollThreshold( SCROLL_THRESHOLD ), + mScrollSpeed( SCROLL_SPEED ), + mScrollDistance( SCROLL_DISTANCE ), mActiveCopyPastePopup( false ), mCursorBlinkStatus( true ), mPrimaryCursorVisible( false ), @@ -219,31 +241,61 @@ struct Decorator::Impl : public ConnectionTracker CreateCursors(); if( mPrimaryCursor ) { - mPrimaryCursorVisible = ( mCursor[PRIMARY_CURSOR].position.x <= size.width ) && ( mCursor[PRIMARY_CURSOR].position.x >= 0.f ); + const CursorImpl& cursor = mCursor[PRIMARY_CURSOR]; + mPrimaryCursorVisible = ( cursor.position.x <= size.width ) && ( cursor.position.x >= 0.f ); if( mPrimaryCursorVisible ) { - mPrimaryCursor.SetPosition( mCursor[PRIMARY_CURSOR].position.x, - mCursor[PRIMARY_CURSOR].position.y ); - mPrimaryCursor.SetSize( Size( 1.0f, mCursor[PRIMARY_CURSOR].cursorHeight ) ); + Vector2 position = cursor.position; + if( GRAB_HANDLE == mHandleScrolling ) + { + if( mScrollDirection == SCROLL_RIGHT ) + { + position.x = 0.f; + } + else + { + position.x = size.width; + } + } + + mPrimaryCursor.SetPosition( position.x, + position.y ); + mPrimaryCursor.SetSize( Size( 1.0f, cursor.cursorHeight ) ); } mPrimaryCursor.SetVisible( mPrimaryCursorVisible ); } if( mSecondaryCursor ) { - mSecondaryCursorVisible = ( mCursor[SECONDARY_CURSOR].position.x <= size.width ) && ( mCursor[SECONDARY_CURSOR].position.x >= 0.f ); + const CursorImpl& cursor = mCursor[SECONDARY_CURSOR]; + mSecondaryCursorVisible = ( cursor.position.x <= size.width ) && ( cursor.position.x >= 0.f ); if( mSecondaryCursorVisible ) { - mSecondaryCursor.SetPosition( mCursor[SECONDARY_CURSOR].position.x, - mCursor[SECONDARY_CURSOR].position.y ); - mSecondaryCursor.SetSize( Size( 1.0f, mCursor[SECONDARY_CURSOR].cursorHeight ) ); + mSecondaryCursor.SetPosition( cursor.position.x, + cursor.position.y ); + mSecondaryCursor.SetSize( Size( 1.0f, cursor.cursorHeight ) ); } mSecondaryCursor.SetVisible( mSecondaryCursorVisible ); } // Show or hide the grab handle - if( mActiveGrabHandle ) + HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + if( grabHandle.active ) { - const bool isVisible = ( mCursor[PRIMARY_CURSOR].position.x <= size.width ) && ( mCursor[PRIMARY_CURSOR].position.x >= 0.f ); + Vector2 position = grabHandle.position; + + if( GRAB_HANDLE == mHandleScrolling ) + { + if( mScrollDirection == SCROLL_RIGHT ) + { + position.x = 0.f; + } + else + { + position.x = size.width; + } + } + + const bool isVisible = ( position.x <= size.width ) && ( position.x >= 0.f ); if( isVisible ) { @@ -251,28 +303,28 @@ struct Decorator::Impl : public ConnectionTracker CreateGrabHandle(); - mGrabHandle.SetPosition( mCursor[PRIMARY_CURSOR].position.x, - mCursor[PRIMARY_CURSOR].position.y + mCursor[PRIMARY_CURSOR].lineHeight ); + grabHandle.actor.SetPosition( position.x, + position.y + grabHandle.lineHeight ); } - mGrabHandle.SetVisible( isVisible ); + grabHandle.actor.SetVisible( isVisible ); } - else if( mGrabHandle ) + else if( grabHandle.actor ) { - UnparentAndReset( mGrabHandle ); + UnparentAndReset( grabHandle.actor ); } // Show or hide the selection handles/highlight - if( mActiveSelection ) + HandleImpl& primary = mHandle[ LEFT_SELECTION_HANDLE ]; + HandleImpl& secondary = mHandle[ RIGHT_SELECTION_HANDLE ]; + if( primary.active || secondary.active ) { SetupTouchEvents(); CreateSelectionHandles(); - SelectionHandleImpl& primary = mSelectionHandle[ PRIMARY_SELECTION_HANDLE ]; primary.actor.SetPosition( primary.position.x, primary.position.y + primary.lineHeight ); - SelectionHandleImpl& secondary = mSelectionHandle[ SECONDARY_SELECTION_HANDLE ]; secondary.actor.SetPosition( secondary.position.x, secondary.position.y + secondary.lineHeight ); @@ -281,8 +333,8 @@ struct Decorator::Impl : public ConnectionTracker } else { - UnparentAndReset( mSelectionHandle[ PRIMARY_SELECTION_HANDLE ].actor ); - UnparentAndReset( mSelectionHandle[ SECONDARY_SELECTION_HANDLE ].actor ); + UnparentAndReset( primary.actor ); + UnparentAndReset( secondary.actor ); UnparentAndReset( mHighlightMeshActor ); } @@ -312,8 +364,9 @@ struct Decorator::Impl : public ConnectionTracker { mCursor[PRIMARY_CURSOR].position += scrollOffset; mCursor[SECONDARY_CURSOR].position += scrollOffset; - mSelectionHandle[ PRIMARY_SELECTION_HANDLE ].position += scrollOffset; - mSelectionHandle[ SECONDARY_SELECTION_HANDLE ].position += scrollOffset; + mHandle[ GRAB_HANDLE ].position += scrollOffset; + mHandle[ LEFT_SELECTION_HANDLE ].position += scrollOffset; + mHandle[ RIGHT_SELECTION_HANDLE ].position += scrollOffset; // TODO Highlight box?? } @@ -335,9 +388,9 @@ struct Decorator::Impl : public ConnectionTracker mCopyPastePopup.SetPosition( popupPosition ); //todo grabhandle(cursor) or selection handle positions to be used } - void CreateCursor( ImageActor& cursor ) + void CreateCursor( ImageActor& cursor, const Vector4& color ) { - cursor = CreateSolidColorActor( Color::WHITE ); + cursor = CreateSolidColorActor( color ); cursor.SetParentOrigin( ParentOrigin::TOP_LEFT ); // Need to set the default parent origin as CreateSolidColorActor() sets a different one. cursor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); } @@ -358,7 +411,7 @@ struct Decorator::Impl : public ConnectionTracker { if ( !mPrimaryCursor ) { - CreateCursor( mPrimaryCursor ); + CreateCursor( mPrimaryCursor, mCursor[PRIMARY_CURSOR].color ); #ifdef DECORATOR_DEBUG mPrimaryCursor.SetName( "PrimaryCursorActor" ); #endif @@ -370,7 +423,7 @@ struct Decorator::Impl : public ConnectionTracker { if ( !mSecondaryCursor ) { - CreateCursor( mSecondaryCursor ); + CreateCursor( mSecondaryCursor, mCursor[SECONDARY_CURSOR].color ); #ifdef DECORATOR_DEBUG mSecondaryCursor.SetName( "SecondaryCursorActor" ); #endif @@ -439,57 +492,62 @@ struct Decorator::Impl : public ConnectionTracker void CreateGrabHandle() { - if( !mGrabHandle ) + HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + if( !grabHandle.actor ) { - if ( !mGrabHandleImage ) + if( !mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_RELEASED] ) + { + mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_RELEASED] = ResourceImage::New( DEFAULT_GRAB_HANDLE_IMAGE_RELEASED ); + } + if( !mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_PRESSED] ) { - mGrabHandleImage = ResourceImage::New( DEFAULT_GRAB_HANDLE_IMAGE ); + mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_PRESSED] = ResourceImage::New( DEFAULT_GRAB_HANDLE_IMAGE_PRESSED ); } - mGrabHandle = ImageActor::New( mGrabHandleImage ); - mGrabHandle.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - mGrabHandle.SetDrawMode( DrawMode::OVERLAY ); + grabHandle.actor = ImageActor::New( mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_RELEASED] ); + grabHandle.actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); + grabHandle.actor.SetDrawMode( DrawMode::OVERLAY ); // Area that Grab handle responds to, larger than actual handle so easier to move #ifdef DECORATOR_DEBUG - mGrabHandle.SetName( "GrabHandleActor" ); + grabHandle.actor.SetName( "GrabHandleActor" ); if ( Dali::Internal::gLogFilter->IsEnabledFor( Debug::Verbose ) ) { - mGrabArea = Toolkit::CreateSolidColorActor( Vector4(0.0f, 0.0f, 0.0f, 0.0f), true, Color::RED, 1 ); - mGrabArea.SetName( "GrabArea" ); + grabHandle.grabArea = Toolkit::CreateSolidColorActor( Vector4(0.0f, 0.0f, 0.0f, 0.0f), true, Color::RED, 1 ); + grabHandle.grabArea.SetName( "GrabArea" ); } else { - mGrabArea = Actor::New(); - mGrabArea.SetName( "GrabArea" ); + grabHandle.grabArea = Actor::New(); + grabHandle.grabArea.SetName( "GrabArea" ); } #else - mGrabArea = Actor::New(); + grabHandle.grabArea = Actor::New(); #endif - mGrabArea.SetParentOrigin( ParentOrigin::TOP_CENTER ); - mGrabArea.SetAnchorPoint( AnchorPoint::TOP_CENTER ); - mGrabArea.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::ALL_DIMENSIONS ); - mGrabArea.SetSizeModeFactor( DEFAULT_GRAB_HANDLE_RELATIVE_SIZE ); - mGrabHandle.Add( mGrabArea ); + grabHandle.grabArea.SetParentOrigin( ParentOrigin::TOP_CENTER ); + grabHandle.grabArea.SetAnchorPoint( AnchorPoint::TOP_CENTER ); + grabHandle.grabArea.SetResizePolicy( ResizePolicy::SIZE_RELATIVE_TO_PARENT, Dimension::ALL_DIMENSIONS ); + grabHandle.grabArea.SetSizeModeFactor( DEFAULT_GRAB_HANDLE_RELATIVE_SIZE ); + grabHandle.actor.Add( grabHandle.grabArea ); - mTapDetector.Attach( mGrabArea ); - mPanGestureDetector.Attach( mGrabArea ); + mTapDetector.Attach( grabHandle.grabArea ); + mPanGestureDetector.Attach( grabHandle.grabArea ); - mActiveLayer.Add( mGrabHandle ); + mActiveLayer.Add( grabHandle.actor ); } } void CreateSelectionHandles() { - SelectionHandleImpl& primary = mSelectionHandle[ PRIMARY_SELECTION_HANDLE ]; - if ( !primary.actor ) + HandleImpl& primary = mHandle[ LEFT_SELECTION_HANDLE ]; + if( !primary.actor ) { - if ( !primary.releasedImage ) + if( !mHandleImages[LEFT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] ) { - primary.releasedImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE ); + mHandleImages[LEFT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] = ResourceImage::New( DEFAULT_SELECTION_HANDLE_ONE ); } - primary.actor = ImageActor::New( primary.releasedImage ); + primary.actor = ImageActor::New( mHandleImages[LEFT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] ); #ifdef DECORATOR_DEBUG primary.actor.SetName("SelectionHandleOne"); #endif @@ -513,15 +571,15 @@ struct Decorator::Impl : public ConnectionTracker mActiveLayer.Add( primary.actor ); } - SelectionHandleImpl& secondary = mSelectionHandle[ SECONDARY_SELECTION_HANDLE ]; - if ( !secondary.actor ) + HandleImpl& secondary = mHandle[ RIGHT_SELECTION_HANDLE ]; + if( !secondary.actor ) { - if ( !secondary.releasedImage ) + if( !mHandleImages[RIGHT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] ) { - secondary.releasedImage = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO ); + mHandleImages[RIGHT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] = ResourceImage::New( DEFAULT_SELECTION_HANDLE_TWO ); } - secondary.actor = ImageActor::New( secondary.releasedImage ); + secondary.actor = ImageActor::New( mHandleImages[RIGHT_SELECTION_HANDLE][HANDLE_IMAGE_RELEASED] ); #ifdef DECORATOR_DEBUG secondary.actor.SetName("SelectionHandleTwo"); #endif @@ -544,8 +602,6 @@ struct Decorator::Impl : public ConnectionTracker secondary.actor.Add( secondary.grabArea ); mActiveLayer.Add( secondary.actor ); } - - //SetUpHandlePropertyNotifications(); TODO } void CreateHighlight() @@ -666,37 +722,85 @@ struct Decorator::Impl : public ConnectionTracker void OnTap( Actor actor, const TapGesture& tap ) { - if( actor == mGrabHandle ) + if( actor == mHandle[GRAB_HANDLE].actor ) { // TODO } } - void OnPan( Actor actor, const PanGesture& gesture ) + void DoPan( HandleImpl& handle, HandleType type, const PanGesture& gesture ) { - if( actor == mGrabArea ) + if( Gesture::Started == gesture.state ) { - if( Gesture::Started == gesture.state ) + handle.grabDisplacementX = handle.grabDisplacementY = 0; + if( mHandleImages[type][HANDLE_IMAGE_PRESSED] ) { - mGrabDisplacementX = mGrabDisplacementY = 0; + handle.actor.SetImage( mHandleImages[type][HANDLE_IMAGE_PRESSED] ); } + } - mGrabDisplacementX += gesture.displacement.x; - mGrabDisplacementY += gesture.displacement.y; + handle.grabDisplacementX += gesture.displacement.x; + handle.grabDisplacementY += gesture.displacement.y; - const float x = mCursor[PRIMARY_CURSOR].position.x + mGrabDisplacementX; - const float y = mCursor[PRIMARY_CURSOR].position.y + mCursor[PRIMARY_CURSOR].lineHeight*0.5f + mGrabDisplacementY; + const float x = handle.position.x + handle.grabDisplacementX; + const float y = handle.position.y + handle.lineHeight*0.5f + handle.grabDisplacementY; - if( Gesture::Started == gesture.state || - Gesture::Continuing == gesture.state ) + if( Gesture::Started == gesture.state || + Gesture::Continuing == gesture.state ) + { + if( x < mScrollThreshold ) + { + mScrollDirection = SCROLL_RIGHT; + mHandleScrolling = type; + StartScrollTimer(); + } + else if( x > mTextControlParent.GetControlSize().width - mScrollThreshold ) + { + mScrollDirection = SCROLL_LEFT; + mHandleScrolling = type; + StartScrollTimer(); + } + else + { + mHandleScrolling = HANDLE_TYPE_COUNT; + StopScrollTimer(); + mObserver.HandleEvent( type, HANDLE_PRESSED, x, y ); + } + } + else if( Gesture::Finished == gesture.state || + Gesture::Cancelled == gesture.state ) + { + if( mScrollTimer && mScrollTimer.IsRunning() ) { - mObserver.GrabHandleEvent( GRAB_HANDLE_PRESSED, x, y ); + mHandleScrolling = HANDLE_TYPE_COUNT; + StopScrollTimer(); + mObserver.HandleEvent( type, HANDLE_STOP_SCROLLING, x, y ); } - else if( Gesture::Finished == gesture.state || - Gesture::Cancelled == gesture.state ) + else { - mObserver.GrabHandleEvent( GRAB_HANDLE_RELEASED, x, y ); + mObserver.HandleEvent( type, HANDLE_RELEASED, x, y ); } + handle.actor.SetImage( mHandleImages[type][HANDLE_IMAGE_RELEASED] ); + } + } + + void OnPan( Actor actor, const PanGesture& gesture ) + { + HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + HandleImpl& primarySelectionHandle = mHandle[LEFT_SELECTION_HANDLE]; + HandleImpl& secondarySelectionHandle = mHandle[RIGHT_SELECTION_HANDLE]; + + if( actor == grabHandle.grabArea ) + { + DoPan( grabHandle, GRAB_HANDLE, gesture ); + } + else if( actor == primarySelectionHandle.grabArea ) + { + DoPan( primarySelectionHandle, LEFT_SELECTION_HANDLE, gesture ); + } + else if( actor == secondarySelectionHandle.grabArea ) + { + DoPan( secondarySelectionHandle, RIGHT_SELECTION_HANDLE, gesture ); } } @@ -726,7 +830,7 @@ struct Decorator::Impl : public ConnectionTracker const float popupHeight = 120.0f; // todo Set as a MaxSize Property in Control or retrieve from CopyPastePopup class. - if( mActiveGrabHandle ) + if( mHandle[GRAB_HANDLE].active ) { // If grab handle enabled then position pop-up below the grab handle. const Vector2 grabHandleSize( 59.0f, 56.0f ); // todo @@ -744,16 +848,10 @@ struct Decorator::Impl : public ConnectionTracker void PopUpLeavesVerticalBoundary( PropertyNotification& source ) { float alternativeYPosition=0.0f; - // todo - // if( mHighlightMeshActor ) // Text Selection mode - // { - // alternativePosition = AlternatePopUpPositionRelativeToSelectionHandles(); - // } - // else // Not in Text Selection mode - // { + // todo use AlternatePopUpPositionRelativeToSelectionHandles() if text is highlighted // if can't be positioned above, then position below row. alternativeYPosition = AlternatePopUpPositionRelativeToCursor(); - // } + mCopyPastePopup.SetY( alternativeYPosition ); } @@ -810,29 +908,97 @@ struct Decorator::Impl : public ConnectionTracker requiredPopupPosition.x = requiredPopupPosition.x + xOffSetToKeepWithinBounds; } + void SetScrollThreshold( float threshold ) + { + mScrollThreshold = threshold; + } + + float GetScrollThreshold() const + { + return mScrollThreshold; + } + + void SetScrollSpeed( float speed ) + { + mScrollSpeed = speed; + mScrollDistance = speed * SCROLL_TICK_INTERVAL * TO_SECONDS; + } + + float GetScrollSpeed() const + { + return mScrollSpeed; + } + + /** + * Creates and starts a timer to scroll the text when handles are close to the edges of the text. + * + * It only starts the timer if it's already created. + */ + void StartScrollTimer() + { + if( !mScrollTimer ) + { + mScrollTimer = Timer::New( SCROLL_TICK_INTERVAL ); + mScrollTimer.TickSignal().Connect( this, &Decorator::Impl::OnScrollTimerTick ); + } + + if( !mScrollTimer.IsRunning() ) + { + mScrollTimer.Start(); + } + } + + /** + * Stops the timer used to scroll the text. + */ + void StopScrollTimer() + { + if( mScrollTimer ) + { + mScrollTimer.Stop(); + } + } + + /** + * Callback called by the timer used to scroll the text. + * + * It calculates and sets a new scroll position. + */ + bool OnScrollTimerTick() + { + if( HANDLE_TYPE_COUNT != mHandleScrolling ) + { + mObserver.HandleEvent( mHandleScrolling, + HANDLE_SCROLLING, + mScrollDirection == SCROLL_RIGHT ? mScrollDistance : -mScrollDistance, + 0.f ); + } + + return true; + } + Internal::Control& mTextControlParent; Observer& mObserver; TapGestureDetector mTapDetector; PanGestureDetector mPanGestureDetector; Timer mCursorBlinkTimer; ///< Timer to signal cursor to blink + Timer mScrollTimer; ///< Timer used to scroll the text when the grab handle is moved close to the edges. Layer mActiveLayer; ///< Layer for active handles and alike that ensures they are above all else. ImageActor mPrimaryCursor; ImageActor mSecondaryCursor; - ImageActor mGrabHandle; - Actor mGrabArea; MeshActor mHighlightMeshActor; ///< Mesh Actor to display highlight TextSelectionPopup mCopyPastePopup; + Image mHandleImages[HANDLE_TYPE_COUNT][HANDLE_IMAGE_TYPE_COUNT]; Image mCursorImage; - Image mGrabHandleImage; Mesh mHighlightMesh; ///< Mesh for highlight MeshData mHighlightMeshData; ///< Mesh Data for highlight Material mHighlightMaterial; ///< Material used for highlight CursorImpl mCursor[CURSOR_COUNT]; - SelectionHandleImpl mSelectionHandle[SELECTION_HANDLE_COUNT]; + HandleImpl mHandle[HANDLE_TYPE_COUNT]; QuadContainer mHighlightQuadList; ///< Sub-selections that combine to create the complete selection highlight Rect mBoundingBox; @@ -841,11 +1007,13 @@ struct Decorator::Impl : public ConnectionTracker unsigned int mActiveCursor; unsigned int mCursorBlinkInterval; float mCursorBlinkDuration; - float mGrabDisplacementX; - float mGrabDisplacementY; + HandleType mHandleScrolling; ///< The handle which is scrolling. + ScrollDirection mScrollDirection; ///< The direction of the scroll. + float mScrollThreshold; ///< Defines a square area inside the control, close to the edge. A cursor entering this area will trigger scroll events. + float mScrollSpeed; ///< The scroll speed in pixels per second. + float mScrollDistance; ///< Distance the text scrolls during a scroll interval. + unsigned int mScrollInterval; ///< Time in milliseconds of a scroll interval. - bool mActiveGrabHandle : 1; - bool mActiveSelection : 1; bool mActiveCopyPastePopup : 1; bool mCursorBlinkStatus : 1; ///< Flag to switch between blink on and blink off. bool mPrimaryCursorVisible : 1; ///< Whether the primary cursor is visible. @@ -891,13 +1059,6 @@ unsigned int Decorator::GetActiveCursor() const void Decorator::SetPosition( Cursor cursor, float x, float y, float cursorHeight, float lineHeight ) { - // Adjust grab handle displacement - if( PRIMARY_CURSOR == cursor ) - { - mImpl->mGrabDisplacementX -= x - mImpl->mCursor[cursor].position.x; - mImpl->mGrabDisplacementY -= y - mImpl->mCursor[cursor].position.y; - } - mImpl->mCursor[cursor].position.x = x; mImpl->mCursor[cursor].position.y = y; mImpl->mCursor[cursor].cursorHeight = cursorHeight; @@ -969,94 +1130,100 @@ float Decorator::GetCursorBlinkDuration() const return mImpl->mCursorBlinkDuration; } -/** GrabHandle **/ +/** Handles **/ -void Decorator::SetGrabHandleActive( bool active ) +void Decorator::SetHandleActive( HandleType handleType, bool active ) { - mImpl->mActiveGrabHandle = active; + mImpl->mHandle[handleType].active = active; } -bool Decorator::IsGrabHandleActive() const +bool Decorator::IsHandleActive( HandleType handleType ) const { - return mImpl->mActiveGrabHandle; + return mImpl->mHandle[handleType].active ; } -void Decorator::SetGrabHandleImage( Dali::Image image ) +void Decorator::SetHandleImage( HandleType handleType, HandleImageType handleImageType, Dali::Image image ) { - mImpl->mGrabHandleImage = image; + mImpl->mHandleImages[handleType][handleImageType] = image; } -Dali::Image Decorator::GetGrabHandleImage() const +Dali::Image Decorator::GetHandleImage( HandleType handleType, HandleImageType handleImageType ) const { - return mImpl->mGrabHandleImage; + return mImpl->mHandleImages[handleType][handleImageType]; } -/** Selection **/ +void Decorator::SetPosition( HandleType handleType, float x, float y, float height ) +{ + // Adjust grab handle displacement + Impl::HandleImpl& handle = mImpl->mHandle[handleType]; -void Decorator::SetSelectionActive( bool active ) + handle.grabDisplacementX -= x - handle.position.x; + handle.grabDisplacementY -= y - handle.position.y; + + handle.position.x = x; + handle.position.y = y; + handle.lineHeight = height; +} + +void Decorator::GetPosition( HandleType handleType, float& x, float& y, float& height ) const { - mImpl->mActiveSelection = active; + Impl::HandleImpl& handle = mImpl->mHandle[handleType]; + + x = handle.position.x; + y = handle.position.y; + height = handle.lineHeight; } -bool Decorator::IsSelectionActive() const +void Decorator::AddHighlight( float x1, float y1, float x2, float y2 ) { - return mImpl->mActiveSelection; + mImpl->mHighlightQuadList.push_back( QuadCoordinates(x1, y1, x2, y2) ); } -void Decorator::SetPosition( SelectionHandle handle, float x, float y, float height ) +void Decorator::ClearHighlights() { - mImpl->mSelectionHandle[handle].position.x = x; - mImpl->mSelectionHandle[handle].position.y = y; - mImpl->mSelectionHandle[handle].lineHeight = height; + mImpl->mHighlightQuadList.clear(); } -void Decorator::GetPosition( SelectionHandle handle, float& x, float& y, float& height ) const +void Decorator::SetHighlightColor( const Vector4& color ) { - x = mImpl->mSelectionHandle[handle].position.x; - y = mImpl->mSelectionHandle[handle].position.y; - height = mImpl->mSelectionHandle[handle].lineHeight; + mImpl->mHighlightColor = color; } -void Decorator::SetImage( SelectionHandle handle, SelectionHandleState state, Dali::Image image ) +const Vector4& Decorator::GetHighlightColor() const { - if( SELECTION_HANDLE_PRESSED == state ) - { - mImpl->mSelectionHandle[handle].pressedImage = image; - } - else - { - mImpl->mSelectionHandle[handle].releasedImage = image; - } + return mImpl->mHighlightColor; } -Dali::Image Decorator::GetImage( SelectionHandle handle, SelectionHandleState state ) const +void Decorator::SetPopupActive( bool active ) { - if( SELECTION_HANDLE_PRESSED == state ) - { - return mImpl->mSelectionHandle[handle].pressedImage; - } + mImpl->mActiveCopyPastePopup = active; +} - return mImpl->mSelectionHandle[handle].releasedImage; +bool Decorator::IsPopupActive() const +{ + return mImpl->mActiveCopyPastePopup ; } -void Decorator::AddHighlight( float x1, float y1, float x2, float y2 ) +/** Scroll **/ + +void Decorator::SetScrollThreshold( float threshold ) { - mImpl->mHighlightQuadList.push_back( QuadCoordinates(x1, y1, x2, y2) ); + mImpl->SetScrollThreshold( threshold ); } -void Decorator::ClearHighlights() +float Decorator::GetScrollThreshold() const { - mImpl->mHighlightQuadList.clear(); + return mImpl->GetScrollThreshold(); } -void Decorator::SetPopupActive( bool active ) +void Decorator::SetScrollSpeed( float speed ) { - mImpl->mActiveCopyPastePopup = active; + mImpl->SetScrollSpeed( speed ); } -bool Decorator::IsPopupActive() const +float Decorator::GetScrollSpeed() const { - return mImpl->mActiveCopyPastePopup ; + return mImpl->GetScrollSpeed(); } Decorator::~Decorator()