automated-tests/src/dali-toolkit-internal/utc-Dali-Text-Controller.cpp

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #include <iostream>
  19
  20 #include <stdlib.h>
  21 #include <limits>
  22
  23 #include <dali-toolkit-test-suite-utils.h>
  24 #include <dali-toolkit/dali-toolkit.h>
  25 #include <toolkit-text-utils.h>
  26 #include <dali/devel-api/events/key-event-devel.h>
  27 #include <dali-toolkit/internal/controls/text-controls/text-field-impl.h>
  28 #include <dali-toolkit/internal/text/text-controller.h>
  29 #include <dali-toolkit/internal/text/text-control-interface.h>
  30 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
  31 #include <dali-toolkit/internal/text/text-controller-impl.h>
  32
  33 using namespace Dali;
  34 using namespace Toolkit;
  35 using namespace Text;
  36
  37 namespace
  38 {
  39
  40 const char* const OPTION_SELECT_ALL("option-select_all");   // "Select All" popup option.
  41 const char* const OPTION_CUT("optionCut");                  // "Cut" popup option.
  42 const char* const OPTION_COPY("optionCopy");                // "Copy" popup option.
  43 const char* const OPTION_PASTE("optionPaste");              // "Paste" popup option.
  44 const char* const OPTION_CLIPBOARD("optionClipboard");      // "Clipboard" popup option.
  45
  46 const Size CONTROL_SIZE( 300.f, 60.f );
  47
  48 std::string gClipboardText;
  49 void ContentSelectedCallback( ClipboardEventNotifier& notifier )
  50 {
  51   gClipboardText = notifier.GetContent();
  52 }
  53
  54 // Generate a KeyEvent to send to Core.
  55 Dali::KeyEvent GenerateKey( const std::string& keyName,
  56                             const std::string& keyString,
  57                             int keyCode,
  58                             int keyModifier,
  59                             unsigned long timeStamp,
  60                             const Dali::KeyEvent::State& keyState )
  61 {
  62   return DevelKeyEvent::New( keyName, "", keyString, keyCode, keyModifier, timeStamp, keyState, "", "", Device::Class::NONE, Device::Subclass::NONE );
  63 }
  64
  65 } // namespace
  66
  67 int UtcDaliTextController(void)
  68 {
  69   tet_infoline(" UtcDaliTextController");
  70   ToolkitTestApplication application;
  71
  72   // Creates a text controller.
  73   ControllerPtr controller = Controller::New();
  74   DALI_TEST_CHECK( controller );
  75
  76   tet_result(TET_PASS);
  77   END_TEST;
  78 }
  79
  80 int UtcDaliTextControllerSetGetScrollEnabled(void)
  81 {
  82   tet_infoline(" UtcDaliTextControllerSetGetScrollEnabled");
  83   ToolkitTestApplication application;
  84
  85   // Creates a text controller.
  86   ControllerPtr controller = Controller::New();
  87   DALI_TEST_CHECK( controller );
  88
  89   // Configures the text controller similarly to the text-editor.
  90   ConfigureTextEditor( controller );
  91
  92   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
  93   DALI_TEST_CHECK( controller->IsVerticalScrollEnabled() );
  94
  95   // Configures the text controller similarly to the text-field.
  96   ConfigureTextField( controller );
  97
  98   DALI_TEST_CHECK( controller->IsHorizontalScrollEnabled() );
  99   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 100
 101   // Configures the text controller similarly to the text-label.
 102   ConfigureTextLabel( controller );
 103
 104   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
 105   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 106
 107   tet_result(TET_PASS);
 108   END_TEST;
 109 }
 110
 111 int UtcDaliTextControllerSetIsTextElide(void)
 112 {
 113   tet_infoline(" UtcDaliTextControllerSetIsTextElide");
 114   ToolkitTestApplication application;
 115
 116   // Creates a text controller.
 117   ControllerPtr controller = Controller::New();
 118   DALI_TEST_CHECK( controller );
 119
 120   // Configures the text controller similarly to the text-editor.
 121   ConfigureTextEditor( controller );
 122   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 123
 124   controller->SetTextElideEnabled( true );
 125   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 126
 127   // Configures the text controller similarly to the text-field.
 128   ConfigureTextField( controller );
 129   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 130
 131   controller->SetTextElideEnabled( true );
 132   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 133
 134   // Configures the text controller similarly to the text-label.
 135   ConfigureTextLabel( controller );
 136   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 137
 138   controller->SetTextElideEnabled( false );
 139   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 140
 141   tet_result(TET_PASS);
 142   END_TEST;
 143 }
 144
 145 int UtcDaliTextControllerEnableCursorBlinking(void)
 146 {
 147   tet_infoline(" UtcDaliTextControllerEnableCursorBlinking");
 148   ToolkitTestApplication application;
 149
 150   // Creates a text controller.
 151   ControllerPtr controller = Controller::New();
 152   DALI_TEST_CHECK( controller );
 153
 154   // There is no text input enabled.
 155   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 156
 157   // Enable the text input.
 158   // Creates a decorator.
 159   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 160                                                        *controller );
 161   InputMethodContext inputMethodContext = InputMethodContext::New();
 162   // Enables the text input.
 163   controller->EnableTextInput( decorator, inputMethodContext );
 164
 165   // Enables the cursor blink.
 166   controller->SetEnableCursorBlink( true );
 167
 168   DALI_TEST_CHECK( controller->GetEnableCursorBlink() );
 169
 170   // Disables the cursor blink.
 171   controller->SetEnableCursorBlink( false );
 172
 173   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 174
 175   tet_result(TET_PASS);
 176   END_TEST;
 177 }
 178
 179 int UtcDaliTextControllerImfEvent(void)
 180 {
 181   tet_infoline(" UtcDaliTextController");
 182   ToolkitTestApplication application;
 183
 184   // Creates a text controller.
 185   ControllerPtr controller = Controller::New();
 186
 187   std::string text;
 188   InputMethodContext::EventData imfEvent;
 189
 190   DALI_TEST_CHECK( controller );
 191
 192   // Enable the text input.
 193   // Creates a decorator.
 194   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 195                                                        *controller );
 196
 197   InputMethodContext inputMethodContext = InputMethodContext::New();
 198   // Enables the text input.
 199   controller->EnableTextInput( decorator, inputMethodContext );
 200
 201   // Set the placeholder text.
 202   controller->SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, "Hello Dali" );
 203
 204   // For coverage.
 205   imfEvent = InputMethodContext::EventData( InputMethodContext::GET_SURROUNDING, "", 0, 0 );
 206   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 207
 208   // Send VOID event.
 209   imfEvent = InputMethodContext::EventData( InputMethodContext::VOID, "", 0, 0 );
 210   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 211
 212   controller->GetText( text );
 213   DALI_TEST_CHECK( text.empty() );
 214
 215   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 216   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 217   controller->GetNaturalSize();
 218
 219   // Check 'Delete All' key which means the input panel send a big range
 220   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -100, 100 );
 221   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 222   controller->GetNaturalSize();
 223
 224   controller->GetText( text );
 225   DALI_TEST_EQUALS( "", text, TEST_LOCATION );
 226
 227   // Send COMMIT event.
 228   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 229   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 230
 231   // Force to update the model.
 232   controller->GetNaturalSize();
 233
 234   controller->GetText( text );
 235   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 236
 237   // Send PRE_EDIT event
 238   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 239   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 240
 241   // Force to update the model.
 242   controller->GetNaturalSize();
 243
 244   controller->GetText( text );
 245   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 246
 247   // Send DELETE_SURROUNDING event
 248   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -1, 1 );
 249   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 250
 251   // Force to update the model.
 252   controller->GetNaturalSize();
 253
 254   controller->GetText( text );
 255   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 256
 257   // for coverage
 258   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::UNDERLINE );
 259
 260   // Send PRE_EDIT event
 261   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "wo", 6, 2 );
 262   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 263
 264   // Force to update the model.
 265   controller->GetNaturalSize();
 266
 267   controller->GetText( text );
 268   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 269
 270   // Send GET_SURROUNDING event
 271   imfEvent = InputMethodContext::EventData( InputMethodContext::GET_SURROUNDING, "", 0, 0 );
 272   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 273
 274   controller->GetText( text );
 275   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 276
 277   // Send PRIVATE_COMMAND event
 278   imfEvent = InputMethodContext::EventData( InputMethodContext::PRIVATE_COMMAND, "", 0, 0 );
 279   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 280
 281   controller->GetText( text );
 282   DALI_TEST_EQUALS( "Hello wo", text, TEST_LOCATION );
 283
 284   tet_result(TET_PASS);
 285   END_TEST;
 286 }
 287
 288 int UtcDaliTextControllerImfPreeditStyle(void)
 289 {
 290   tet_infoline(" UtcDaliTextControllerImfPreeditStyle");
 291   ToolkitTestApplication application;
 292
 293   // Creates a text controller.
 294   ControllerPtr controller = Controller::New();
 295
 296   std::string text;
 297   InputMethodContext::EventData imfEvent;
 298
 299   DALI_TEST_CHECK( controller );
 300
 301   // Configures the text controller similarly to the text-field.
 302   ConfigureTextField( controller );
 303
 304   InputMethodContext inputMethodContext = InputMethodContext::New();
 305
 306   // Send COMMIT event.
 307   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 308   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 309
 310   // Force to update the model.
 311   controller->GetNaturalSize();
 312
 313   controller->GetText( text );
 314   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 315
 316   // Send PRE_EDIT event
 317   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 318   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 319   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::NONE );
 320   controller->GetNaturalSize();
 321
 322   controller->GetText( text );
 323   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 324
 325   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 326   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 327
 328   // Set the preedit style as REVERSE
 329   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::REVERSE );
 330   controller->GetNaturalSize();
 331
 332   controller->GetText( text );
 333   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 334
 335   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 336   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 337
 338   // Set the preedit style as HIGHLIGHT
 339   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::HIGHLIGHT );
 340   controller->GetNaturalSize();
 341
 342   controller->GetText( text );
 343   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 344
 345   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 346   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 347
 348   // Set the preedit style as CUSTOM_PLATFORM_STYLE_1
 349   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_1 );
 350   controller->GetNaturalSize();
 351
 352   controller->GetText( text );
 353   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 354
 355   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 356   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 357
 358   // Set the preedit style as CUSTOM_PLATFORM_STYLE_2
 359   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_2 );
 360   controller->GetNaturalSize();
 361
 362   controller->GetText( text );
 363   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 364
 365   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 366   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 367
 368   // Set the preedit style as CUSTOM_PLATFORM_STYLE_3
 369   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_3 );
 370   controller->GetNaturalSize();
 371
 372   controller->GetText( text );
 373   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 374
 375   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 376   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 377
 378   // Set the preedit style as CUSTOM_PLATFORM_STYLE_4
 379   inputMethodContext.SetPreeditStyle( InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_4 );
 380   controller->GetNaturalSize();
 381
 382   controller->GetText( text );
 383   DALI_TEST_EQUALS( "Hello w", text, TEST_LOCATION );
 384
 385   tet_result(TET_PASS);
 386   END_TEST;
 387 }
 388
 389 int UtcDaliTextControllerImfPreeditStyleReverse(void)
 390 {
 391   tet_infoline(" UtcDaliTextControllerImfPreeditStyleReverse");
 392   ToolkitTestApplication application;
 393
 394   // Creates a text controller.
 395   ControllerPtr controller = Controller::New();
 396
 397   std::string text;
 398   InputMethodContext::EventData imfEvent;
 399
 400   DALI_TEST_CHECK(controller);
 401
 402   // Configures the text controller similarly to the text-field.
 403   ConfigureTextField(controller);
 404
 405   InputMethodContext inputMethodContext = InputMethodContext::New();
 406
 407   // Send PRE_EDIT event
 408   imfEvent = InputMethodContext::EventData(InputMethodContext::PRE_EDIT, "Reverse", 0, 7);
 409   controller->OnInputMethodContextEvent(inputMethodContext, imfEvent);
 410
 411   // For coverage, mEditableControlInterface is required.
 412   // Creates a temporary text-field to use mEditableControlInterface.
 413   TextField field = TextField::New();
 414   Toolkit::Internal::TextField& fieldImpl = GetImpl(field);
 415   ControllerPtr fieldController = fieldImpl.GetTextController();
 416   Controller::Impl& fieldControllerImpl = Controller::Impl::GetImplementation(*fieldController.Get());
 417   Controller::Impl& controllerImpl = Controller::Impl::GetImplementation(*controller.Get());
 418
 419   // For coverage, mEditableControlInterface is required.
 420   controllerImpl.mEditableControlInterface = fieldControllerImpl.mEditableControlInterface;
 421
 422   // Set the preedit style as REVERSE
 423   inputMethodContext.SetPreeditStyle(InputMethodContext::PreeditStyle::REVERSE);
 424   controller->GetNaturalSize();
 425
 426   controller->GetText(text);
 427   DALI_TEST_EQUALS("Reverse", text, TEST_LOCATION);
 428
 429   tet_result(TET_PASS);
 430   END_TEST;
 431 }
 432
 433 int UtcDaliTextControllerTextPopupButtonTouched(void)
 434 {
 435   tet_infoline(" UtcDaliTextControllerTextPopupButtonTouched");
 436   ToolkitTestApplication application;
 437
 438   // Creates a text controller.
 439   ControllerPtr controller = Controller::New();
 440
 441   DALI_TEST_CHECK( controller );
 442
 443   std::string text;
 444   PushButton button;
 445   Property::Map attributes;
 446
 447   // Enable the text input.
 448   // Creates a decorator.
 449   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 450                                                        *controller );
 451
 452   InputMethodContext inputMethodContext = InputMethodContext::New();
 453   // Enables the text input.
 454   controller->EnableTextInput( decorator, inputMethodContext );
 455
 456   // Creates the text's popup.
 457   TextSelectionPopupCallbackInterface& callbackInterface = *controller;
 458   TextSelectionPopup textPopup = TextSelectionPopup::New( &callbackInterface );
 459
 460   Toolkit::TextSelectionPopup::Buttons buttonsToEnable = static_cast<Toolkit::TextSelectionPopup::Buttons>( TextSelectionPopup::CUT        |
 461                                                                                                             TextSelectionPopup::COPY       |
 462                                                                                                             TextSelectionPopup::PASTE      |
 463                                                                                                             TextSelectionPopup::SELECT     |
 464                                                                                                             TextSelectionPopup::SELECT_ALL |
 465                                                                                                             TextSelectionPopup::CLIPBOARD );
 466
 467   textPopup.EnableButtons( buttonsToEnable );
 468   application.GetScene().Add( textPopup );
 469   textPopup.ShowPopup();
 470
 471   // Render and notify
 472   application.SendNotification();
 473   application.Render();
 474
 475   // Sets some text.
 476   controller->SetText( "Hello world" );
 477
 478   // Select the whole text.
 479   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 480   DALI_TEST_CHECK( button );
 481
 482   button.DoAction( "buttonClick", attributes );
 483
 484   // Call relayout to process the input events.
 485   controller->Relayout( CONTROL_SIZE );
 486
 487   // Cut the text.
 488   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 489   DALI_TEST_CHECK( button );
 490
 491   button.DoAction( "buttonClick", attributes );
 492
 493   // Force to update the model.
 494   controller->GetNaturalSize();
 495
 496   controller->GetText( text );
 497   DALI_TEST_CHECK( text.empty() );
 498
 499   // Set text again.
 500   controller->SetText( "Hello world" );
 501
 502   // Select the whole text.
 503   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 504   DALI_TEST_CHECK( button );
 505
 506   button.DoAction( "buttonClick", attributes );
 507
 508   // Call relayout to process the input events.
 509   controller->Relayout( CONTROL_SIZE );
 510
 511   // Copy to the clipboard.
 512   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_COPY ) );
 513   DALI_TEST_CHECK( button );
 514
 515   button.DoAction( "buttonClick", attributes );
 516
 517   // Call relayout to process the input events.
 518   controller->Relayout( CONTROL_SIZE );
 519
 520   // Cut the text.
 521   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 522   DALI_TEST_CHECK( button );
 523
 524   button.DoAction( "buttonClick", attributes );
 525
 526   // Force to update the model.
 527   controller->GetNaturalSize();
 528
 529   controller->GetText( text );
 530   DALI_TEST_CHECK( text.empty() );
 531
 532   ClipboardEventNotifier clipboardEventNotifier = ClipboardEventNotifier::Get();
 533   clipboardEventNotifier.ContentSelectedSignal().Connect( &ContentSelectedCallback );
 534
 535   // Paste the text.
 536   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_PASTE ) );
 537   DALI_TEST_CHECK( button );
 538
 539   button.DoAction( "buttonClick", attributes );
 540
 541   // Call relayout to process the input events.
 542   controller->Relayout( CONTROL_SIZE );
 543
 544   DALI_TEST_EQUALS( "Hello world", gClipboardText, TEST_LOCATION );
 545
 546   // Show the clipboard.
 547   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CLIPBOARD ) );
 548   DALI_TEST_CHECK( button );
 549
 550   button.DoAction( "buttonClick", attributes );
 551
 552   tet_result(TET_PASS);
 553   END_TEST;
 554 }
 555
 556 int UtcDaliTextControllerGetInputShadowProperty(void)
 557 {
 558   tet_infoline(" UtcDaliTextControllerGetInputShadowProperty");
 559   ToolkitTestApplication application;
 560
 561   // Creates a text controller.
 562   ControllerPtr controller = Controller::New();
 563
 564   DALI_TEST_CHECK( controller );
 565
 566   const std::string& shadowProperties = controller->GetInputShadowProperties();
 567
 568   DALI_TEST_CHECK( shadowProperties.empty() );
 569
 570   tet_result(TET_PASS);
 571   END_TEST;
 572 }
 573
 574 int UtcDaliTextControllerGetInputUnderlineProperty(void)
 575 {
 576   tet_infoline(" UtcDaliTextControllerGetInputUnderlineProperty");
 577   ToolkitTestApplication application;
 578
 579   // Creates a text controller.
 580   ControllerPtr controller = Controller::New();
 581
 582   DALI_TEST_CHECK( controller );
 583
 584   const std::string& underlineProperties = controller->GetInputUnderlineProperties();
 585
 586   DALI_TEST_CHECK( underlineProperties.empty() );
 587
 588   tet_result(TET_PASS);
 589   END_TEST;
 590 }
 591
 592 int UtcDaliTextControllerSetGetAutoScrollEnabled(void)
 593 {
 594   tet_infoline(" UtcDaliTextControllerSetGetAutoScrollEnabled");
 595   ToolkitTestApplication application;
 596
 597   // Creates a text controller.
 598   ControllerPtr controller = Controller::New();
 599
 600   DALI_TEST_CHECK( controller );
 601
 602   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 603
 604   // The auto scrolling shouldn't be enabled if the multi-line is enabled.
 605
 606   // Enable multi-line.
 607   controller->SetMultiLineEnabled( true );
 608
 609   // Enable text scrolling.
 610   controller->SetAutoScrollEnabled( true );
 611
 612   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 613
 614   // Disable multi-line.
 615   controller->SetMultiLineEnabled( false );
 616
 617   // Enable text scrolling.
 618   controller->SetAutoScrollEnabled( true );
 619
 620   // Should be ebabled now.
 621   DALI_TEST_CHECK( controller->IsAutoScrollEnabled() );
 622
 623   tet_result(TET_PASS);
 624   END_TEST;
 625 }
 626
 627 int UtcDaliTextControllerSetGetCheckProperty(void)
 628 {
 629   tet_infoline(" UtcDaliTextControllerSetGetCheckProperty");
 630   ToolkitTestApplication application;
 631
 632   // Creates a text controller.
 633   ControllerPtr controller = Controller::New();
 634
 635   DALI_TEST_CHECK( controller );
 636
 637   // Enable the text input.
 638   // Creates a decorator.
 639   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 640
 641   InputMethodContext inputMethodContext = InputMethodContext::New();
 642   // Enables the text input.
 643   controller->EnableTextInput( decorator, inputMethodContext );
 644
 645   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 646
 647   // Set the text input to password.
 648   controller->SetInputModePassword( true );
 649
 650   DALI_TEST_CHECK( controller->IsInputModePassword() );
 651
 652   // Unset the text input to password.
 653   controller->SetInputModePassword( false );
 654
 655   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 656
 657   tet_result(TET_PASS);
 658   END_TEST;
 659 }
 660
 661 int UtcDaliTextControllerSetGetTapLongPressAction(void)
 662 {
 663   tet_infoline(" UtcDaliTextControllerSetGetTapLongPressAction");
 664   ToolkitTestApplication application;
 665
 666   // Creates a text controller.
 667   ControllerPtr controller = Controller::New();
 668
 669   DALI_TEST_CHECK( controller );
 670
 671   // Test first with no decorator.
 672
 673   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 674   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 675   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 676
 677   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 678   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 679   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 680
 681   // Add a decorator and re-test.
 682
 683   // Creates a decorator.
 684   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 685
 686   InputMethodContext inputMethodContext = InputMethodContext::New();
 687   // Enables the text input.
 688   controller->EnableTextInput( decorator, inputMethodContext );
 689
 690   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 691   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 692   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 693
 694   DALI_TEST_EQUALS( Controller::NoTextTap::SHOW_SELECTION_POPUP, controller->GetNoTextLongPressAction(), TEST_LOCATION ); // The default is SHOW_SELECTION_POPUP
 695   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 696   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 697
 698   END_TEST;
 699 }
 700
 701 int UtcDaliTextControllerSetGetLineSpacingProperty(void)
 702 {
 703   tet_infoline(" UtcDaliTextControllerSetGetLineSpacingProperty");
 704   ToolkitTestApplication application;
 705
 706   const Size size( application.GetScene().GetSize() );
 707
 708   // single line text
 709   const std::string textSingle("A Quick Brown Fox Jumps Over The Lazy Dog");
 710
 711   // multi-line text
 712   const std::string textMulti("A Quick Brown\nFox Jumps Over\nThe Lazy Dog");
 713
 714   // Creates a text controller.
 715   ControllerPtr controller = Controller::New();
 716
 717   ConfigureTextLabel(controller);
 718
 719   // single line, line spacing = 0px
 720   {
 721     const float EXPECTED_SPACING = 0.0f;
 722     const Vector2 EXPECTED_LAYOUT_SIZE( 360.0f, 19.0f);
 723     const Vector3 EXPECTED_NATURAL_SIZE( 360.0f, 20.0f, 0.0f );
 724
 725     controller->SetText(textSingle);
 726     controller->Relayout(size);
 727     controller->SetMultiLineEnabled( false );
 728
 729     Vector3 naturalSize  = controller->GetNaturalSize();
 730     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 731     float lineSpacing0 = controller->GetDefaultLineSpacing();
 732
 733     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 734     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 735     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 736   }
 737
 738   // single line, line spacing = 20px
 739   {
 740     const float EXPECTED_SPACING = 20.0f;
 741     const Vector2 EXPECTED_LAYOUT_SIZE( 360.0f, 19.0f );
 742     const Vector3 EXPECTED_NATURAL_SIZE( 360.0f, 40.0f, 0.0f );
 743
 744     controller->SetText(textSingle);
 745     controller->Relayout(size);
 746     controller->SetDefaultLineSpacing( 20 );
 747     controller->SetMultiLineEnabled( false );
 748
 749     Vector3 naturalSize  = controller->GetNaturalSize();
 750     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 751     float lineSpacing0 = controller->GetDefaultLineSpacing();
 752
 753     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 754     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 755     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 756   }
 757
 758   // multi-line, line spacing = 0px
 759   {
 760     const float EXPECTED_SPACING = 0.0f;
 761     const Vector2 EXPECTED_LAYOUT_SIZE( 350.0f, 39.0f );
 762     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 58.0f, 0.0f );
 763
 764     controller->SetText(textMulti);
 765     controller->Relayout(size);
 766     controller->SetMultiLineEnabled( true );
 767     controller->SetDefaultLineSpacing( 0 );
 768
 769     Vector3 naturalSize  = controller->GetNaturalSize();
 770     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 771     float lineSpacing0 = controller->GetDefaultLineSpacing();
 772
 773     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 774     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 775     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 776   }
 777
 778   // multi-line, line spacing = 20px
 779   {
 780     const float EXPECTED_SPACING = 20.0f;
 781     const Vector2 EXPECTED_LAYOUT_SIZE( 124.0f, 57.0f );
 782     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 118.0f, 0.0f );
 783
 784     controller->SetText(textMulti);
 785     controller->Relayout(size);
 786     controller->SetMultiLineEnabled( true );
 787     controller->SetDefaultLineSpacing( 20 );
 788
 789     Vector3 naturalSize  = controller->GetNaturalSize();
 790     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 791     float lineSpacing0 = controller->GetDefaultLineSpacing();
 792
 793     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 794     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 795     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 796   }
 797
 798   // multi-line, line spacing = 30px
 799   {
 800     const float EXPECTED_SPACING = 30.0f;
 801     const Vector2 EXPECTED_LAYOUT_SIZE( 124.0f, 117.0f );
 802     const Vector3 EXPECTED_NATURAL_SIZE( 124.0f, 148.0f, 0.0f );
 803
 804     controller->SetText(textMulti);
 805     controller->Relayout(size);
 806     controller->SetMultiLineEnabled( true );
 807     controller->SetDefaultLineSpacing( 30 );
 808
 809     Vector3 naturalSize  = controller->GetNaturalSize();
 810     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 811     float lineSpacing0 = controller->GetDefaultLineSpacing();
 812
 813     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 814     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 815     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 816   }
 817
 818
 819   END_TEST;
 820
 821 }
 822
 823 int UtcDaliTextControllerCheckBufferIndices(void)
 824 {
 825   tet_infoline(" UtcDaliTextControllerCheckBufferIndices");
 826   ToolkitTestApplication application;
 827
 828   // Creates a text controller.
 829   ControllerPtr controller = Controller::New();
 830
 831   ConfigureTextLabel(controller);
 832
 833   // Set the text
 834   const std::string text("A Quick Brown Fox Jumps Over The Lazy Dog");
 835   controller->SetText(text);
 836
 837   // Get the implementation of the text controller
 838   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 839
 840   // Tweak some parameters to make the indices to access the text buffer invalid
 841   mImpl.mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl.mModel->mLogicalModel->mText.Count() * 10u;
 842   mImpl.mTextUpdateInfo.mNumberOfCharactersToRemove = 0u;
 843   mImpl.mTextUpdateInfo.mPreviousNumberOfCharacters = 0u;
 844   mImpl.mOperationsPending = Controller::ALL_OPERATIONS;
 845
 846   // Perform a relayout
 847   const Size size( application.GetScene().GetSize() );
 848   controller->Relayout(size);
 849
 850   tet_result(TET_PASS);
 851
 852   END_TEST;
 853 }
 854
 855 int UtcDaliTextControllerCheckInputColorChanged(void)
 856 {
 857   tet_infoline(" UtcDaliTextControllerCheckInputColorChanged");
 858   ToolkitTestApplication application;
 859
 860   // Creates a text controller.
 861   ControllerPtr controller = Controller::New();
 862
 863   ConfigureTextLabel(controller);
 864
 865   // Enable the text input.
 866   // Creates a decorator.
 867   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 868                                                        *controller );
 869   InputMethodContext inputMethodContext = InputMethodContext::New();
 870   // Enables the text input.
 871   controller->EnableTextInput( decorator, inputMethodContext );
 872
 873   // Set the text
 874   const std::string text("Hello World!");
 875   controller->SetText(text);
 876
 877   const Vector4 inputColor( 0.0f, 0.0f, 0.0f, 1.0f );
 878   controller->SetInputColor( inputColor );
 879
 880   // Get the implementation of the text controller
 881   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 882
 883   //  Reset operation
 884   mImpl.mOperationsPending = Controller::NO_OPERATION;
 885
 886   // simulate a key event.
 887   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 888
 889   // change the input color
 890   const Vector4 newInputColor( 1.0f, 0.0f, 0.0f, 1.0f );
 891   controller->SetInputColor( newInputColor );
 892
 893   // Check if relayout is requested or not when event state is INACTIVE.
 894   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 895   DALI_TEST_EQUALS( Controller::COLOR, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::COLOR ), TEST_LOCATION );
 896
 897   // Perform a relayout
 898   const Size size( application.GetScene().GetSize() );
 899   controller->Relayout(size);
 900
 901   tet_result(TET_PASS);
 902
 903   END_TEST;
 904 }
 905
 906 int UtcDaliTextControllerCheckInputFontFamilyChanged(void)
 907 {
 908   tet_infoline(" UtcDaliTextControllerCheckInputFontFamilyChanged");
 909   ToolkitTestApplication application;
 910
 911   // Creates a text controller.
 912   ControllerPtr controller = Controller::New();
 913
 914   ConfigureTextLabel(controller);
 915
 916   // Enable the text input.
 917   // Creates a decorator.
 918   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 919                                                        *controller );
 920   InputMethodContext inputMethodContext = InputMethodContext::New();
 921   // Enables the text input.
 922   controller->EnableTextInput( decorator, inputMethodContext );
 923
 924   // Set the text and font family
 925   const std::string text("Hello World!");
 926   controller->SetText(text);
 927   controller->SetInputFontFamily("SamsungOneUI_200");
 928
 929   // Get the implementation of the text controller
 930   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 931
 932   //  Reset operation
 933   mImpl.mOperationsPending = Controller::NO_OPERATION;
 934
 935   // simulate a key event.
 936   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 937
 938   // change the input font family
 939   controller->SetInputFontFamily("SamsungOneUI_300");
 940
 941   // Check if relayout is requested or not when event state is INACTIVE.
 942   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 943   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 944                     TEST_LOCATION );
 945
 946   // Perform a relayout
 947   const Size size( application.GetScene().GetSize() );
 948   controller->Relayout(size);
 949
 950   tet_result(TET_PASS);
 951
 952   END_TEST;
 953 }
 954
 955 int UtcDaliTextControllerCheckInputFontWeightChanged(void)
 956 {
 957   tet_infoline(" UtcDaliTextControllerCheckInputFontWeightChanged");
 958   ToolkitTestApplication application;
 959
 960   // Creates a text controller.
 961   ControllerPtr controller = Controller::New();
 962
 963   ConfigureTextLabel(controller);
 964
 965   // Enable the text input.
 966   // Creates a decorator.
 967   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 968                                                        *controller );
 969   InputMethodContext inputMethodContext = InputMethodContext::New();
 970   // Enables the text input.
 971   controller->EnableTextInput( decorator, inputMethodContext );
 972
 973   // Set the text
 974   const std::string text("Hello World!");
 975   controller->SetText(text);
 976   controller->SetInputFontWeight( TextAbstraction::FontWeight::NORMAL );
 977
 978   // Get the implementation of the text controller
 979   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 980
 981   // Reset operation
 982   mImpl.mOperationsPending = Controller::NO_OPERATION;
 983
 984   // simulate a key event.
 985   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
 986
 987   // change the input font weight
 988   controller->SetInputFontWeight( TextAbstraction::FontWeight::BOLD );
 989
 990   // Check if relayout is requested or not when event state is INACTIVE.
 991   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 992   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 993                     TEST_LOCATION );
 994
 995   // Perform a relayout
 996   const Size size( application.GetScene().GetSize() );
 997   controller->Relayout(size);
 998
 999   tet_result(TET_PASS);
