X-Git-Url: http://review.tizen.org/git/?a=blobdiff_plain;f=dali-toolkit%2Finternal%2Ftext%2Fdecorator%2Ftext-decorator.cpp;h=5d3976c0007c274c2b1e5030ba856946bff3c64f;hb=8d522afed46c436b653f991b7e383fae80eee7df;hp=6541b7728bb95cf3c62a7d99a503108d4459fdf7;hpb=669373aecf093fe345b679b0ebe1e8056b12af2c;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 6541b77..5d3976c 100644 --- a/dali-toolkit/internal/text/decorator/text-decorator.cpp +++ b/dali-toolkit/internal/text/decorator/text-decorator.cpp @@ -85,11 +85,6 @@ Integration::Log::Filter* gLogFilter( Integration::Log::Filter::New(Debug::NoLog // Local Data namespace { - -const char* DEFAULT_GRAB_HANDLE_IMAGE_RELEASED( DALI_IMAGE_DIR "cursor_handler_center.png" ); - -const int DEFAULT_POPUP_OFFSET( -100.0f ); // Vertical offset of Popup from cursor or handles position. - const Dali::Vector3 DEFAULT_GRAB_HANDLE_RELATIVE_SIZE( 1.25f, 1.5f, 1.0f ); const Dali::Vector3 DEFAULT_SELECTION_HANDLE_RELATIVE_SIZE( 1.25f, 1.5f, 1.0f ); @@ -219,6 +214,7 @@ struct Decorator::Impl : public ConnectionTracker active( false ), visible( false ), pressed( false ), + verticallyFlippedPreferred( false ), horizontallyFlipped( false ), verticallyFlipped( false ) { @@ -236,21 +232,20 @@ struct Decorator::Impl : public ConnectionTracker bool active : 1; bool visible : 1; bool pressed : 1; - bool horizontallyFlipped : 1; ///< Whether the handle has been horizontally flipped. - bool verticallyFlipped : 1; ///< Whether the handle has been vertically flipped. + bool verticallyFlippedPreferred : 1; ///< Whether the handle is preferred to be vertically flipped. + bool horizontallyFlipped : 1; ///< Whether the handle has been horizontally flipped. + bool verticallyFlipped : 1; ///< Whether the handle has been vertically flipped. }; struct PopupImpl { PopupImpl() - : position(), - offset( DEFAULT_POPUP_OFFSET ) + : position() { } TextSelectionPopup actor; Vector3 position; - int offset; }; Impl( ControllerInterface& controller, @@ -299,6 +294,8 @@ struct Decorator::Impl : public ConnectionTracker */ void Relayout( const Vector2& size ) { + mControlSize = size; + // TODO - Remove this if nothing is active CreateActiveLayer(); @@ -308,13 +305,11 @@ struct Decorator::Impl : public ConnectionTracker if( mPrimaryCursor ) { const CursorImpl& cursor = mCursor[PRIMARY_CURSOR]; - mPrimaryCursorVisible = ( cursor.position.x <= size.width ) && ( cursor.position.x >= 0.f ); + mPrimaryCursorVisible = ( cursor.position.x + mCursorWidth <= mControlSize.width ) && ( cursor.position.x >= 0.f ); if( mPrimaryCursorVisible ) { - const Vector2& position = cursor.position; - - mPrimaryCursor.SetPosition( position.x, - position.y ); + mPrimaryCursor.SetPosition( cursor.position.x, + cursor.position.y ); mPrimaryCursor.SetSize( Size( mCursorWidth, cursor.cursorHeight ) ); } mPrimaryCursor.SetVisible( mPrimaryCursorVisible && mCursorBlinkStatus ); @@ -322,7 +317,7 @@ struct Decorator::Impl : public ConnectionTracker if( mSecondaryCursor ) { const CursorImpl& cursor = mCursor[SECONDARY_CURSOR]; - mSecondaryCursorVisible = ( cursor.position.x <= size.width ) && ( cursor.position.x >= 0.f ); + mSecondaryCursorVisible = ( cursor.position.x + mCursorWidth <= mControlSize.width ) && ( cursor.position.x >= 0.f ); if( mSecondaryCursorVisible ) { mSecondaryCursor.SetPosition( cursor.position.x, @@ -334,11 +329,10 @@ struct Decorator::Impl : public ConnectionTracker // Show or hide the grab handle HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + bool newGrabHandlePosition = false; if( grabHandle.active ) { - const Vector2& position = grabHandle.position; - - const bool isVisible = ( position.x <= size.width ) && ( position.x >= 0.f ); + const bool isVisible = ( grabHandle.position.x + floor( 0.5f * mCursorWidth ) <= mControlSize.width ) && ( grabHandle.position.x >= 0.f ); if( isVisible ) { @@ -349,8 +343,14 @@ struct Decorator::Impl : public ConnectionTracker // Sets the grab handle image according if it's pressed, flipped, etc. SetHandleImage( GRAB_HANDLE ); + + newGrabHandlePosition = true; + } + + if( grabHandle.actor ) + { + grabHandle.actor.SetVisible( isVisible ); } - grabHandle.actor.SetVisible( isVisible ); } else if( grabHandle.actor ) { @@ -360,13 +360,12 @@ struct Decorator::Impl : public ConnectionTracker // Show or hide the selection handles/highlight HandleImpl& primary = mHandle[ LEFT_SELECTION_HANDLE ]; HandleImpl& secondary = mHandle[ RIGHT_SELECTION_HANDLE ]; + bool newPrimaryHandlePosition = false; + bool newSecondaryHandlePosition = false; if( primary.active || secondary.active ) { - const Vector2& primaryPosition = primary.position; - const Vector2& secondaryPosition = secondary.position; - - const bool isPrimaryVisible = ( primaryPosition.x <= size.width ) && ( primaryPosition.x >= 0.f ); - const bool isSecondaryVisible = ( secondaryPosition.x <= size.width ) && ( secondaryPosition.x >= 0.f ); + 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 ); if( isPrimaryVisible || isSecondaryVisible ) { @@ -380,6 +379,8 @@ struct Decorator::Impl : public ConnectionTracker SetHandleImage( LEFT_SELECTION_HANDLE ); SetSelectionHandleMarkerSize( primary ); + + newPrimaryHandlePosition = true; } if( isSecondaryVisible ) @@ -390,10 +391,19 @@ struct Decorator::Impl : public ConnectionTracker SetHandleImage( RIGHT_SELECTION_HANDLE ); SetSelectionHandleMarkerSize( secondary ); + + newSecondaryHandlePosition = true; } } - primary.actor.SetVisible( isPrimaryVisible ); - secondary.actor.SetVisible( isSecondaryVisible ); + + if( primary.actor ) + { + primary.actor.SetVisible( isPrimaryVisible ); + } + if( secondary.actor ) + { + secondary.actor.SetVisible( isSecondaryVisible ); + } CreateHighlight(); UpdateHighlight(); @@ -414,6 +424,14 @@ struct Decorator::Impl : public ConnectionTracker } } + if( newGrabHandlePosition || + newPrimaryHandlePosition || + newSecondaryHandlePosition ) + { + // Setup property notifications to find whether the handles leave the boundaries of the current display. + SetupActiveLayerPropertyNotifications(); + } + if( mActiveCopyPastePopup ) { ShowPopup(); @@ -456,32 +474,40 @@ struct Decorator::Impl : public ConnectionTracker void DeterminePositionPopup() { - if ( !mActiveCopyPastePopup ) + if( !mActiveCopyPastePopup ) { return; } + // Retrieves the popup's size after relayout. + const Vector3 popupSize = Vector3( mCopyPastePopup.actor.GetRelayoutSize( Dimension::WIDTH ), mCopyPastePopup.actor.GetRelayoutSize( Dimension::HEIGHT ), 0.0f ); + if( mPopupSetNewPosition ) { - if ( mHandle[LEFT_SELECTION_HANDLE].active || mHandle[RIGHT_SELECTION_HANDLE].active ) - { - float minHandleXPosition = std::min ( mHandle[LEFT_SELECTION_HANDLE].position.x, mHandle[RIGHT_SELECTION_HANDLE].position.x ); - float maxHandleXPosition = std::max ( mHandle[LEFT_SELECTION_HANDLE].position.x, mHandle[RIGHT_SELECTION_HANDLE].position.x ); + 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]; - float minHandleYPosition = std::min ( mHandle[LEFT_SELECTION_HANDLE].position.y, mHandle[RIGHT_SELECTION_HANDLE].position.y ); + if( primaryHandle.active || secondaryHandle.active ) + { + // Calculates the popup's position if selection handles are active. + const float minHandleXPosition = std::min( primaryHandle.position.x, secondaryHandle.position.x ); + const float maxHandleXPosition = std::max( primaryHandle.position.x, secondaryHandle.position.x ); + const float maxHandleHeight = std::max( primaryHandle.size.height, secondaryHandle.size.height ); - mCopyPastePopup.position.x = minHandleXPosition + ( ( maxHandleXPosition - minHandleXPosition ) *0.5f ); - mCopyPastePopup.position.y = minHandleYPosition + mCopyPastePopup.offset; + mCopyPastePopup.position.x = minHandleXPosition + ( ( maxHandleXPosition - minHandleXPosition ) * 0.5f ); + mCopyPastePopup.position.y = -0.5f * popupSize.height - maxHandleHeight + std::min( primaryHandle.position.y, secondaryHandle.position.y ); } else { - mCopyPastePopup.position = Vector3( mCursor[PRIMARY_CURSOR].position.x, mCursor[PRIMARY_CURSOR].position.y -100.0f , 0.0f ); //todo 100 to be an offset Property + // 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 ); } } - Vector3 popupSize = Vector3( mCopyPastePopup.actor.GetRelayoutSize( Dimension::WIDTH ), mCopyPastePopup.actor.GetRelayoutSize( Dimension::HEIGHT ), 0.0f ); - - GetConstrainedPopupPosition( mCopyPastePopup.position, popupSize, AnchorPoint::CENTER, mActiveLayer, mBoundingBox ); + // Checks if there is enough space above the text control. If not it places the popup under it. + GetConstrainedPopupPosition( mCopyPastePopup.position, popupSize * AnchorPoint::CENTER, mActiveLayer, mBoundingBox ); SetUpPopupPositionNotifications(); @@ -619,7 +645,7 @@ struct Decorator::Impl : public ConnectionTracker void SetSelectionHandleMarkerSize( HandleImpl& handle ) { - if ( handle.markerActor ) + if( handle.markerActor ) { handle.markerActor.SetSize( 0, handle.lineHeight ); } @@ -630,11 +656,6 @@ struct Decorator::Impl : public ConnectionTracker HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; if( !grabHandle.actor ) { - if( !mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_RELEASED] ) - { - SetHandleImage( GRAB_HANDLE, HANDLE_IMAGE_RELEASED, ResourceImage::New( DEFAULT_GRAB_HANDLE_IMAGE_RELEASED ) ); - } - grabHandle.actor = ImageActor::New( mHandleImages[GRAB_HANDLE][HANDLE_IMAGE_RELEASED] ); grabHandle.actor.SetSortModifier( DECORATION_DEPTH_INDEX ); grabHandle.actor.SetAnchorPoint( AnchorPoint::TOP_CENTER ); @@ -677,7 +698,7 @@ struct Decorator::Impl : public ConnectionTracker void CreateHandleMarker( HandleImpl& handle, Image& image, HandleType handleType ) { - if ( image ) + if( image ) { handle.markerActor = ImageActor::New( image ); handle.markerActor.SetColor( mHandleColor ); @@ -685,12 +706,12 @@ struct Decorator::Impl : public ConnectionTracker handle.markerActor.SetResizePolicy ( ResizePolicy::FIXED, Dimension::HEIGHT ); - if ( LEFT_SELECTION_HANDLE == handleType ) + if( LEFT_SELECTION_HANDLE == handleType ) { handle.markerActor.SetAnchorPoint( AnchorPoint::BOTTOM_RIGHT ); handle.markerActor.SetParentOrigin( ParentOrigin::TOP_RIGHT ); } - else if ( RIGHT_SELECTION_HANDLE == handleType ) + else if( RIGHT_SELECTION_HANDLE == handleType ) { handle.markerActor.SetAnchorPoint( AnchorPoint::BOTTOM_LEFT ); handle.markerActor.SetParentOrigin( ParentOrigin::TOP_LEFT ); @@ -771,16 +792,14 @@ struct Decorator::Impl : public ConnectionTracker void CalculateHandleWorldCoordinates( HandleImpl& handle, Vector2& position ) { - // Get the world position of the active layer + // Gets the world position of the active layer. The active layer is where the handles are added. const Vector3 parentWorldPosition = mActiveLayer.GetCurrentWorldPosition(); - // Get the size of the UI control. - Vector2 targetSize; - mController.GetTargetSize( targetSize ); - // The grab handle position in world coords. - position.x = parentWorldPosition.x - 0.5f * targetSize.width + handle.position.x; - position.y = parentWorldPosition.y - 0.5f * targetSize.height + handle.position.y + handle.lineHeight; + // 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; } void SetGrabHandlePosition() @@ -788,13 +807,21 @@ struct Decorator::Impl : public ConnectionTracker // Reference to the grab handle. HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; - // The grab handle position in world coords. + // Transforms the handle position into world coordinates. + // @note This is not the same value as grabHandle.actor.GetCurrentWorldPosition() + // as it's transforming the handle's position set by the text-controller and not + // the final position set to the actor. Another difference is the GetCurrentWorldPosition() + // retrieves the position of the center of the actor but the handle's position set + // by the text controller is not the center of the actor. Vector2 grabHandleWorldPosition; CalculateHandleWorldCoordinates( grabHandle, grabHandleWorldPosition ); // Check if the grab handle exceeds the boundaries of the decoration box. // At the moment only the height is checked for the grab handle. - grabHandle.verticallyFlipped = ( grabHandleWorldPosition.y + grabHandle.size.height > mBoundingBox.w ); + + grabHandle.verticallyFlipped = ( grabHandle.verticallyFlippedPreferred && + ( ( grabHandleWorldPosition.y - grabHandle.size.height ) > mBoundingBox.y ) ) || + ( grabHandleWorldPosition.y + grabHandle.lineHeight + grabHandle.size.height > mBoundingBox.w ); // The grab handle 'y' position in local coords. // If the grab handle exceeds the bottom of the decoration box, @@ -802,7 +829,7 @@ struct Decorator::Impl : public ConnectionTracker // The SetGrabHandleImage() method will change the orientation. const float yLocalPosition = grabHandle.verticallyFlipped ? grabHandle.position.y : grabHandle.position.y + grabHandle.lineHeight; - grabHandle.actor.SetPosition( grabHandle.position.x - floor( 0.5f * mCursorWidth ), + grabHandle.actor.SetPosition( grabHandle.position.x + floor( 0.5f * mCursorWidth ), yLocalPosition ); // TODO : Fix for multiline. } @@ -813,11 +840,16 @@ struct Decorator::Impl : public ConnectionTracker // Reference to the selection handle. HandleImpl& handle = mHandle[type]; - // Get the world coordinates of the handle position. + // Transforms the handle position into world coordinates. + // @note This is not the same value as handle.actor.GetCurrentWorldPosition() + // as it's transforming the handle's position set by the text-controller and not + // the final position set to the actor. Another difference is the GetCurrentWorldPosition() + // retrieves the position of the center of the actor but the handle's position set + // by the text controller is not the center of the actor. Vector2 handleWorldPosition; CalculateHandleWorldCoordinates( handle, handleWorldPosition ); - // Whether to flip the handle. + // Whether to flip the handle (horizontally). bool flipHandle = isPrimaryHandle ? mFlipLeftSelectionHandleDirection : mFlipRightSelectionHandleDirection; // Whether to flip the handles if they are crossed. @@ -830,9 +862,23 @@ struct Decorator::Impl : public ConnectionTracker // Does not flip if both conditions are true (double flip) flipHandle = flipHandle != ( crossFlip || mHandlePreviousCrossed ); + // Will flip the handles vertically if the user prefers it. + bool verticallyFlippedPreferred = handle.verticallyFlippedPreferred; + + if( crossFlip || mHandlePreviousCrossed ) + { + if( isPrimaryHandle ) + { + verticallyFlippedPreferred = mHandle[RIGHT_SELECTION_HANDLE].verticallyFlippedPreferred; + } + else + { + verticallyFlippedPreferred = mHandle[LEFT_SELECTION_HANDLE].verticallyFlippedPreferred; + } + } + // Check if the selection handle exceeds the boundaries of the decoration box. const bool exceedsLeftEdge = ( isPrimaryHandle ? !flipHandle : flipHandle ) && ( handleWorldPosition.x - handle.size.width < mBoundingBox.x ); - const bool exceedsRightEdge = ( isPrimaryHandle ? flipHandle : !flipHandle ) && ( handleWorldPosition.x + handle.size.width > mBoundingBox.z ); // Does not flip if both conditions are true (double flip) @@ -860,7 +906,9 @@ struct Decorator::Impl : public ConnectionTracker } // Whether to flip the handle vertically. - handle.verticallyFlipped = ( handleWorldPosition.y + handle.size.height > mBoundingBox.w ); + handle.verticallyFlipped = ( verticallyFlippedPreferred && + ( ( handleWorldPosition.y - handle.size.height ) > mBoundingBox.y ) ) || + ( handleWorldPosition.y + handle.lineHeight + handle.size.height > mBoundingBox.w ); // The primary selection handle 'y' position in local coords. // If the handle exceeds the bottom of the decoration box, @@ -890,18 +938,27 @@ struct Decorator::Impl : public ConnectionTracker } // Chooses between the released or pressed image. It checks whether the pressed image exists. - const HandleImageType imageType = ( handle.pressed ? ( mHandleImages[type][HANDLE_IMAGE_PRESSED] ? HANDLE_IMAGE_PRESSED : HANDLE_IMAGE_RELEASED ) : HANDLE_IMAGE_RELEASED ); + if( handle.actor ) + { + const HandleImageType imageType = ( handle.pressed ? ( mHandleImages[type][HANDLE_IMAGE_PRESSED] ? HANDLE_IMAGE_PRESSED : HANDLE_IMAGE_RELEASED ) : HANDLE_IMAGE_RELEASED ); - handle.actor.SetImage( mHandleImages[type][imageType] ); + handle.actor.SetImage( mHandleImages[type][imageType] ); + } if( HANDLE_TYPE_COUNT != markerType ) { - const HandleImageType markerImageType = ( handle.pressed ? ( mHandleImages[markerType][HANDLE_IMAGE_PRESSED] ? HANDLE_IMAGE_PRESSED : HANDLE_IMAGE_RELEASED ) : HANDLE_IMAGE_RELEASED ); - handle.markerActor.SetImage( mHandleImages[markerType][markerImageType] ); + if( handle.markerActor ) + { + const HandleImageType markerImageType = ( handle.pressed ? ( mHandleImages[markerType][HANDLE_IMAGE_PRESSED] ? HANDLE_IMAGE_PRESSED : HANDLE_IMAGE_RELEASED ) : HANDLE_IMAGE_RELEASED ); + handle.markerActor.SetImage( mHandleImages[markerType][markerImageType] ); + } } // Whether to flip the handle vertically. - handle.actor.SetOrientation( handle.verticallyFlipped ? ANGLE_180 : ANGLE_0, Vector3::XAXIS ); + if( handle.actor ) + { + handle.actor.SetOrientation( handle.verticallyFlipped ? ANGLE_180 : ANGLE_0, Vector3::XAXIS ); + } } void CreateHighlight() @@ -1188,30 +1245,234 @@ struct Decorator::Impl : public ConnectionTracker return true; } - // Popup + void HandleResetPosition( PropertyNotification& source ) + { + const HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; - float AlternatePopUpPositionRelativeToCursor() + if( grabHandle.active ) + { + // Sets the grab handle position and calculates if it needs to be vertically flipped if it exceeds the boundary box. + SetGrabHandlePosition(); + + // Sets the grab handle image according if it's pressed, flipped, etc. + SetHandleImage( GRAB_HANDLE ); + } + else + { + // Sets the primary selection handle position and calculates if it needs to be vertically flipped if it exceeds the boundary box. + SetSelectionHandlePosition( LEFT_SELECTION_HANDLE ); + + // Sets the primary handle image according if it's pressed, flipped, etc. + SetHandleImage( LEFT_SELECTION_HANDLE ); + + // Sets the secondary selection handle position and calculates if it needs to be vertically flipped if it exceeds the boundary box. + SetSelectionHandlePosition( RIGHT_SELECTION_HANDLE ); + + // Sets the secondary handle image according if it's pressed, flipped, etc. + SetHandleImage( RIGHT_SELECTION_HANDLE ); + } + } + + void SetupActiveLayerPropertyNotifications() { - float alternativePosition=0.0f;; + if( !mActiveLayer ) + { + return; + } + + // Vertical notifications. - if ( mPrimaryCursor ) // Secondary cursor not used for paste + // Disconnect any previous connected callback. + if( mVerticalLessThanNotification ) { - Cursor cursor = PRIMARY_CURSOR; - alternativePosition = mCursor[cursor].position.y; + mVerticalLessThanNotification.NotifySignal().Disconnect( this, &Decorator::Impl::HandleResetPosition ); + mActiveLayer.RemovePropertyNotification( mVerticalLessThanNotification ); } - const float popupHeight = 120.0f; // todo Set as a MaxSize Property in Control or retrieve from CopyPastePopup class. + if( mVerticalGreaterThanNotification ) + { + mVerticalGreaterThanNotification.NotifySignal().Disconnect( this, &Decorator::Impl::HandleResetPosition ); + mActiveLayer.RemovePropertyNotification( mVerticalGreaterThanNotification ); + } - if( mHandle[GRAB_HANDLE].active ) + const HandleImpl& grabHandle = mHandle[GRAB_HANDLE]; + const HandleImpl& primaryHandle = mHandle[LEFT_SELECTION_HANDLE]; + const HandleImpl& secondaryHandle = mHandle[RIGHT_SELECTION_HANDLE]; + + if( grabHandle.active ) { - // If grab handle enabled then position pop-up below the grab handle. - const Vector2 grabHandleSize( 59.0f, 56.0f ); // todo - const float BOTTOM_HANDLE_BOTTOM_OFFSET = 1.5; //todo Should be a property - alternativePosition += grabHandleSize.height + popupHeight + BOTTOM_HANDLE_BOTTOM_OFFSET ; + if( grabHandle.verticallyFlipped ) + { + // The grab handle is vertically flipped. Never is going to exceed the bottom edje of the display. + mVerticalGreaterThanNotification.Reset(); + + // The vertical distance from the center of the active layer to the top edje of the display. + const float topHeight = 0.5f * mControlSize.height - grabHandle.position.y + grabHandle.size.height; + + mVerticalLessThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + LessThanCondition( mBoundingBox.y + topHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalLessThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalLessThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + else + { + // The grab handle is not vertically flipped. Never is going to exceed the top edje of the display. + mVerticalLessThanNotification.Reset(); + + // The vertical distance from the center of the active layer to the bottom edje of the display. + const float bottomHeight = -0.5f * mControlSize.height + grabHandle.position.y + grabHandle.lineHeight + grabHandle.size.height; + + mVerticalGreaterThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + GreaterThanCondition( mBoundingBox.w - bottomHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalGreaterThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalGreaterThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + } + else // The selection handles are active + { + if( primaryHandle.verticallyFlipped && secondaryHandle.verticallyFlipped ) + { + // Both selection handles are vertically flipped. Never are going to exceed the bottom edje of the display. + mVerticalGreaterThanNotification.Reset(); + + // The vertical distance from the center of the active layer to the top edje of the display. + const float topHeight = 0.5f * mControlSize.height + std::max( -primaryHandle.position.y + primaryHandle.size.height, -secondaryHandle.position.y + secondaryHandle.size.height ); + + mVerticalLessThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + LessThanCondition( mBoundingBox.y + topHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalLessThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalLessThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + else if( !primaryHandle.verticallyFlipped && !secondaryHandle.verticallyFlipped ) + { + // Both selection handles aren't vertically flipped. Never are going to exceed the top edje of the display. + mVerticalLessThanNotification.Reset(); + + // The vertical distance from the center of the active layer to the bottom edje of the display. + const float bottomHeight = -0.5f * mControlSize.height + std::max( primaryHandle.position.y + primaryHandle.lineHeight + primaryHandle.size.height, + secondaryHandle.position.y + secondaryHandle.lineHeight + secondaryHandle.size.height ); + + mVerticalGreaterThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + GreaterThanCondition( mBoundingBox.w - bottomHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalGreaterThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalGreaterThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + else + { + // Only one of the selection handles is vertically flipped. Both vertical notifications are needed. + + // The vertical distance from the center of the active layer to the top edje of the display. + const float topHeight = 0.5f * mControlSize.height + ( primaryHandle.verticallyFlipped ? + -primaryHandle.position.y + primaryHandle.size.height : + -secondaryHandle.position.y + secondaryHandle.size.height ); + + mVerticalLessThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + LessThanCondition( mBoundingBox.y + topHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalLessThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalLessThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + + // The vertical distance from the center of the active layer to the bottom edje of the display. + const float bottomHeight = -0.5f * mControlSize.height + ( primaryHandle.verticallyFlipped ? + secondaryHandle.position.y + secondaryHandle.lineHeight + secondaryHandle.size.height : + primaryHandle.position.y + primaryHandle.lineHeight + primaryHandle.size.height ); + + mVerticalGreaterThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, + GreaterThanCondition( mBoundingBox.w - bottomHeight ) ); + + // Notifies the change from false to true and from true to false. + mVerticalGreaterThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mVerticalGreaterThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + } + + // Horizontal notifications. + + // Disconnect any previous connected callback. + if( mHorizontalLessThanNotification ) + { + mHorizontalLessThanNotification.NotifySignal().Disconnect( this, &Decorator::Impl::HandleResetPosition ); + mActiveLayer.RemovePropertyNotification( mHorizontalLessThanNotification ); + } + + if( mHorizontalGreaterThanNotification ) + { + mHorizontalGreaterThanNotification.NotifySignal().Disconnect( this, &Decorator::Impl::HandleResetPosition ); + mActiveLayer.RemovePropertyNotification( mHorizontalGreaterThanNotification ); + } + + if( primaryHandle.active || secondaryHandle.active ) + { + // The horizontal distance from the center of the active layer to the left edje of the display. + const float leftWidth = 0.5f * mControlSize.width + std::max( -primaryHandle.position.x + primaryHandle.size.width, + -secondaryHandle.position.x + secondaryHandle.size.width ); + + mHorizontalLessThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_X, + LessThanCondition( mBoundingBox.x + leftWidth ) ); + + // Notifies the change from false to true and from true to false. + mHorizontalLessThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mHorizontalLessThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + + // The horizontal distance from the center of the active layer to the right edje of the display. + const float rightWidth = -0.5f * mControlSize.width + std::max( primaryHandle.position.x + primaryHandle.size.width, + secondaryHandle.position.x + secondaryHandle.size.width ); + + mHorizontalGreaterThanNotification = mActiveLayer.AddPropertyNotification( Actor::Property::WORLD_POSITION_X, + GreaterThanCondition( mBoundingBox.z - rightWidth ) ); + + // Notifies the change from false to true and from true to false. + mHorizontalGreaterThanNotification.SetNotifyMode( PropertyNotification::NotifyOnChanged ); + + // Connects the signals with the callbacks. + mHorizontalGreaterThanNotification.NotifySignal().Connect( this, &Decorator::Impl::HandleResetPosition ); + } + } + + // Popup + + float AlternatePopUpPositionRelativeToCursor() + { + float alternativePosition = 0.0f; + + const float popupHeight = mCopyPastePopup.actor.GetRelayoutSize( Dimension::HEIGHT ); + + 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 ) + { + const float maxHandleHeight = std::max( primaryHandle.size.height, secondaryHandle.size.height ); + alternativePosition = 0.5f * popupHeight + cursor.lineHeight + maxHandleHeight + std::min( primaryHandle.position.y, secondaryHandle.position.y ); } else { - alternativePosition += popupHeight; + alternativePosition = 0.5f * popupHeight + cursor.lineHeight + grabHandle.size.height + cursor.position.y; } return alternativePosition; @@ -1219,7 +1480,7 @@ struct Decorator::Impl : public ConnectionTracker void PopUpLeavesVerticalBoundary( PropertyNotification& source ) { - float alternativeYPosition=0.0f; + float alternativeYPosition = 0.0f; // todo use AlternatePopUpPositionRelativeToSelectionHandles() if text is highlighted // if can't be positioned above, then position below row. alternativeYPosition = AlternatePopUpPositionRelativeToCursor(); @@ -1227,31 +1488,28 @@ struct Decorator::Impl : public ConnectionTracker mCopyPastePopup.actor.SetY( alternativeYPosition ); } - - void SetUpPopupPositionNotifications( ) + void SetUpPopupPositionNotifications() { // Note Property notifications ignore any set anchor point so conditions must allow for this. Default is Top Left. // Exceeding vertical boundary - float popupHeight = mCopyPastePopup.actor.GetRelayoutSize( Dimension::HEIGHT); + const float popupHeight = mCopyPastePopup.actor.GetRelayoutSize( Dimension::HEIGHT ); PropertyNotification verticalExceedNotification = mCopyPastePopup.actor.AddPropertyNotification( Actor::Property::WORLD_POSITION_Y, - OutsideCondition( mBoundingBox.y + popupHeight * 0.5f, - mBoundingBox.w - popupHeight * 0.5f ) ); + OutsideCondition( mBoundingBox.y + popupHeight * 0.5f, + mBoundingBox.w - popupHeight * 0.5f ) ); verticalExceedNotification.NotifySignal().Connect( this, &Decorator::Impl::PopUpLeavesVerticalBoundary ); } - void GetConstrainedPopupPosition( Vector3& requiredPopupPosition, Vector3& popupSize, Vector3 anchorPoint, Actor& parent, const Vector4& boundingRectangleWorld ) + void GetConstrainedPopupPosition( Vector3& requiredPopupPosition, const Vector3& popupDistanceFromAnchorPoint, Actor parent, const Vector4& boundingRectangleWorld ) { DALI_ASSERT_DEBUG ( "Popup parent not on stage" && parent.OnStage() ) // Parent must already by added to Stage for these Get calls to work - Vector3 parentAnchorPoint = parent.GetCurrentAnchorPoint(); - Vector3 parentWorldPositionLeftAnchor = parent.GetCurrentWorldPosition() - parent.GetCurrentSize()*parentAnchorPoint; - Vector3 popupWorldPosition = parentWorldPositionLeftAnchor + requiredPopupPosition; // Parent World position plus popup local position gives World Position - Vector3 popupDistanceFromAnchorPoint = popupSize*anchorPoint; + const Vector3 parentWorldPositionLeftAnchor = parent.GetCurrentWorldPosition() - parent.GetCurrentSize() * parent.GetCurrentAnchorPoint(); + const Vector3 popupWorldPosition = parentWorldPositionLeftAnchor + requiredPopupPosition; // Parent World position plus popup local position gives World Position // Calculate distance to move popup (in local space) so fits within the boundary float xOffSetToKeepWithinBounds = 0.0f; @@ -1259,13 +1517,13 @@ struct Decorator::Impl : public ConnectionTracker { xOffSetToKeepWithinBounds = boundingRectangleWorld.x - ( popupWorldPosition.x - popupDistanceFromAnchorPoint.x ); } - else if ( popupWorldPosition.x + popupDistanceFromAnchorPoint.x > boundingRectangleWorld.z ) + else if( popupWorldPosition.x + popupDistanceFromAnchorPoint.x > boundingRectangleWorld.z ) { xOffSetToKeepWithinBounds = boundingRectangleWorld.z - ( popupWorldPosition.x + popupDistanceFromAnchorPoint.x ); } // Ensure initial display of Popup is in alternative position if can not fit above. As Property notification will be a frame behind. - if ( popupWorldPosition.y - popupDistanceFromAnchorPoint.y < boundingRectangleWorld.y ) + if( popupWorldPosition.y - popupDistanceFromAnchorPoint.y < boundingRectangleWorld.y ) { requiredPopupPosition.y = AlternatePopUpPositionRelativeToCursor(); } @@ -1273,8 +1531,8 @@ struct Decorator::Impl : public ConnectionTracker requiredPopupPosition.x = requiredPopupPosition.x + xOffSetToKeepWithinBounds; // Prevent pixel mis-alignment by rounding down. - requiredPopupPosition.x = static_cast( requiredPopupPosition.x ); - requiredPopupPosition.y = static_cast( requiredPopupPosition.y ); + requiredPopupPosition.x = floor( requiredPopupPosition.x ); + requiredPopupPosition.y = floor( requiredPopupPosition.y ); } void SetHandleImage( HandleType handleType, HandleImageType handleImageType, Dali::Image image ) @@ -1371,11 +1629,15 @@ struct Decorator::Impl : public ConnectionTracker 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; + Layer mActiveLayer; ///< Layer for active handles and alike that ensures they are above all else. + PropertyNotification mVerticalLessThanNotification; ///< Notifies when the 'y' coord of the active layer is less than a given value. + PropertyNotification mVerticalGreaterThanNotification; ///< Notifies when the 'y' coord of the active layer is grater than a given value. + PropertyNotification mHorizontalLessThanNotification; ///< Notifies when the 'x' coord of the active layer is less than a given value. + PropertyNotification mHorizontalGreaterThanNotification; ///< Notifies when the 'x' coord of the active layer is grater than a given value. + ImageActor mPrimaryCursor; + ImageActor mSecondaryCursor; - Actor mHighlightActor; ///< Actor to display highlight + Actor mHighlightActor; ///< Actor to display highlight Renderer mHighlightRenderer; Material mHighlightMaterial; ///< Material used for highlight Property::Map mQuadVertexFormat; @@ -1398,6 +1660,7 @@ struct Decorator::Impl : public ConnectionTracker Vector4 mBoundingBox; ///< The bounding box in world coords. Vector4 mHighlightColor; ///< Color of the highlight Vector2 mHighlightPosition; ///< The position of the highlight actor. + Vector2 mControlSize; ///< The control's size. Set by the Relayout. unsigned int mActiveCursor; unsigned int mCursorBlinkInterval; @@ -1634,6 +1897,16 @@ const Vector2& Decorator::GetPosition( HandleType handleType ) const return mImpl->mHandle[handleType].position; } +void Decorator::FlipHandleVertically( HandleType handleType, bool flip ) +{ + mImpl->mHandle[handleType].verticallyFlippedPreferred = flip; +} + +bool Decorator::IsHandleVerticallyFlipped( HandleType handleType ) const +{ + return mImpl->mHandle[handleType].verticallyFlippedPreferred; +} + void Decorator::FlipSelectionHandlesOnCrossEnabled( bool enable ) { mImpl->mFlipSelectionHandlesOnCross = enable;