X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Fdecorator%2Ftext-decorator.cpp;h=0b3ff48495bece3281b8e337129f04dd1df48554;hb=refs%2Fchanges%2F84%2F72984%2F13;hp=7f032d7bb7c4d9f8b821758f91a036b6c2cd36d7;hpb=0dd2826b16facb7e8f21ffb86853bd1b0afb97b4;p=platform%2Fcore%2Fuifw%2Fdali-toolkit.git diff --git a/dali-toolkit/internal/text/decorator/text-decorator.cpp b/dali-toolkit/internal/text/decorator/text-decorator.cpp index 7f032d7..0b3ff48 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 @@ -33,7 +33,6 @@ #include // INTERNAL INCLUDES -#include #include #include #include @@ -94,17 +93,17 @@ const Dali::Vector4 LIGHT_BLUE( 0.75f, 0.96f, 1.f, 1.f ); // The text highlight const Dali::Vector4 HANDLE_COLOR( 0.0f, (183.0f / 255.0f), (229.0f / 255.0f), 1.0f ); -const unsigned int CURSOR_BLINK_INTERVAL = 500u; // Cursor blink interval -const float TO_MILLISECONDS = 1000.f; -const float TO_SECONDS = 1.f / TO_MILLISECONDS; +const unsigned int CURSOR_BLINK_INTERVAL = 500u; ///< Cursor blink interval in milliseconds. +const float TO_MILLISECONDS = 1000.f; ///< Converts from seconds to milliseconds. +const float TO_SECONDS = 1.f / TO_MILLISECONDS; ///< Converts from milliseconds to seconds. -const unsigned int SCROLL_TICK_INTERVAL = 50u; +const unsigned int SCROLL_TICK_INTERVAL = 50u; ///< Scroll interval in milliseconds. +const float SCROLL_THRESHOLD = 10.f; ///< Threshold in pixels close to the edges of the decorator boundaries from where the scroll timer starts to emit signals. +const float SCROLL_SPEED = 300.f; ///< The scroll speed in pixels/second. -const float SCROLL_THRESHOLD = 10.f; -const float SCROLL_SPEED = 300.f; -const float SCROLL_DISTANCE = SCROLL_SPEED * SCROLL_TICK_INTERVAL * TO_SECONDS; +const float SCROLL_DISTANCE = SCROLL_SPEED * SCROLL_TICK_INTERVAL * TO_SECONDS; ///< Distance in pixels scrolled in one second. -const float CURSOR_WIDTH = 1.f; +const float CURSOR_WIDTH = 1.f; ///< The cursor's width in pixels. /** * structure to hold coordinates of each quad, which will make up the mesh. @@ -209,6 +208,7 @@ struct Decorator::Impl : public ConnectionTracker { HandleImpl() : position(), + globalPosition(), size(), lineHeight( 0.0f ), grabDisplacementX( 0.f ), @@ -227,6 +227,7 @@ struct Decorator::Impl : public ConnectionTracker ImageView markerActor; Vector2 position; + Vector2 globalPosition; Size size; float lineHeight; ///< Not the handle height float grabDisplacementX; @@ -278,16 +279,16 @@ struct Decorator::Impl : public ConnectionTracker mFlipSelectionHandlesOnCross( false ), mFlipLeftSelectionHandleDirection( false ), mFlipRightSelectionHandleDirection( false ), - mHandlePanning( false ), - mHandleCurrentCrossed( false ), - mHandlePreviousCrossed( false ), - mNotifyEndOfScroll( false ) + mIsHandlePanning( false ), + mIsHandleCurrentlyCrossed( false ), + mIsHandlePreviouslyCrossed( false ), + mNotifyEndOfScroll( false ), + mHorizontalScrollingEnabled( false ), + mVerticalScrollingEnabled( false ) { mQuadVertexFormat[ "aPosition" ] = Property::VECTOR2; - mQuadIndexFormat[ "indices" ] = Property::INTEGER; - mHighlightMaterial = Material::New( Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ) ); - - SetupTouchEvents(); + mHighlightShader = Shader::New( VERTEX_SHADER, FRAGMENT_SHADER ); + SetupGestures(); } /** @@ -307,7 +308,10 @@ struct Decorator::Impl : public ConnectionTracker if( mPrimaryCursor ) { const CursorImpl& cursor = mCursor[PRIMARY_CURSOR]; - mPrimaryCursorVisible = ( cursor.position.x + mCursorWidth <= mControlSize.width ) && ( cursor.position.x >= 0.f ); + mPrimaryCursorVisible = ( ( cursor.position.x + mCursorWidth <= mControlSize.width ) && + ( cursor.position.x >= 0.f ) && + ( cursor.position.y + cursor.cursorHeight <= mControlSize.height ) && + ( cursor.position.y >= 0.f ) ); if( mPrimaryCursorVisible ) { mPrimaryCursor.SetPosition( cursor.position.x, @@ -319,7 +323,10 @@ struct Decorator::Impl : public ConnectionTracker if( mSecondaryCursor ) { const CursorImpl& cursor = mCursor[SECONDARY_CURSOR]; - mSecondaryCursorVisible = ( cursor.position.x + mCursorWidth <= mControlSize.width ) && ( cursor.position.x >= 0.f ); + mSecondaryCursorVisible = ( ( cursor.position.x + mCursorWidth <= mControlSize.width ) && + ( cursor.position.x >= 0.f ) && + ( cursor.position.y + cursor.cursorHeight <= mControlSize.height ) && + ( cursor.position.y >= 0.f ) ); if( mSecondaryCursorVisible ) { mSecondaryCursor.SetPosition( cursor.position.x, @@ -334,7 +341,10 @@ struct Decorator::Impl : public ConnectionTracker bool newGrabHandlePosition = false; if( grabHandle.active ) { - const bool isVisible = ( grabHandle.position.x + floor( 0.5f * mCursorWidth ) <= mControlSize.width ) && ( grabHandle.position.x >= 0.f ); + const bool isVisible = ( ( grabHandle.position.x + floor( 0.5f * mCursorWidth ) <= mControlSize.width ) && + ( grabHandle.position.x >= 0.f ) && + ( grabHandle.position.y <= mControlSize.height - grabHandle.lineHeight ) && + ( grabHandle.position.y >= 0.f ) ); if( isVisible ) { @@ -366,8 +376,14 @@ struct Decorator::Impl : public ConnectionTracker bool newSecondaryHandlePosition = false; if( primary.active || secondary.active ) { - const bool isPrimaryVisible = ( primary.position.x <= mControlSize.width ) && ( primary.position.x >= 0.f ); - const bool isSecondaryVisible = ( secondary.position.x <= mControlSize.width ) && ( secondary.position.x >= 0.f ); + const bool isPrimaryVisible = ( ( primary.position.x <= mControlSize.width ) && + ( primary.position.x >= 0.f ) && + ( primary.position.y <= mControlSize.height - primary.lineHeight ) && + ( primary.position.y >= 0.f ) ); + const bool isSecondaryVisible = ( ( secondary.position.x <= mControlSize.width ) && + ( secondary.position.x >= 0.f ) && + ( secondary.position.y <= mControlSize.height - secondary.lineHeight ) && + ( secondary.position.y >= 0.f ) ); if( isPrimaryVisible || isSecondaryVisible ) { @@ -489,7 +505,6 @@ struct Decorator::Impl : public ConnectionTracker { const HandleImpl& primaryHandle = mHandle[LEFT_SELECTION_HANDLE]; const HandleImpl& secondaryHandle = mHandle[RIGHT_SELECTION_HANDLE]; - const HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; const CursorImpl& cursor = mCursor[PRIMARY_CURSOR]; if( primaryHandle.active || secondaryHandle.active ) @@ -505,7 +520,15 @@ struct Decorator::Impl : public ConnectionTracker else { // Calculates the popup's position if the grab handle is active. - mCopyPastePopup.position = Vector3( cursor.position.x, -0.5f * popupSize.height - grabHandle.size.height + cursor.position.y, 0.0f ); + const HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + if( grabHandle.verticallyFlipped ) + { + mCopyPastePopup.position = Vector3( cursor.position.x, -0.5f * popupSize.height - grabHandle.size.height + cursor.position.y, 0.0f ); + } + else + { + mCopyPastePopup.position = Vector3( cursor.position.x, -0.5f * popupSize.height + cursor.position.y, 0.0f ); + } } } @@ -529,7 +552,7 @@ struct Decorator::Impl : public ConnectionTracker { cursor = Control::New(); cursor.SetBackgroundColor( color ); - cursor.SetParentOrigin( ParentOrigin::TOP_LEFT ); // Need to set the default parent origin as CreateSolidColorActor() sets a different one. + cursor.SetParentOrigin( ParentOrigin::TOP_LEFT ); cursor.SetAnchorPoint( AnchorPoint::TOP_LEFT ); } @@ -617,13 +640,20 @@ struct Decorator::Impl : public ConnectionTracker return true; } - void SetupTouchEvents() + void SetupGestures() { + // Will consume tap gestures on handles. mTapDetector = TapGestureDetector::New(); - mTapDetector.DetectedSignal().Connect( this, &Decorator::Impl::OnTap ); - mPanGestureDetector = PanGestureDetector::New(); - mPanGestureDetector.DetectedSignal().Connect( this, &Decorator::Impl::OnPan ); + // Will consume double tap gestures on handles. + mTapDetector.SetMaximumTapsRequired( 2u ); + + // Will consume long press gestures on handles. + mLongPressDetector = LongPressGestureDetector::New(); + + // Detects pan gestures on handles. + mPanDetector = PanGestureDetector::New(); + mPanDetector.DetectedSignal().Connect( this, &Decorator::Impl::OnPan ); } void CreateActiveLayer() @@ -690,9 +720,16 @@ struct Decorator::Impl : public ConnectionTracker grabHandle.actor.Add( grabHandle.grabArea ); grabHandle.actor.SetColor( mHandleColor ); - grabHandle.grabArea.TouchedSignal().Connect( this, &Decorator::Impl::OnGrabHandleTouched ); - mTapDetector.Attach( grabHandle.grabArea ); - mPanGestureDetector.Attach( grabHandle.grabArea ); + grabHandle.grabArea.TouchSignal().Connect( this, &Decorator::Impl::OnGrabHandleTouched ); + + // The grab handle's actor is attached to the tap and long press detectors in order to consume these events. + // Note that no callbacks are connected to any signal emitted by the tap and long press detectors. + mTapDetector.Attach( grabHandle.actor ); + mLongPressDetector.Attach( grabHandle.actor ); + + // The grab handle's area is attached to the pan detector. + // The OnPan() method is connected to the signals emitted by the pan detector. + mPanDetector.Attach( grabHandle.grabArea ); mActiveLayer.Add( grabHandle.actor ); } @@ -751,9 +788,16 @@ struct Decorator::Impl : public ConnectionTracker primary.grabArea.SetAnchorPoint( AnchorPoint::TOP_CENTER ); primary.grabArea.SetSizeModeFactor( DEFAULT_SELECTION_HANDLE_RELATIVE_SIZE ); - mTapDetector.Attach( primary.grabArea ); - mPanGestureDetector.Attach( primary.grabArea ); - primary.grabArea.TouchedSignal().Connect( this, &Decorator::Impl::OnHandleOneTouched ); + primary.grabArea.TouchSignal().Connect( this, &Decorator::Impl::OnHandleOneTouched ); + + // The handle's actor is attached to the tap and long press detectors in order to consume these events. + // Note that no callbacks are connected to any signal emitted by the tap and long press detectors. + mTapDetector.Attach( primary.actor ); + mLongPressDetector.Attach( primary.actor ); + + // The handle's area is attached to the pan detector. + // The OnPan() method is connected to the signals emitted by the pan detector. + mPanDetector.Attach( primary.grabArea ); primary.actor.Add( primary.grabArea ); @@ -788,9 +832,16 @@ struct Decorator::Impl : public ConnectionTracker secondary.grabArea.SetAnchorPoint( AnchorPoint::TOP_CENTER ); secondary.grabArea.SetSizeModeFactor( DEFAULT_SELECTION_HANDLE_RELATIVE_SIZE ); - mTapDetector.Attach( secondary.grabArea ); - mPanGestureDetector.Attach( secondary.grabArea ); - secondary.grabArea.TouchedSignal().Connect( this, &Decorator::Impl::OnHandleTwoTouched ); + secondary.grabArea.TouchSignal().Connect( this, &Decorator::Impl::OnHandleTwoTouched ); + + // The handle's actor is attached to the tap and long press detectors in order to consume these events. + // Note that no callbacks are connected to any signal emitted by the tap and long press detectors. + mTapDetector.Attach( secondary.actor ); + mLongPressDetector.Attach( secondary.actor ); + + // The handle's area is attached to the pan detector. + // The OnPan() method is connected to the signals emitted by the pan detector. + mPanDetector.Attach( secondary.grabArea ); secondary.actor.Add( secondary.grabArea ); @@ -812,8 +863,8 @@ struct Decorator::Impl : public ConnectionTracker // The grab handle position in world coords. // The active layer's world position is the center of the active layer. The origin of the // coord system of the handles is the top left of the active layer. - position.x = parentWorldPosition.x - 0.5f * mControlSize.width + handle.position.x; - position.y = parentWorldPosition.y - 0.5f * mControlSize.height + handle.position.y; + position.x = parentWorldPosition.x - 0.5f * mControlSize.width + handle.position.x + ( mSmoothHandlePanEnabled ? handle.grabDisplacementX : 0.f ); + position.y = parentWorldPosition.y - 0.5f * mControlSize.height + handle.position.y + ( mSmoothHandlePanEnabled ? handle.grabDisplacementY : 0.f ); } void SetGrabHandlePosition() @@ -845,8 +896,8 @@ struct Decorator::Impl : public ConnectionTracker if( grabHandle.actor ) { - grabHandle.actor.SetPosition( grabHandle.position.x + floor( 0.5f * mCursorWidth ), - yLocalPosition ); // TODO : Fix for multiline. + grabHandle.actor.SetPosition( grabHandle.position.x + floor( 0.5f * mCursorWidth ) + ( mSmoothHandlePanEnabled ? grabHandle.grabDisplacementX : 0.f ), + yLocalPosition + ( mSmoothHandlePanEnabled ? grabHandle.grabDisplacementY : 0.f ) ); } } @@ -871,18 +922,21 @@ struct Decorator::Impl : public ConnectionTracker // Whether to flip the handles if they are crossed. bool crossFlip = false; - if( mFlipSelectionHandlesOnCross || !mHandlePanning ) + if( mFlipSelectionHandlesOnCross || !mIsHandlePanning ) { - crossFlip = mHandleCurrentCrossed; + crossFlip = mIsHandleCurrentlyCrossed; } + // Whether the handle was crossed before start the panning. + const bool isHandlePreviouslyCrossed = mFlipSelectionHandlesOnCross ? false : mIsHandlePreviouslyCrossed; + // Does not flip if both conditions are true (double flip) - flipHandle = flipHandle != ( crossFlip || mHandlePreviousCrossed ); + flipHandle = flipHandle != ( crossFlip || isHandlePreviouslyCrossed ); // Will flip the handles vertically if the user prefers it. bool verticallyFlippedPreferred = handle.verticallyFlippedPreferred; - if( crossFlip || mHandlePreviousCrossed ) + if( crossFlip || isHandlePreviouslyCrossed ) { if( isPrimaryHandle ) { @@ -935,8 +989,8 @@ struct Decorator::Impl : public ConnectionTracker if( handle.actor ) { - handle.actor.SetPosition( handle.position.x, - yLocalPosition ); // TODO : Fix for multiline. + handle.actor.SetPosition( handle.position.x + ( mSmoothHandlePanEnabled ? handle.grabDisplacementX : 0.f ), + yLocalPosition + ( mSmoothHandlePanEnabled ? handle.grabDisplacementY : 0.f ) ); } } @@ -1007,7 +1061,7 @@ struct Decorator::Impl : public ConnectionTracker if( !mHighlightQuadList.empty() ) { Vector< Vector2 > vertices; - Vector< unsigned int> indices; + Vector< unsigned short> indices; Vector2 vertex; std::vector::iterator iter = mHighlightQuadList.begin(); @@ -1048,37 +1102,23 @@ struct Decorator::Impl : public ConnectionTracker indices.PushBack( v + 3 ); } - if( mQuadVertices ) - { - mQuadVertices.SetSize( vertices.Size() ); - } - else + if( ! mQuadVertices ) { - mQuadVertices = PropertyBuffer::New( mQuadVertexFormat, vertices.Size() ); + mQuadVertices = PropertyBuffer::New( mQuadVertexFormat ); } - if( mQuadIndices ) - { - mQuadIndices.SetSize( indices.Size() ); - } - else - { - mQuadIndices = PropertyBuffer::New( mQuadIndexFormat, indices.Size() ); - } - - mQuadVertices.SetData( &vertices[ 0 ] ); - mQuadIndices.SetData( &indices[ 0 ] ); + mQuadVertices.SetData( &vertices[ 0 ], vertices.Size() ); if( !mQuadGeometry ) { mQuadGeometry = Geometry::New(); mQuadGeometry.AddVertexBuffer( mQuadVertices ); } - mQuadGeometry.SetIndexBuffer( mQuadIndices ); + mQuadGeometry.SetIndexBuffer( &indices[ 0 ], indices.Size() ); if( !mHighlightRenderer ) { - mHighlightRenderer = Dali::Renderer::New( mQuadGeometry, mHighlightMaterial ); + mHighlightRenderer = Dali::Renderer::New( mQuadGeometry, mHighlightShader ); mHighlightActor.AddRenderer( mHighlightRenderer ); } } @@ -1095,45 +1135,57 @@ struct Decorator::Impl : public ConnectionTracker } } - void OnTap( Actor actor, const TapGesture& tap ) - { - if( actor == mHandle[GRAB_HANDLE].actor ) - { - // TODO - } - } - void DoPan( HandleImpl& handle, HandleType type, const PanGesture& gesture ) { if( Gesture::Started == gesture.state ) { - handle.grabDisplacementX = handle.grabDisplacementY = 0; + handle.grabDisplacementX = handle.grabDisplacementY = 0.f; + + handle.globalPosition.x = handle.position.x; + handle.globalPosition.y = handle.position.y; } handle.grabDisplacementX += gesture.displacement.x; - handle.grabDisplacementY += gesture.displacement.y; + handle.grabDisplacementY += ( handle.verticallyFlipped ? -gesture.displacement.y : gesture.displacement.y ); - const float x = handle.position.x + handle.grabDisplacementX; - const float y = handle.position.y + handle.lineHeight*0.5f + handle.grabDisplacementY; + const float x = handle.globalPosition.x + handle.grabDisplacementX; + const float y = handle.globalPosition.y + handle.grabDisplacementY + 0.5f * handle.lineHeight; + const float yVerticallyFlippedCorrected = y - ( handle.verticallyFlipped ? handle.lineHeight : 0.f ); - if( Gesture::Started == gesture.state || - Gesture::Continuing == gesture.state ) + if( ( Gesture::Started == gesture.state ) || + ( Gesture::Continuing == gesture.state ) ) { Vector2 targetSize; mController.GetTargetSize( targetSize ); - if( x < mScrollThreshold ) + if( mHorizontalScrollingEnabled && + ( x < mScrollThreshold ) ) { mScrollDirection = SCROLL_RIGHT; mHandleScrolling = type; StartScrollTimer(); } - else if( x > targetSize.width - mScrollThreshold ) + else if( mHorizontalScrollingEnabled && + ( x > targetSize.width - mScrollThreshold ) ) { mScrollDirection = SCROLL_LEFT; mHandleScrolling = type; StartScrollTimer(); } + else if( mVerticalScrollingEnabled && + ( yVerticallyFlippedCorrected < mScrollThreshold ) ) + { + mScrollDirection = SCROLL_TOP; + mHandleScrolling = type; + StartScrollTimer(); + } + else if( mVerticalScrollingEnabled && + ( yVerticallyFlippedCorrected + handle.lineHeight > targetSize.height - mScrollThreshold ) ) + { + mScrollDirection = SCROLL_BOTTOM; + mHandleScrolling = type; + StartScrollTimer(); + } else { mHandleScrolling = HANDLE_TYPE_COUNT; @@ -1141,10 +1193,10 @@ struct Decorator::Impl : public ConnectionTracker mController.DecorationEvent( type, HANDLE_PRESSED, x, y ); } - mHandlePanning = true; + mIsHandlePanning = true; } - else if( Gesture::Finished == gesture.state || - Gesture::Cancelled == gesture.state ) + else if( ( Gesture::Finished == gesture.state ) || + ( Gesture::Cancelled == gesture.state ) ) { if( mScrollTimer && ( mScrollTimer.IsRunning() || mNotifyEndOfScroll ) ) @@ -1165,7 +1217,7 @@ struct Decorator::Impl : public ConnectionTracker } handle.pressed = false; - mHandlePanning = false; + mIsHandlePanning = false; } } @@ -1189,22 +1241,24 @@ struct Decorator::Impl : public ConnectionTracker } } - bool OnGrabHandleTouched( Actor actor, const TouchEvent& event ) + bool OnGrabHandleTouched( Actor actor, const TouchData& touch ) { + HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + // Switch between pressed/release grab-handle images - if( event.GetPointCount() > 0 && - mHandle[GRAB_HANDLE].actor ) + if( touch.GetPointCount() > 0 && + grabHandle.actor ) { - const TouchPoint& point = event.GetPoint(0); + const PointState::Type state = touch.GetState( 0 ); - if( TouchPoint::Down == point.state ) + if( PointState::DOWN == state ) { - mHandle[GRAB_HANDLE].pressed = true; + grabHandle.pressed = true; } - else if( ( TouchPoint::Up == point.state ) || - ( TouchPoint::Interrupted == point.state ) ) + else if( ( PointState::UP == state ) || + ( PointState::INTERRUPTED == state ) ) { - mHandle[GRAB_HANDLE].pressed = false; + grabHandle.pressed = false; } SetHandleImage( GRAB_HANDLE ); @@ -1214,24 +1268,26 @@ struct Decorator::Impl : public ConnectionTracker return true; } - bool OnHandleOneTouched( Actor actor, const TouchEvent& event ) + bool OnHandleOneTouched( Actor actor, const TouchData& touch ) { + HandleImpl& primarySelectionHandle = mHandle[LEFT_SELECTION_HANDLE]; + // Switch between pressed/release selection handle images - if( event.GetPointCount() > 0 && - mHandle[LEFT_SELECTION_HANDLE].actor ) + if( touch.GetPointCount() > 0 && + primarySelectionHandle.actor ) { - const TouchPoint& point = event.GetPoint(0); + const PointState::Type state = touch.GetState( 0 ); - if( TouchPoint::Down == point.state ) + if( PointState::DOWN == state ) { - mHandle[LEFT_SELECTION_HANDLE].pressed = true; + primarySelectionHandle.pressed = true; } - else if( ( TouchPoint::Up == point.state ) || - ( TouchPoint::Interrupted == point.state ) ) + else if( ( PointState::UP == state ) || + ( PointState::INTERRUPTED == state ) ) { - mHandle[LEFT_SELECTION_HANDLE].pressed = false; - mHandlePreviousCrossed = mHandleCurrentCrossed; - mHandlePanning = false; + primarySelectionHandle.pressed = false; + mIsHandlePreviouslyCrossed = mIsHandleCurrentlyCrossed; + mIsHandlePanning = false; } SetHandleImage( LEFT_SELECTION_HANDLE ); @@ -1241,24 +1297,26 @@ struct Decorator::Impl : public ConnectionTracker return true; } - bool OnHandleTwoTouched( Actor actor, const TouchEvent& event ) + bool OnHandleTwoTouched( Actor actor, const TouchData& touch ) { + HandleImpl& secondarySelectionHandle = mHandle[RIGHT_SELECTION_HANDLE]; + // Switch between pressed/release selection handle images - if( event.GetPointCount() > 0 && - mHandle[RIGHT_SELECTION_HANDLE].actor ) + if( touch.GetPointCount() > 0 && + secondarySelectionHandle.actor ) { - const TouchPoint& point = event.GetPoint(0); + const PointState::Type state = touch.GetState( 0 ); - if( TouchPoint::Down == point.state ) + if( PointState::DOWN == state ) { - mHandle[RIGHT_SELECTION_HANDLE].pressed = true; + secondarySelectionHandle.pressed = true; } - else if( ( TouchPoint::Up == point.state ) || - ( TouchPoint::Interrupted == point.state ) ) + else if( ( PointState::UP == state ) || + ( PointState::INTERRUPTED == state ) ) { - mHandle[RIGHT_SELECTION_HANDLE].pressed = false; - mHandlePreviousCrossed = mHandleCurrentCrossed; - mHandlePanning = false; + secondarySelectionHandle.pressed = false; + mIsHandlePreviouslyCrossed = mIsHandleCurrentlyCrossed; + mIsHandlePanning = false; } SetHandleImage( RIGHT_SELECTION_HANDLE ); @@ -1636,10 +1694,39 @@ struct Decorator::Impl : public ConnectionTracker { if( HANDLE_TYPE_COUNT != mHandleScrolling ) { + float x = 0.f; + float y = 0.f; + + switch( mScrollDirection ) + { + case SCROLL_RIGHT: + { + x = mScrollDistance; + break; + } + case SCROLL_LEFT: + { + x = -mScrollDistance; + break; + } + case SCROLL_TOP: + { + y = mScrollDistance; + break; + } + case SCROLL_BOTTOM: + { + y = -mScrollDistance; + break; + } + default: + break; + } + mController.DecorationEvent( mHandleScrolling, HANDLE_SCROLLING, - mScrollDirection == SCROLL_RIGHT ? mScrollDistance : -mScrollDistance, - 0.f ); + x, + y ); } return true; @@ -1647,8 +1734,10 @@ struct Decorator::Impl : public ConnectionTracker ControllerInterface& mController; - TapGestureDetector mTapDetector; - PanGestureDetector mPanGestureDetector; + TapGestureDetector mTapDetector; + PanGestureDetector mPanDetector; + LongPressGestureDetector mLongPressDetector; + 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. @@ -1662,9 +1751,8 @@ struct Decorator::Impl : public ConnectionTracker Actor mHighlightActor; ///< Actor to display highlight Renderer mHighlightRenderer; - Material mHighlightMaterial; ///< Material used for highlight + Shader mHighlightShader; ///< Shader used for highlight Property::Map mQuadVertexFormat; - Property::Map mQuadIndexFormat; PopupImpl mCopyPastePopup; TextSelectionPopup::Buttons mEnabledPopupButtons; /// Bit mask of currently enabled Popup buttons TextSelectionPopupCallbackInterface& mTextSelectionPopupCallbackInterface; @@ -1676,7 +1764,6 @@ struct Decorator::Impl : public ConnectionTracker HandleImpl mHandle[HANDLE_TYPE_COUNT]; PropertyBuffer mQuadVertices; - PropertyBuffer mQuadIndices; Geometry mQuadGeometry; QuadContainer mHighlightQuadList; ///< Sub-selections that combine to create the complete selection highlight @@ -1705,10 +1792,13 @@ struct Decorator::Impl : public ConnectionTracker bool mFlipSelectionHandlesOnCross : 1; ///< Whether to flip the selection handles as soon as they cross. bool mFlipLeftSelectionHandleDirection : 1; ///< Whether to flip the left selection handle image because of the character's direction. bool mFlipRightSelectionHandleDirection : 1; ///< Whether to flip the right selection handle image because of the character's direction. - bool mHandlePanning : 1; ///< Whether any of the handles is moving. - bool mHandleCurrentCrossed : 1; ///< Whether the handles are crossed. - bool mHandlePreviousCrossed : 1; ///< Whether the handles where crossed at the last handle touch up. + bool mIsHandlePanning : 1; ///< Whether any of the handles is moving. + bool mIsHandleCurrentlyCrossed : 1; ///< Whether the handles are crossed. + bool mIsHandlePreviouslyCrossed : 1; ///< Whether the handles where crossed at the last handle touch up. bool mNotifyEndOfScroll : 1; ///< Whether to notify the end of the scroll. + bool mHorizontalScrollingEnabled : 1; ///< Whether the horizontal scrolling is enabled. + bool mVerticalScrollingEnabled : 1; ///< Whether the vertical scrolling is enabled. + bool mSmoothHandlePanEnabled : 1; ///< Whether to pan smoothly the handles. }; DecoratorPtr Decorator::New( ControllerInterface& controller, @@ -1752,18 +1842,22 @@ unsigned int Decorator::GetActiveCursor() const void Decorator::SetPosition( Cursor cursor, float x, float y, float cursorHeight, float lineHeight ) { - mImpl->mCursor[cursor].position.x = x; - mImpl->mCursor[cursor].position.y = y; - mImpl->mCursor[cursor].cursorHeight = cursorHeight; - mImpl->mCursor[cursor].lineHeight = lineHeight; + Impl::CursorImpl& cursorImpl = mImpl->mCursor[cursor]; + + cursorImpl.position.x = x; + cursorImpl.position.y = y; + cursorImpl.cursorHeight = cursorHeight; + cursorImpl.lineHeight = lineHeight; } void Decorator::GetPosition( Cursor cursor, float& x, float& y, float& cursorHeight, float& lineHeight ) const { - x = mImpl->mCursor[cursor].position.x; - y = mImpl->mCursor[cursor].position.y; - cursorHeight = mImpl->mCursor[cursor].cursorHeight; - lineHeight = mImpl->mCursor[cursor].lineHeight; + const Impl::CursorImpl& cursorImpl = mImpl->mCursor[cursor]; + + x = cursorImpl.position.x; + y = cursorImpl.position.y; + cursorHeight = cursorImpl.cursorHeight; + lineHeight = cursorImpl.lineHeight; } const Vector2& Decorator::GetPosition( Cursor cursor ) const @@ -1851,7 +1945,7 @@ void Decorator::SetHandleActive( HandleType handleType, bool active ) { if( ( LEFT_SELECTION_HANDLE == handleType ) || ( RIGHT_SELECTION_HANDLE == handleType ) ) { - mImpl->mHandlePreviousCrossed = false; + mImpl->mIsHandlePreviouslyCrossed = false; } // TODO: this is a work-around. @@ -1898,12 +1992,15 @@ void Decorator::SetPosition( HandleType handleType, float x, float y, float heig // Adjust handle's displacement Impl::HandleImpl& handle = mImpl->mHandle[handleType]; - handle.grabDisplacementX -= x - handle.position.x; - handle.grabDisplacementY -= y - handle.position.y; - handle.position.x = x; handle.position.y = y; handle.lineHeight = height; + + if( mImpl->mSmoothHandlePanEnabled ) + { + handle.grabDisplacementX = 0.f; + handle.grabDisplacementY = 0.f; + } } void Decorator::GetPosition( HandleType handleType, float& x, float& y, float& height ) const @@ -1937,7 +2034,7 @@ void Decorator::FlipSelectionHandlesOnCrossEnabled( bool enable ) void Decorator::SetSelectionHandleFlipState( bool indicesSwapped, bool left, bool right ) { - mImpl->mHandleCurrentCrossed = indicesSwapped; + mImpl->mIsHandleCurrentlyCrossed = indicesSwapped; mImpl->mFlipLeftSelectionHandleDirection = left; mImpl->mFlipRightSelectionHandleDirection = right; } @@ -2027,6 +2124,36 @@ void Decorator::NotifyEndOfScroll() mImpl->NotifyEndOfScroll(); } +void Decorator::SetHorizontalScrollEnabled( bool enable ) +{ + mImpl->mHorizontalScrollingEnabled = enable; +} + +bool Decorator::IsHorizontalScrollEnabled() const +{ + return mImpl->mHorizontalScrollingEnabled; +} + +void Decorator::SetVerticalScrollEnabled( bool enable ) +{ + mImpl->mVerticalScrollingEnabled = enable; +} + +bool Decorator::IsVerticalScrollEnabled() const +{ + return mImpl->mVerticalScrollingEnabled; +} + +void Decorator::SetSmoothHandlePanEnabled( bool enable ) +{ + mImpl->mSmoothHandlePanEnabled = enable; +} + +bool Decorator::IsSmoothHandlePanEnabled() const +{ + return mImpl->mSmoothHandlePanEnabled; +} + Decorator::~Decorator() { delete mImpl;