1000
1001   END_TEST;
1002 }
1003
1004 int UtcDaliTextControllerCheckInputFontWidthChanged(void)
1005 {
1006   tet_infoline(" UtcDaliTextControllerCheckInputFontWidthChanged");
1007   ToolkitTestApplication application;
1008
1009   // Creates a text controller.
1010   ControllerPtr controller = Controller::New();
1011
1012   ConfigureTextLabel(controller);
1013
1014   // Enable the text input.
1015   // Creates a decorator.
1016   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
1017                                                        *controller );
1018   InputMethodContext inputMethodContext = InputMethodContext::New();
1019   // Enables the text input.
1020   controller->EnableTextInput( decorator, inputMethodContext );
1021
1022   // Set the text
1023   const std::string text("Hello World!");
1024   controller->SetText(text);
1025   controller->SetInputFontWidth( TextAbstraction::FontWidth::NORMAL );
1026
1027   // Get the implementation of the text controller
1028   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1029
1030   // Reset operation
1031   mImpl.mOperationsPending = Controller::NO_OPERATION;
1032
1033   // simulate a key event.
1034   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
1035
1036   // change the input font width
1037   controller->SetInputFontWidth( TextAbstraction::FontWidth::EXPANDED );
1038
1039   // Check if relayout is requested or not when event state is INACTIVE.
1040   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1041   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
1042                     TEST_LOCATION );
1043
1044   // Perform a relayout
1045   const Size size( application.GetScene().GetSize() );
1046   controller->Relayout(size);
1047
1048   tet_result(TET_PASS);
1049
1050   END_TEST;
1051 }
1052
1053 int UtcDaliTextControllerCheckInputFontSlantChanged(void)
1054 {
1055   tet_infoline(" UtcDaliTextControllerCheckInputFontSlantChanged");
1056   ToolkitTestApplication application;
1057
1058   // Creates a text controller.
1059   ControllerPtr controller = Controller::New();
1060
1061   ConfigureTextLabel(controller);
1062
1063   // Enable the text input.
1064   // Creates a decorator.
1065   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
1066                                                        *controller );
1067   InputMethodContext inputMethodContext = InputMethodContext::New();
1068   // Enables the text input.
1069   controller->EnableTextInput( decorator, inputMethodContext );
1070
1071   // Set the text
1072   const std::string text("Hello World!");
1073   controller->SetText(text);
1074   controller->SetInputFontSlant( TextAbstraction::FontSlant::NORMAL );
1075
1076   // Get the implementation of the text controller
1077   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1078
1079   //  Reset operation
1080   mImpl.mOperationsPending = Controller::NO_OPERATION;
1081
1082   // simulate a key event.
1083   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
1084
1085   // change the input font slant
1086   controller->SetInputFontSlant( TextAbstraction::FontSlant::ROMAN );
1087
1088   // Check if relayout is requested or not when event state is INACTIVE.
1089   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1090   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
1091                     TEST_LOCATION );
1092
1093   // Perform a relayout
1094   const Size size( application.GetScene().GetSize() );
1095   controller->Relayout(size);
1096
1097   tet_result(TET_PASS);
1098
1099   END_TEST;
1100 }
1101
1102 int UtcDaliTextControllerCheckInputFontPointSizeChanged(void)
1103 {
1104   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeChanged");
1105   ToolkitTestApplication application;
1106
1107   // Creates a text controller.
1108   ControllerPtr controller = Controller::New();
1109
1110   ConfigureTextLabel(controller);
1111
1112   // Enable the text input.
1113   // Creates a decorator.
1114   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
1115                                                        *controller );
1116   InputMethodContext inputMethodContext = InputMethodContext::New();
1117   // Enables the text input.
1118   controller->EnableTextInput( decorator, inputMethodContext );
1119
1120   // Set the text
1121   const std::string text("Hello World!");
1122   controller->SetText(text);
1123   controller->SetInputFontPointSize( 1.0f );
1124
1125   // Get the implementation of the text controller
1126   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1127
1128   //  Reset operation
1129   mImpl.mOperationsPending = Controller::NO_OPERATION;
1130
1131   // simulate a key event.
1132   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::DOWN ) );
1133
1134   // change the input font point size
1135   controller->SetInputFontPointSize( 1.2f );
1136
1137   // Check if relayout is requested or not when event state is INACTIVE.
1138   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1139   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
1140                     TEST_LOCATION );
1141
1142   // Perform a relayout
1143   const Size size( application.GetScene().GetSize() );
1144   controller->Relayout(size);
1145
1146   tet_result(TET_PASS);
1147
1148   END_TEST;
1149 }
1150
1151 int UtcDaliTextControllerSelectEvent(void)
1152 {
1153   tet_infoline(" UtcDaliTextControllerSelectEvent");
1154   ToolkitTestApplication application;
1155
1156   // Creates a text controller.
1157   ControllerPtr controller = Controller::New();
1158
1159   // Configures the text controller similarly to the text-field.
1160   ConfigureTextField( controller );
1161
1162   // Set the text
1163   const std::string text("Hello World!");
1164   controller->SetText( text );
1165
1166   // Select the whole text.
1167   controller->SelectEvent( 0.f, 0.f, SelectionType::INTERACTIVE );
1168
1169   // Perform a relayout
1170   const Size size( application.GetScene().GetSize() );
1171   controller->Relayout(size);
1172
1173   // Get the implementation of the text controller
1174   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1175
1176   // Check if the whole text is selected or not.
1177   std::string retrieved_text;
1178   mImpl.RetrieveSelection( retrieved_text, false );
1179   DALI_TEST_EQUALS( "Hello", retrieved_text, TEST_LOCATION );
1180
1181   // Select the whole text.
1182   controller->SelectEvent( 0.f, 0.f, SelectionType::ALL );
1183
1184   // Perform a relayout
1185   controller->Relayout( size );
1186
1187   mImpl.RetrieveSelection( retrieved_text, false );
1188   DALI_TEST_EQUALS( text, retrieved_text, TEST_LOCATION );
1189
1190   END_TEST;
1191 }
1192
1193
1194 int UtcDaliTextControllerRemoveTextChangeEventData(void)
1195 {
1196   tet_infoline(" UtcDaliTextControllerRemoveTextChangeEventData");
1197   ToolkitTestApplication application;
1198
1199   // Creates a text controller.
1200   ControllerPtr controller = Controller::New();
1201
1202   ConfigureTextField( controller );
1203
1204   // Set the text
1205   const std::string text( "Hello World!" );
1206   controller->SetText( text );
1207   controller->SetInputFontPointSize( 1.0f );
1208
1209   // Get the implementation of the text controller
1210   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1211
1212   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1213
1214   // Send DELETE_SURROUNDING event
1215   InputMethodContext::EventData imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -1, 1 );
1216   InputMethodContext inputMethodContext = InputMethodContext::New();
1217   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1218
1219   // Force to update the model.
1220   controller->GetNaturalSize();
1221
1222   // Simulate a key event to delete text
1223   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Dali::KeyEvent::DOWN ) );
1224
1225   DALI_TEST_EQUALS( EventData::EDITING, mImpl.mEventData->mState, TEST_LOCATION );
1226
1227   // Perform a relayout
1228   const Size size( application.GetScene().GetSize() );
1229   controller->Relayout( size );
1230
1231   tet_result(TET_PASS);
1232
1233   END_TEST;
1234 }
1235
1236 int UtcDaliTextControllerCheckInputFontPointSizeUpdated(void)
1237 {
1238   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeUpdated");
1239   ToolkitTestApplication application;
1240
1241   // Creates a text controller.
1242   ControllerPtr controller = Controller::New();
1243
1244   ConfigureTextField(controller);
1245
1246   // Set the text
1247   const std::string text("Hello World!");
1248   controller->SetText( text );
1249   controller->SetInputFontPointSize( 1.0f );
1250   controller->KeyboardFocusGainEvent();
1251
1252   application.SendNotification();
1253   application.Render();
1254
1255   // Perform a relayout
1256   const Size size( application.GetScene().GetSize() );
1257   controller->Relayout(size);
1258
1259   // simulate a key event.
1260   controller->KeyEvent( GenerateKey( "a", "a", 38, 0, 0, Dali::KeyEvent::DOWN ) );
1261
1262   // change the input font point size
1263   controller->SetInputFontPointSize( 20.f );
1264
1265   application.SendNotification();
1266   application.Render();
1267
1268   // Perform a relayout
1269   controller->Relayout(size);
1270
1271   tet_result(TET_PASS);
1272
1273   END_TEST;
1274 }
1275
1276 int UtcDaliTextControllerDeleteSurroundings(void)
1277 {
1278   tet_infoline(" UtcDaliTextControllerDeleteSurroundings");
1279   ToolkitTestApplication application;
1280
1281   // Creates a text controller.
1282   ControllerPtr controller = Controller::New();
1283
1284   ConfigureTextField( controller );
1285
1286   // Get the implementation of the text controller
1287   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
1288
1289   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
1290
1291   InputMethodContext inputMethodContext = InputMethodContext::New();
1292   // Add some pre-edit text, such as Korean
1293   InputMethodContext::EventData imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "ㅂㅂㅂ", 0, 3 );
1294   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1295
1296   // Perform a relayout
1297   const Size size( application.GetScene().GetSize() );
1298
1299   application.SendNotification();
1300   application.Render();
1301
1302   controller->Relayout( size );
1303
1304   // Simulate a key event to delete one text
1305   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Dali::KeyEvent::DOWN ) );
1306
1307   // Send DELETE_SURROUNDING event (Delete All text)
1308   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -2, 2 );
1309   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
1310
1311   application.SendNotification();
1312   application.Render();
1313
1314   controller->Relayout( size );
1315
1316   // simulate a key event to add text
1317   controller->KeyEvent( GenerateKey( "ㅇ", "ㅇ", 238, 0, 0, Dali::KeyEvent::DOWN ) );
1318   controller->KeyEvent( GenerateKey( "ㅇ", "ㅇ", 238, 0, 0, Dali::KeyEvent::DOWN ) );
1319
1320   DALI_TEST_EQUALS( EventData::EDITING, mImpl.mEventData->mState, TEST_LOCATION );
1321
1322   // Force to update the model.
1323   controller->GetNaturalSize();
1324
1325   application.SendNotification();
1326   application.Render();
1327
1328   controller->Relayout( size );
1329
1330   tet_result(TET_PASS);
1331
1332   END_TEST;
1333 }