application.Render();
Actor layer = editor.GetChildAt( 1u );
- DALI_TEST_CHECK( layer.GetProperty< bool >( Actor::Property::IS_LAYER ) );
-
DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
// The text is not selected and not changed because of 'SetProperty( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION, false )'
DALI_TEST_EQUALS( "Hello\nld\nHello lo\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
+ // Select all Text
+ application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
+
+ // Render and notify
+ application.SendNotification();
+ application.Render();
+
+ // replace text with "c"
+ application.ProcessEvent( GenerateKey( "c", "", "c", KEY_C_CODE, 0, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
+
+ // Render and notify
+ application.SendNotification();
+ application.Render();
+
+ //text is "c"
+ DALI_TEST_EQUALS( "c", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
+
END_TEST;
}
END_TEST;
}
+
+int UtcDaliTextEditorSelectRange(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline("utcDaliTextEditorSelectRange");
+
+ TextEditor textEditor = TextEditor::New();
+ DALI_TEST_CHECK( textEditor );
+
+ application.GetScene().Add( textEditor );
+
+ // Avoid a crash when core load gl resources.
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+
+ application.SendNotification();
+ application.Render();
+
+ textEditor.SetProperty( TextEditor::Property::TEXT, "Hello world" );
+
+ textEditor.SetProperty( DevelTextEditor::Property::SELECTED_TEXT_START, 0 );
+ textEditor.SetProperty( DevelTextEditor::Property::SELECTED_TEXT_END, 5 );
+
+ DALI_TEST_EQUALS( textEditor.GetProperty( DevelTextEditor::Property::SELECTED_TEXT_START ).Get<int>(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( textEditor.GetProperty( DevelTextEditor::Property::SELECTED_TEXT_END ).Get<int>(), 5, TEST_LOCATION );
+
+ END_TEST;
+}
\ No newline at end of file
application.Render();
Actor layer = field.GetChildAt( 1u );
- DALI_TEST_CHECK( layer.GetProperty< bool >( Actor::Property::IS_LAYER ) );
-
DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
END_TEST;
}
+
+int UtcDaliTextFieldSelectRange(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" UtcDaliTextFieldSelectRange ");
+
+ TextField textField = TextField::New();
+
+ application.GetScene().Add( textField );
+
+ textField.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
+ textField.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
+ textField.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
+
+ // Avoid a crash when core load gl resources.
+ application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
+
+ application.SendNotification();
+ application.Render();
+
+ textField.SetProperty( TextField::Property::TEXT, "Hello world" );
+
+ application.SendNotification();
+ application.Render();
+
+ textField.SetProperty( DevelTextField::Property::SELECTED_TEXT_START , 0);
+ textField.SetProperty( DevelTextField::Property::SELECTED_TEXT_END , 5);
+
+ // Hello is selected
+ std::string selectedText = textField.GetProperty( DevelTextField::Property::SELECTED_TEXT ).Get<std::string>();
+ DALI_TEST_EQUALS( "Hello", selectedText, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( textField.GetProperty( DevelTextField::Property::SELECTED_TEXT_START ).Get<int>(), 0, TEST_LOCATION );
+ DALI_TEST_EQUALS( textField.GetProperty( DevelTextField::Property::SELECTED_TEXT_END ).Get<int>(), 5, TEST_LOCATION );
+
+ textField.SetProperty( DevelTextField::Property::SELECTED_TEXT_START , 6);
+ textField.SetProperty( DevelTextField::Property::SELECTED_TEXT_END , 11);
+
+ // world is selected
+ selectedText = textField.GetProperty( DevelTextField::Property::SELECTED_TEXT ).Get<std::string>();
+ DALI_TEST_EQUALS( "world", selectedText, TEST_LOCATION );
+
+ DALI_TEST_EQUALS( textField.GetProperty( DevelTextField::Property::SELECTED_TEXT_START ).Get<int>(), 6, TEST_LOCATION );
+ DALI_TEST_EQUALS( textField.GetProperty( DevelTextField::Property::SELECTED_TEXT_END ).Get<int>(), 11, TEST_LOCATION );
+
+ END_TEST;
+}
VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::ENABLED );
DALI_TEST_CHECK( videoView );
+ application.GetScene().Add( videoView );
+
// Build the animation
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
VideoView videoView = DevelVideoView::New( Dali::VideoSyncMode::DISABLED );
DALI_TEST_CHECK( videoView );
+ application.GetScene().Add( videoView );
+
// Build the animation
float durationSeconds(1.0f);
Animation animation = Animation::New(durationSeconds);
RENDERING_BACKEND,
/**
- * @brief The maximum number of characters that can be inserted.
- * @details Name "maxLength", type Property::INTEGER.
- */
+ * @brief The maximum number of characters that can be inserted.
+ * @details Name "maxLength", type Property::INTEGER.
+ */
MAX_LENGTH,
+
+ /**
+ * @brief The selected text start position.
+ * @details Name "selectedTextStart", type Property::INTEGER.
+ */
+ SELECTED_TEXT_START,
+
+ /**
+ * @brief The selected text range end position.
+ * @details Name "selectedTextEnd", type Property::INTEGER.
+ */
+ SELECTED_TEXT_END,
};
} // namespace Property
*/
RENDERING_BACKEND = ELLIPSIS + 7,
+ /**
+ * @brief The selected text start position.
+ * @details Name "selectedTextStart", type Property::INTEGER.
+ */
+ SELECTED_TEXT_START,
+
+ /**
+ * @brief The selected text range end position.
+ * @details Name "selectedTextEnd", type Property::INTEGER.
+ */
+ SELECTED_TEXT_END,
+
};
+
} // namespace Property
/**
GetImpl(*this).EnableButtons(buttonsToEnable);
}
-void TextSelectionPopup::RaiseAbove(Layer target)
+void TextSelectionPopup::RaiseAbove(Actor target)
{
GetImpl(*this).RaiseAbove(target);
}
void EnableButtons(Toolkit::TextSelectionPopup::Buttons buttonsToEnable);
/**
- * @brief Raises the toolbar's layer above the given @e target layer.
+ * @brief Raises the toolbar's actor above the given @e target actor.
*
- * @param[in] target The layer to get above of.
+ * @param[in] target The actor to get above of.
*/
- void RaiseAbove(Layer target);
+ void RaiseAbove(Actor target);
/**
* @brief Show the Popup if not being shown
GetImpl(*this).ResizeDividers(size);
}
-void TextSelectionToolbar::RaiseAbove(Layer target)
+void TextSelectionToolbar::RaiseAbove(Actor target)
{
GetImpl(*this).RaiseAbove(target);
}
void ResizeDividers(Size& size);
/**
- * @brief Raises the layer above the given @e target layer.
+ * @brief Raises the actor above the given @e target actor.
*
- * @param[in] target The layer to get above of.
+ * @param[in] target The actor to get above of.
*/
- void RaiseAbove(Layer target);
+ void RaiseAbove(Actor target);
/**
* @copydoc Toolkit::ScrollView::ScrollTo(const Vector2&)
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "matchSystemLanguageDirection", BOOLEAN, MATCH_SYSTEM_LANGUAGE_DIRECTION )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "renderingBackend", INTEGER, RENDERING_BACKEND )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "maxLength", INTEGER, MAX_LENGTH )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "selectedTextStart", INTEGER, SELECTED_TEXT_START )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextEditor, "selectedTextEnd", INTEGER, SELECTED_TEXT_END )
DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, TextEditor, "inputStyleChanged", SIGNAL_INPUT_STYLE_CHANGED )
}
break;
}
+ case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START:
+ {
+ if( impl.mController )
+ {
+ uint32_t start = static_cast<uint32_t>(value.Get< int >());
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p SELECTED_TEXT_START %d\n", impl.mController.Get(), start );
+ impl.SetTextSelectionRange( &start, nullptr );
+ }
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END:
+ {
+ if( impl.mController )
+ {
+ uint32_t end = static_cast<uint32_t>(value.Get< int >());
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextEditor %p SELECTED_TEXT_END %d\n", impl.mController.Get(), end );
+ impl.SetTextSelectionRange( nullptr, &end );
+ }
+ break;
+ }
} // switch
} // texteditor
}
}
break;
}
+ case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_START:
+ {
+ Uint32Pair range = impl.GetTextSelectionRange();
+ value = static_cast<int>(range.first);
+ break;
+ }
+ case Toolkit::DevelTextEditor::Property::SELECTED_TEXT_END:
+ {
+ Uint32Pair range = impl.GetTextSelectionRange();
+ value = static_cast<int>(range.second);
+ break;
+ }
} //switch
}
{
Actor self = Self();
- mController = Text::Controller::New( this, this );
+ mController = Text::Controller::New( this, this, this);
mDecorator = Text::Decorator::New( *mController,
*mController );
}
}
+void TextEditor::SetTextSelectionRange(const uint32_t *start, const uint32_t *end)
+{
+ if( mController && mController->IsShowingRealText() )
+ {
+ mController->SetTextSelectionRange( start, end );
+ SetKeyInputFocus();
+ }
+}
+
+Uint32Pair TextEditor::GetTextSelectionRange() const
+{
+ Uint32Pair range(0, 0);
+ if( mController && mController->IsShowingRealText() )
+ {
+ range = mController->GetTextSelectionRange();
+ }
+ return range;
+}
+
void TextEditor::UpdateScrollBar()
{
using namespace Dali;
#include <dali-toolkit/internal/text/decorator/text-decorator.h>
#include <dali-toolkit/internal/text/text-control-interface.h>
#include <dali-toolkit/internal/text/text-editable-control-interface.h>
+#include <dali-toolkit/internal/text/text-selectable-control-interface.h>
#include <dali-toolkit/internal/text/text-controller.h>
#include <dali-toolkit/internal/text/text-vertical-scroller.h>
#include <dali-toolkit/internal/text/rendering/text-renderer.h>
/**
* @brief A control which renders a long text string with styles.
*/
-class TextEditor : public Control, public Text::ControlInterface, public Text::EditableControlInterface
+class TextEditor : public Control, public Text::ControlInterface, public Text::EditableControlInterface, public Text::SelectableControlInterface
{
public:
*/
void AddDecoration( Actor& actor, bool needsClipping ) override;
+
+// From SelectableControlInterface
+public:
+ /**
+ * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
+ */
+ void SetTextSelectionRange(const uint32_t *start, const uint32_t *end) override;
+
+ /**
+ * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
+ */
+ Uint32Pair GetTextSelectionRange() const override;
+
private: // Implementation
/**
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "textBackground", VECTOR4, BACKGROUND )
DALI_DEVEL_PROPERTY_REGISTRATION_READ_ONLY( Toolkit, TextField, "selectedText", STRING, SELECTED_TEXT )
DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "renderingBackend", INTEGER, RENDERING_BACKEND )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "selectedTextStart", INTEGER, SELECTED_TEXT_START )
+DALI_DEVEL_PROPERTY_REGISTRATION( Toolkit, TextField, "selectedTextEnd", INTEGER, SELECTED_TEXT_END )
DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "textChanged", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "maxLengthReached", SIGNAL_MAX_LENGTH_REACHED )
}
break;
}
+ case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
+ {
+ if( impl.mController )
+ {
+ uint32_t start = static_cast<uint32_t>(value.Get< int >());
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_START %d\n", impl.mController.Get(), start );
+ impl.SetTextSelectionRange( &start, nullptr );
+ }
+ break;
+ }
+ case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
+ {
+ if( impl.mController )
+ {
+ uint32_t end = static_cast<uint32_t>(value.Get< int >());
+ DALI_LOG_INFO( gLogFilter, Debug::General, "TextField %p SELECTED_TEXT_END %d\n", impl.mController.Get(), end );
+ impl.SetTextSelectionRange( nullptr, &end );
+ }
+ break;
+ }
} // switch
} // textfield
}
}
break;
}
+ case Toolkit::DevelTextField::Property::SELECTED_TEXT_START:
+ {
+ Uint32Pair range = impl.GetTextSelectionRange( );
+ value = static_cast<int>(range.first);
+ break;
+ }
+ case Toolkit::DevelTextField::Property::SELECTED_TEXT_END:
+ {
+ Uint32Pair range = impl.GetTextSelectionRange( );
+ value = static_cast<int>(range.second);
+ break;
+ }
} //switch
}
}
}
+void TextField::SetTextSelectionRange(const uint32_t *start, const uint32_t *end)
+{
+ if( mController && mController->IsShowingRealText() )
+ {
+ mController->SetTextSelectionRange( start, end );
+ SetKeyInputFocus();
+ }
+}
+
+Uint32Pair TextField::GetTextSelectionRange() const
+{
+ Uint32Pair range;
+ if( mController && mController->IsShowingRealText() )
+ {
+ range = mController->GetTextSelectionRange();
+ }
+ return range;
+}
+
+
InputMethodContext TextField::GetInputMethodContext()
{
return mInputMethodContext;
{
Actor self = Self();
- mController = Text::Controller::New( this, this );
+ mController = Text::Controller::New( this, this ,this);
// When using the vector-based rendering, the size of the GLyphs are different
TextAbstraction::GlyphType glyphType = (DevelText::RENDERING_VECTOR_BASED == mRenderingBackend) ? TextAbstraction::VECTOR_GLYPH : TextAbstraction::BITMAP_GLYPH;
#include <dali-toolkit/internal/text/decorator/text-decorator.h>
#include <dali-toolkit/internal/text/text-control-interface.h>
#include <dali-toolkit/internal/text/text-editable-control-interface.h>
+#include <dali-toolkit/internal/text/text-selectable-control-interface.h>
#include <dali-toolkit/internal/text/text-controller.h>
#include <dali-toolkit/internal/text/rendering/text-renderer.h>
/**
* @brief A control which renders a short text string.
*/
-class TextField : public Control, public Text::ControlInterface, public Text::EditableControlInterface
+class TextField : public Control, public Text::ControlInterface, public Text::EditableControlInterface, public Text::SelectableControlInterface
{
public:
*/
void SelectWholeText();
- /**
+ /**
* @brief Called to unselect the whole texts.
*/
void SelectNone();
*/
void AddDecoration( Actor& actor, bool needsClipping ) override;
+
+// From SelectableControlInterface
+public:
+ /**
+ * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
+ */
+ void SetTextSelectionRange(const uint32_t *start, const uint32_t *end) override;
+
+ /**
+ * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
+ */
+ Uint32Pair GetTextSelectionRange() const override;
+
private: // Implementation
/**
mButtonsChanged = true;
}
-void TextSelectionPopup::RaiseAbove( Layer target )
+void TextSelectionPopup::RaiseAbove( Actor target )
{
if( mToolbar )
{
/**
* @copydoc Toolkit::TextSelectionPopup::RaiseAbove()
*/
- void RaiseAbove( Layer target );
+ void RaiseAbove( Actor target );
/**
* @copydoc Toolkit::TextSelectionPopup::ShowPopup()
void TextSelectionToolbar::SetPopupMaxSize( const Size& maxSize )
{
mMaxSize = maxSize;
- if (mScrollView && mToolbarLayer )
+ if( mScrollView && mToolbarActor )
{
mScrollView.SetProperty( Actor::Property::MAXIMUM_SIZE, mMaxSize );
- mToolbarLayer.SetProperty( Actor::Property::MAXIMUM_SIZE, mMaxSize );
+ mToolbarActor.SetProperty( Actor::Property::MAXIMUM_SIZE, mMaxSize );
}
}
self.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
- // Create Layer to house the toolbar.
- mToolbarLayer = Layer::New();
- mToolbarLayer.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
- mToolbarLayer.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
- mToolbarLayer.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
+ // Create Actor to house the toolbar.
+ mToolbarActor = Actor::New();
+ mToolbarActor.SetResizePolicy( ResizePolicy::FIT_TO_CHILDREN, Dimension::ALL_DIMENSIONS );
+ mToolbarActor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER );
+ mToolbarActor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::CENTER );
if( !mScrollView )
{
mTableOfButtons.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::CENTER_LEFT );
mScrollView.Add( mTableOfButtons );
- mToolbarLayer.Add( mScrollView );
+ mToolbarActor.Add( mScrollView );
- self.Add( mToolbarLayer );
+ self.Add( mToolbarActor );
}
void TextSelectionToolbar::SetUpScrollBar( bool enable )
RelayoutRequest();
}
-void TextSelectionToolbar::RaiseAbove( Layer target )
+void TextSelectionToolbar::RaiseAbove( Actor target )
{
- mToolbarLayer.RaiseAbove( target );
+ mToolbarActor.RaiseAbove( target );
}
void TextSelectionToolbar::SetScrollBarPadding( const Vector2& padding )
/**
* @copydoc Toolkit::TextSelectionToolbar::RaiseAbove()
*/
- void RaiseAbove( Layer target );
+ void RaiseAbove( Actor target );
/**
* Sets the scroll bar padding.
private: // Data
- Layer mToolbarLayer; ///< The layer used to house the toolbar.
+ Actor mToolbarActor; ///< The actor used to house the toolbar.
Toolkit::TableView mTableOfButtons; ///< Actor which holds all the buttons, sensitivity can be set on buttons via this actor
Toolkit::ScrollView mScrollView; ///< Provides scrolling of Toolbar when content does not fit.
Toolkit::ScrollBar mScrollBar; ///< An horizontal scroll bar for the text's popup options.
{
if( !mActiveLayer )
{
- mActiveLayer = Layer::New();
+ mActiveLayer = Actor::New();
#ifdef DECORATOR_DEBUG
mActiveLayer.SetProperty( Actor::Property::NAME, "ActiveLayerActor" );
#endif
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.
+ Actor mActiveLayer; ///< Actor for active handles and alike that ensures they are above all else.
PropertyNotification mHandleVerticalLessThanNotification; ///< Notifies when the 'y' coord of the active layer is less than a given value.
PropertyNotification mHandleVerticalGreaterThanNotification; ///< Notifies when the 'y' coord of the active layer is grater than a given value.
PropertyNotification mHandleHorizontalLessThanNotification; ///< Notifies when the 'x' coord of the active layer is less than a given value.
}
}
+void Controller::Impl::SetTextSelectionRange(const uint32_t *pStart, const uint32_t *pEnd)
+{
+ if( nullptr == mEventData )
+ {
+ // Nothing to do if there is no text.
+ return;
+ }
+
+ if( mEventData->mSelectionEnabled && (pStart || pEnd))
+ {
+ uint32_t length = static_cast<uint32_t>(mModel->mLogicalModel->mText.Count());
+
+ if (pStart)
+ {
+ mEventData->mLeftSelectionPosition = std::min(*pStart, length);
+ }
+ if (pEnd)
+ {
+ mEventData->mRightSelectionPosition = std::min(*pEnd, length);
+ }
+
+ if (mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition)
+ {
+ ChangeState( EventData::EDITING );
+ mEventData->mPrimaryCursorPosition = mEventData->mLeftSelectionPosition = mEventData->mRightSelectionPosition;
+ mEventData->mUpdateCursorPosition = true;
+ }
+ else
+ {
+ ChangeState( EventData::SELECTING );
+ mEventData->mUpdateHighlightBox = true;
+ }
+ }
+}
+
+Uint32Pair Controller::Impl::GetTextSelectionRange() const
+{
+ Uint32Pair range;
+
+ if( mEventData )
+ {
+ range.first = mEventData->mLeftSelectionPosition;
+ range.second = mEventData->mRightSelectionPosition;
+ }
+
+ return range;
+}
+
void Controller::Impl::RetrieveSelection( std::string& selectedText, bool deleteAfterRetrieval )
{
if( mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition )
struct CursorInfo;
struct FontDefaults;
+class SelectableControlInterface;
+
struct Event
{
// Used to queue input events until DoRelayout()
struct Controller::Impl
{
Impl( ControlInterface* controlInterface,
- EditableControlInterface* editableControlInterface )
+ EditableControlInterface* editableControlInterface,
+ SelectableControlInterface* selectableControlInterface )
: mControlInterface( controlInterface ),
mEditableControlInterface( editableControlInterface ),
+ mSelectableControlInterface( selectableControlInterface ),
mModel(),
mFontDefaults( NULL ),
mUnderlineDefaults( NULL ),
void OnSelectNoneEvent();
/**
+ * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
+ */
+ void SetTextSelectionRange(const uint32_t *pStart, const uint32_t *pEndf);
+
+ /**
+ * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
+ */
+ Uint32Pair GetTextSelectionRange() const;
+
+ /**
* @brief Retrieves the selected text. It removes the text if the @p deleteAfterRetrieval parameter is @e true.
*
* @param[out] selectedText The selected text encoded in utf8.
ControlInterface* mControlInterface; ///< Reference to the text controller.
EditableControlInterface* mEditableControlInterface; ///< Reference to the editable text controller.
+ SelectableControlInterface* mSelectableControlInterface; ///< Reference to the selectable text controller.
ModelPtr mModel; ///< Pointer to the text's model.
FontDefaults* mFontDefaults; ///< Avoid allocating this when the user does not specify a font.
UnderlineDefaults* mUnderlineDefaults; ///< Avoid allocating this when the user does not specify underline parameters.
const std::string KEY_C_NAME = "c";
const std::string KEY_V_NAME = "v";
const std::string KEY_X_NAME = "x";
+const std::string KEY_A_NAME = "a";
+const std::string KEY_INSERT_NAME = "Insert";
const char * const PLACEHOLDER_TEXT = "text";
const char * const PLACEHOLDER_TEXT_FOCUSED = "textFocused";
}
ControllerPtr Controller::New( ControlInterface* controlInterface,
- EditableControlInterface* editableControlInterface )
+ EditableControlInterface* editableControlInterface,
+ SelectableControlInterface* selectableControlInterface )
{
return ControllerPtr( new Controller( controlInterface,
- editableControlInterface ) );
+ editableControlInterface,
+ selectableControlInterface ) );
}
// public : Configure the text controller.
// Do nothing
return false;
}
- else if ( keyEvent.IsCtrlModifier() )
+ else if ( keyEvent.IsCtrlModifier() && !keyEvent.IsShiftModifier())
{
bool consumed = false;
- if (keyName == KEY_C_NAME)
+ if (keyName == KEY_C_NAME || keyName == KEY_INSERT_NAME)
{
- // Ctrl-C to copy the selected text
+ // Ctrl-C or Ctrl+Insert to copy the selected text
TextPopupButtonTouched( Toolkit::TextSelectionPopup::COPY );
consumed = true;
}
TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT );
consumed = true;
}
+ else if (keyName == KEY_A_NAME)
+ {
+ // Ctrl-A to select All the text
+ TextPopupButtonTouched( Toolkit::TextSelectionPopup::SELECT_ALL );
+ consumed = true;
+ }
return consumed;
}
else if( ( Dali::DALI_KEY_BACKSPACE == keyCode ) ||
}
}
+void Controller::SetTextSelectionRange(const uint32_t *start, const uint32_t *end)
+{
+ if( mImpl->mEventData )
+ {
+ mImpl->mEventData->mCheckScrollAmount = true;
+ mImpl->mEventData->mIsLeftHandleSelected = true;
+ mImpl->mEventData->mIsRightHandleSelected = true;
+ mImpl->SetTextSelectionRange(start, end);
+ mImpl->RequestRelayout();
+ KeyboardFocusGainEvent();
+ }
+}
+
+Uint32Pair Controller::GetTextSelectionRange() const
+{
+ return mImpl->GetTextSelectionRange();
+}
+
InputMethodContext::CallbackData Controller::OnInputMethodContextEvent( InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent )
{
// Whether the text needs to be relaid-out.
Controller::Controller()
: mImpl( NULL )
{
- mImpl = new Controller::Impl( NULL, NULL );
+ mImpl = new Controller::Impl( nullptr, nullptr, nullptr );
}
Controller::Controller( ControlInterface* controlInterface )
{
- mImpl = new Controller::Impl( controlInterface, NULL );
+ mImpl = new Controller::Impl( controlInterface, NULL, NULL );
}
Controller::Controller( ControlInterface* controlInterface,
- EditableControlInterface* editableControlInterface )
+ EditableControlInterface* editableControlInterface,
+ SelectableControlInterface* selectableControlInterface )
{
mImpl = new Controller::Impl( controlInterface,
- editableControlInterface );
+ editableControlInterface,
+ selectableControlInterface );
}
// The copy constructor and operator are left unimplemented.
#include <dali-toolkit/internal/text/layouts/layout-engine.h>
#include <dali-toolkit/internal/text/hidden-text.h>
#include <dali-toolkit/internal/text/text-model-interface.h>
+#include <dali-toolkit/internal/text/text-selectable-control-interface.h>
namespace Dali
{
*
* @param[in] controlInterface The control's interface.
* @param[in] editableControlInterface The editable control's interface.
+ * @param[in] selectableControlInterface The selectable control's interface.
*
* @return A pointer to a new Controller.
*/
static ControllerPtr New( ControlInterface* controlInterface,
- EditableControlInterface* editableControlInterface );
+ EditableControlInterface* editableControlInterface,
+ SelectableControlInterface* selectableControlInterface );
public: // Configure the text controller.
void SelectEvent( float x, float y, SelectionType selection );
/**
+ * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
+ */
+ void SetTextSelectionRange(const uint32_t *start, const uint32_t *end);
+
+ /**
+ * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
+ */
+ Uint32Pair GetTextSelectionRange() const;
+
+ /**
* @brief Event received from input method context
*
* @param[in] inputMethodContext The input method context.
* @brief Private constructor.
*/
Controller( ControlInterface* controlInterface,
- EditableControlInterface* editableControlInterface );
+ EditableControlInterface* editableControlInterface,
+ SelectableControlInterface* selectableControlInterface );
// Undefined
Controller( const Controller& handle );
--- /dev/null
+#ifndef DALI_TOOLKIT_TEXT_SELECTABLE_CONTROL_INTERFACE_H
+#define DALI_TOOLKIT_TEXT_SELECTABLE_CONTROL_INTERFACE_H
+
+/*
+ * Copyright (c) 2020 Samsung Electronics Co., Ltd.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+namespace Dali
+{
+
+namespace Toolkit
+{
+
+using Uint32Pair = std::pair<uint32_t,uint32_t>;
+namespace Text
+{
+
+/**
+ * @brief An interface that the Text::Controller used for text selection functionality.
+ */
+class SelectableControlInterface
+{
+public:
+
+ /**
+ * @brief Virtual destructor.
+ */
+ virtual ~SelectableControlInterface() = default;
+
+ /**
+ * @brief Called to set the selection postions in the texts.
+ * @param start start selection position (pass NULL to ignore).
+ * @param end end selection position (pass NULL to ignore).
+ */
+ virtual void SetTextSelectionRange(const uint32_t *start, const uint32_t *end) = 0;
+
+ /**
+ * @brief Called to return the selection postions in the texts.
+ * @return pair contains start and end positions.
+ */
+ virtual Uint32Pair GetTextSelectionRange() const = 0;
+};
+
+} // namespace Text
+
+} // namespace Toolkit
+
+} // namespace Dali
+
+#endif // DALI_TOOLKIT_TEXT_SELECTABLE_CONTROL_INTERFACE_H
#include <dali/public-api/actors/layer.h>
#include <dali/devel-api/common/stage.h>
#include <dali/devel-api/adaptor-framework/image-loading.h>
+#include <dali/devel-api/rendering/renderer-devel.h>
+#include <dali/devel-api/rendering/texture-devel.h>
#include <dali/devel-api/scripting/enum-helper.h>
#include <dali/devel-api/scripting/scripting.h>
#include <dali/integration-api/debug.h>
#include <dali-toolkit/internal/visuals/visual-base-data-impl.h>
#include <dali-toolkit/internal/visuals/visual-url.h>
#include <dali-toolkit/internal/visuals/image-visual-shader-factory.h>
-#include <dali/devel-api/rendering/renderer-devel.h>
namespace Dali
{
Geometry geometry;
Shader shader;
- if( !mImpl->mCustomShader )
+ // Get the geometry
+ if( mImpl->mCustomShader )
+ {
+ geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
+ }
+ else // Get any geometry associated with the texture
{
TextureManager& textureManager = mFactoryCache.GetTextureManager();
uint32_t firstElementCount {0u};
uint32_t secondElementCount {0u};
geometry = textureManager.GetRenderGeometry(mTextureId, firstElementCount, secondElementCount);
- if(!firstElementCount && !secondElementCount)
+
+ if(!firstElementCount && !secondElementCount) // Otherwise use quad
{
geometry = CreateGeometry( mFactoryCache, ImageDimensions( 1, 1 ) );
}
+ }
- shader = mImageVisualShaderFactory.GetShader( mFactoryCache,
- mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
- mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE,
- IsRoundedCornerRequired() );
+ std::string vertexShader;
+ bool usesWholeTexture = true;
+ if(mImpl->mCustomShader && !mImpl->mCustomShader->mVertexShader.empty())
+ {
+ vertexShader = mImpl->mCustomShader->mVertexShader;
+ usesWholeTexture = false; // Impossible to tell.
}
else
{
- geometry = CreateGeometry( mFactoryCache, mImpl->mCustomShader->mGridSize );
- if( mImpl->mCustomShader->mVertexShader.empty() && mImpl->mCustomShader->mFragmentShader.empty() )
- {
- // Use custom hints
- shader = Shader::New( mImageVisualShaderFactory.GetVertexShaderSource(), mImageVisualShaderFactory.GetFragmentShaderSource(), mImpl->mCustomShader->mHints );
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- else
- {
- shader = Shader::New( mImpl->mCustomShader->mVertexShader.empty() ? mImageVisualShaderFactory.GetVertexShaderSource() : mImpl->mCustomShader->mVertexShader,
- mImpl->mCustomShader->mFragmentShader.empty() ? mImageVisualShaderFactory.GetFragmentShaderSource() : mImpl->mCustomShader->mFragmentShader,
- mImpl->mCustomShader->mHints );
- if( mImpl->mCustomShader->mVertexShader.empty() )
- {
- shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
- }
- }
+ vertexShader = mImageVisualShaderFactory.GetVertexShaderSource();
+ }
+
+ std::string fragmentShader;
+ if(mImpl->mCustomShader && !mImpl->mCustomShader->mFragmentShader.empty())
+ {
+ fragmentShader = mImpl->mCustomShader->mFragmentShader;
+ }
+ else
+ {
+ fragmentShader = mImageVisualShaderFactory.GetFragmentShaderSource();
+ }
+
+ // If the texture is native, we may need to change prefix and sampler in
+ // the fragment shader
+ bool modifiedFragmentShader = false;
+ if(mTextures && DevelTexture::IsNative(mTextures.GetTexture(0)))
+ {
+ Texture nativeTexture = mTextures.GetTexture(0);
+ modifiedFragmentShader = DevelTexture::ApplyNativeFragmentShader(nativeTexture, fragmentShader);
+ }
+
+ const bool useStandardShader = !mImpl->mCustomShader && !modifiedFragmentShader;
+ if(useStandardShader)
+ {
+ // Create and cache the standard shader
+ shader = mImageVisualShaderFactory.GetShader(
+ mFactoryCache,
+ mImpl->mFlags & Impl::IS_ATLASING_APPLIED,
+ mWrapModeU <= WrapMode::CLAMP_TO_EDGE && mWrapModeV <= WrapMode::CLAMP_TO_EDGE,
+ IsRoundedCornerRequired() );
+ }
+ else if(mImpl->mCustomShader)
+ {
+ shader = Shader::New(vertexShader, fragmentShader, mImpl->mCustomShader->mHints);
+ }
+ else
+ {
+ shader = Shader::New(vertexShader, fragmentShader);
+ }
+
+ if(usesWholeTexture)
+ {
+ shader.RegisterProperty( PIXEL_AREA_UNIFORM_NAME, FULL_TEXTURE_RECT );
}
// Set pixel align off as default.
// We should trun it off until issues are resolved
shader.RegisterProperty( PIXEL_ALIGNED_UNIFORM_NAME, PIXEL_ALIGN_OFF );
+ // Create the renderer
mImpl->mRenderer = Renderer::New( geometry, shader );
+
if( textureSet )
{
mImpl->mRenderer.SetTextures( textureSet );
EnablePreMultipliedAlpha( IsPreMultipliedAlphaEnabled() );
}
+
void ImageVisual::LoadTexture( bool& atlasing, Vector4& atlasRect, TextureSet& textures, bool orientationCorrection,
TextureManager::ReloadPolicy forceReload )
{
{
const unsigned int TOOLKIT_MAJOR_VERSION = 1;
const unsigned int TOOLKIT_MINOR_VERSION = 9;
-const unsigned int TOOLKIT_MICRO_VERSION = 29;
+const unsigned int TOOLKIT_MICRO_VERSION = 30;
const char* const TOOLKIT_BUILD_DATE = __DATE__ " " __TIME__;
#ifdef DEBUG_ENABLED
Name: dali2-toolkit
Summary: Dali 3D engine Toolkit
-Version: 1.9.29
+Version: 1.9.30
Release: 1
Group: System/Libraries
License: Apache-2.0 and BSD-3-Clause and MIT
projects / platform / core / uifw / dali-toolkit.git / commitdiff