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

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