const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT = "horizontal-alignment";
const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT = "vertical-alignment";
+static bool gTextChangedCallBackCalled;
static bool gMaxCharactersCallBackCalled;
+static void TestTextChangedCallback( TextField control )
+{
+ tet_infoline(" TestTextChangedCallback");
+
+ gTextChangedCallBackCalled = true;
+}
+
static void TestMaxLengthReachedCallback( TextField control )
{
- tet_infoline(" TestMaxLengthReachedCallbackCallback");
+ tet_infoline(" TestMaxLengthReachedCallback");
gMaxCharactersCallBackCalled = true;
}
END_TEST;
}
+// Positive test for the text-changed signal.
+int utcDaliTextFieldTextChangedP(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextFieldTextChangedP");
+ TextField field = TextField::New();
+ DALI_TEST_CHECK( field );
+
+ Stage::GetCurrent().Add(field);
+
+ field.TextChangedSignal().Connect(&TestTextChangedCallback);
+
+ gTextChangedCallBackCalled = false;
+ field.SetProperty( TextField::Property::TEXT, "ABC" );
+ DALI_TEST_CHECK( gTextChangedCallBackCalled );
+
+ application.SendNotification();
+
+ field.SetKeyInputFocus();
+
+ Dali::Integration::KeyEvent keyevent;
+ keyevent.keyName = "D";
+ keyevent.keyString = "D";
+ keyevent.keyCode = 0;
+ keyevent.keyModifier = 0;
+ keyevent.time = 0;
+ keyevent.state = Integration::KeyEvent::Down;
+
+ gTextChangedCallBackCalled = false;
+ application.ProcessEvent( keyevent );
+ DALI_TEST_CHECK( gTextChangedCallBackCalled );
+
+ END_TEST;
+}
+
+// Negative test for the text-changed signal.
+int utcDaliTextFieldTextChangedN(void)
+{
+ ToolkitTestApplication application;
+ tet_infoline(" utcDaliTextFieldTextChangedN");
+ TextField field = TextField::New();
+ DALI_TEST_CHECK( field );
+
+ Stage::GetCurrent().Add(field);
+
+ field.TextChangedSignal().Connect(&TestTextChangedCallback);
+
+ gTextChangedCallBackCalled = false;
+ field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "ABC" ); // Setting placeholder, not TEXT
+ DALI_TEST_CHECK( ! gTextChangedCallBackCalled );
+
+ END_TEST;
+}
+
// Positive test for Max Characters reached signal.
int utcDaliTextFieldMaxCharactersReachedP(void)
{
DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "decoration-bounding-box", RECTANGLE, DECORATION_BOUNDING_BOX )
DALI_PROPERTY_REGISTRATION( Toolkit, TextField, "input-method-settings", MAP, INPUT_METHOD_SETTINGS )
+DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "text-changed", SIGNAL_TEXT_CHANGED )
DALI_SIGNAL_REGISTRATION( Toolkit, TextField, "max-length-reached", SIGNAL_MAX_LENGTH_REACHED )
DALI_TYPE_REGISTRATION_END()
bool connected( true );
Toolkit::TextField field = Toolkit::TextField::DownCast( handle );
- if( 0 == strcmp( signalName.c_str(), SIGNAL_MAX_LENGTH_REACHED ) )
+ if( 0 == strcmp( signalName.c_str(), SIGNAL_TEXT_CHANGED ) )
+ {
+ field.TextChangedSignal().Connect( tracker, functor );
+ }
+ else if( 0 == strcmp( signalName.c_str(), SIGNAL_MAX_LENGTH_REACHED ) )
{
field.MaxLengthReachedSignal().Connect( tracker, functor );
}
return connected;
}
+Toolkit::TextField::TextChangedSignalType& TextField::TextChangedSignal()
+{
+ return mTextChangedSignal;
+}
+
Toolkit::TextField::MaxLengthReachedSignalType& TextField::MaxLengthReachedSignal()
{
return mMaxLengthReachedSignal;
RelayoutRequest();
}
+void TextField::TextChanged()
+{
+ Dali::Toolkit::TextField handle( GetOwner() );
+ mTextChangedSignal.Emit( handle );
+}
+
void TextField::MaxLengthReached()
{
Dali::Toolkit::TextField handle( GetOwner() );
static bool DoConnectSignal( BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor );
/**
+ * @copydoc TextField::TextChangedSignal()
+ */
+ Toolkit::TextField::TextChangedSignalType& TextChangedSignal();
+
+ /**
* @copydoc TextField::MaxLengthReachedSignal()
*/
Toolkit::TextField::MaxLengthReachedSignalType& MaxLengthReachedSignal();
virtual void RequestTextRelayout();
/**
+ * @copydoc Text::ControlInterface::TextChanged()
+ */
+ virtual void TextChanged();
+
+ /**
* @copydoc Text::ControlInterface::MaxLengthReached()
*/
virtual void MaxLengthReached();
private: // Data
// Signals
+ Toolkit::TextField::TextChangedSignalType mTextChangedSignal;
Toolkit::TextField::MaxLengthReachedSignalType mMaxLengthReachedSignal;
Text::ControllerPtr mController;
RelayoutRequest();
}
+void TextLabel::TextChanged()
+{
+ // TextLabel does not provide a signal for this
+}
+
void TextLabel::MaxLengthReached()
{
// Pure Virtual from TextController Interface, only needed when inputting text
virtual void RequestTextRelayout();
/**
+ * @copydoc Text::ControlInterface::TextChanged()
+ */
+ virtual void TextChanged();
+
+ /**
* @copydoc Text::ControlInterface::MaxLengthReached()
*/
virtual void MaxLengthReached();
virtual void RequestTextRelayout() = 0;
/**
+ * @brief Called to signal that text has been inserted or deleted.
+ */
+ virtual void TextChanged() = 0;
+
+ /**
* @brief Called when the number of characters to be inserted exceeds the maximum limit
*/
virtual void MaxLengthReached() = 0;
*/
void QueueModifyEvent( ModifyEvent::Type type )
{
+ if( ModifyEvent::TEXT_REPLACED == type)
+ {
+ // Cancel previously queued inserts etc.
+ mModifyEvents.clear();
+ }
+
ModifyEvent event;
event.type = type;
mModifyEvents.push_back( event );
void Controller::SetText( const std::string& text )
{
- // Cancel previously queued inserts etc.
- mImpl->mModifyEvents.clear();
-
// Remove the previously set text
ResetText();
// Reset keyboard as text changed
mImpl->ResetImfManager();
+
+ // Do this last since it provides callbacks into application code
+ mImpl->mControlInterface.TextChanged();
}
void Controller::GetText( std::string& text ) const
{
DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyEvent" );
+ bool textChanged( false );
+
if( mImpl->mEventData &&
keyEvent.state == KeyEvent::Down )
{
{
mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
}
+
+ textChanged = true;
}
}
else
mImpl->ClearPreEditFlag();
InsertText( keyString, COMMIT );
+
+ textChanged = true;
}
mImpl->ChangeState( EventData::EDITING ); // todo Confirm this is the best place to change the state of
mImpl->RequestRelayout();
}
+ if( textChanged )
+ {
+ // Do this last since it provides callbacks into application code
+ mImpl->mControlInterface.TextChanged();
+ }
+
return false;
}
{
DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mLogicalModel->mText.Count() );
- mImpl->mControlInterface.MaxLengthReached();
-
mImpl->ResetImfManager();
+
+ // Do this last since it provides callbacks into application code
+ mImpl->mControlInterface.MaxLengthReached();
}
}
{
mImpl->mOperationsPending = ALL_OPERATIONS;
mImpl->RequestRelayout();
+
+ // Do this last since it provides callbacks into application code
+ mImpl->mControlInterface.TextChanged();
}
ImfManager::ImfCallbackData callbackData( update, cursorPosition, text, false );
mImpl->mEventData->mIsShowingPlaceholderText = true;
- // Cancel previously queued inserts etc.
- mImpl->mModifyEvents.clear();
-
// Disable handles when showing place-holder text
mImpl->mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
mImpl->mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
return Control::DownCast<TextField, Internal::TextField>(handle);
}
+TextField::TextChangedSignalType& TextField::TextChangedSignal()
+{
+ return Dali::Toolkit::GetImpl( *this ).TextChangedSignal();
+}
+
TextField::MaxLengthReachedSignalType& TextField::MaxLengthReachedSignal()
{
return Dali::Toolkit::GetImpl( *this ).MaxLengthReachedSignal();
* * Signals
* | %Signal Name | Method |
* |------------------------|-----------------------------------------------------|
+ * | text-changed | @ref TextChangedSignal() |
* | max-length-reached | @ref MaxLengthReachedSignal() |
*
*/
// Type Defs
/// @brief Max Characters Exceed signal type;
+ typedef Signal<void ( TextField ) > TextChangedSignalType;
typedef Signal<void ( TextField ) > MaxLengthReachedSignalType;
/**
// Signals
/**
+ * @brief This signal is emitted when the text changes.
+ *
+ * A callback of the following type may be connected:
+ * @code
+ * void YourCallbackName( TextField textField );
+ * @endcode
+ * @return The signal to connect to.
+ */
+ TextChangedSignalType& TextChangedSignal();
+
+ /**
* @brief This signal is emitted when inserted text exceeds the maximum character limit.
*
* A callback of the following type may be connected: