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

   1 /*
   2  * Copyright (c) 2019 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-toolkit/internal/text/text-controller.h>
  27 #include <dali-toolkit/internal/text/text-control-interface.h>
  28 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
  29 #include <dali-toolkit/internal/text/text-controller-impl.h>
  30
  31 using namespace Dali;
  32 using namespace Toolkit;
  33 using namespace Text;
  34
  35 namespace
  36 {
  37
  38 const char* const OPTION_SELECT_ALL("option-select_all");   // "Select All" popup option.
  39 const char* const OPTION_CUT("optionCut");                  // "Cut" popup option.
  40 const char* const OPTION_COPY("optionCopy");                // "Copy" popup option.
  41 const char* const OPTION_PASTE("optionPaste");              // "Paste" popup option.
  42 const char* const OPTION_CLIPBOARD("optionClipboard");      // "Clipboard" popup option.
  43
  44 const Size CONTROL_SIZE( 300.f, 60.f );
  45
  46 std::string gClipboardText;
  47 void ContentSelectedCallback( ClipboardEventNotifier& notifier )
  48 {
  49   gClipboardText = notifier.GetContent();
  50 }
  51
  52 // Generate a KeyEvent to send to Core.
  53 Dali::KeyEvent GenerateKey( const std::string& keyName,
  54                             const std::string& keyString,
  55                             int keyCode,
  56                             int keyModifier,
  57                             unsigned long timeStamp,
  58                             const Dali::KeyEvent::State& keyState )
  59 {
  60   return Dali::KeyEvent( keyName,
  61                          keyString,
  62                          keyCode,
  63                          keyModifier,
  64                          timeStamp,
  65                          keyState );
  66 }
  67
  68 } // namespace
  69
  70 int UtcDaliTextController(void)
  71 {
  72   tet_infoline(" UtcDaliTextController");
  73   ToolkitTestApplication application;
  74
  75   // Creates a text controller.
  76   ControllerPtr controller = Controller::New();
  77   DALI_TEST_CHECK( controller );
  78
  79   tet_result(TET_PASS);
  80   END_TEST;
  81 }
  82
  83 int UtcDaliTextControllerSetGetScrollEnabled(void)
  84 {
  85   tet_infoline(" UtcDaliTextControllerSetGetScrollEnabled");
  86   ToolkitTestApplication application;
  87
  88   // Creates a text controller.
  89   ControllerPtr controller = Controller::New();
  90   DALI_TEST_CHECK( controller );
  91
  92   // Configures the text controller similarly to the text-editor.
  93   ConfigureTextEditor( controller );
  94
  95   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
  96   DALI_TEST_CHECK( controller->IsVerticalScrollEnabled() );
  97
  98   // Configures the text controller similarly to the text-field.
  99   ConfigureTextField( controller );
 100
 101   DALI_TEST_CHECK( controller->IsHorizontalScrollEnabled() );
 102   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 103
 104   // Configures the text controller similarly to the text-label.
 105   ConfigureTextLabel( controller );
 106
 107   DALI_TEST_CHECK( !controller->IsHorizontalScrollEnabled() );
 108   DALI_TEST_CHECK( !controller->IsVerticalScrollEnabled() );
 109
 110   tet_result(TET_PASS);
 111   END_TEST;
 112 }
 113
 114 int UtcDaliTextControllerSetIsTextElide(void)
 115 {
 116   tet_infoline(" UtcDaliTextControllerSetIsTextElide");
 117   ToolkitTestApplication application;
 118
 119   // Creates a text controller.
 120   ControllerPtr controller = Controller::New();
 121   DALI_TEST_CHECK( controller );
 122
 123   // Configures the text controller similarly to the text-editor.
 124   ConfigureTextEditor( controller );
 125   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 126
 127   controller->SetTextElideEnabled( true );
 128   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 129
 130   // Configures the text controller similarly to the text-field.
 131   ConfigureTextField( controller );
 132   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 133
 134   controller->SetTextElideEnabled( true );
 135   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 136
 137   // Configures the text controller similarly to the text-label.
 138   ConfigureTextLabel( controller );
 139   DALI_TEST_EQUALS( true, controller->IsTextElideEnabled(), TEST_LOCATION );
 140
 141   controller->SetTextElideEnabled( false );
 142   DALI_TEST_EQUALS( false, controller->IsTextElideEnabled(), TEST_LOCATION );
 143
 144   tet_result(TET_PASS);
 145   END_TEST;
 146 }
 147
 148 int UtcDaliTextControllerEnableCursorBlinking(void)
 149 {
 150   tet_infoline(" UtcDaliTextControllerEnableCursorBlinking");
 151   ToolkitTestApplication application;
 152
 153   // Creates a text controller.
 154   ControllerPtr controller = Controller::New();
 155   DALI_TEST_CHECK( controller );
 156
 157   // There is no text input enabled.
 158   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 159
 160   // Enable the text input.
 161   // Creates a decorator.
 162   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 163                                                        *controller );
 164   InputMethodContext inputMethodContext = InputMethodContext::New();
 165   // Enables the text input.
 166   controller->EnableTextInput( decorator, inputMethodContext );
 167
 168   // Enables the cursor blink.
 169   controller->SetEnableCursorBlink( true );
 170
 171   DALI_TEST_CHECK( controller->GetEnableCursorBlink() );
 172
 173   // Disables the cursor blink.
 174   controller->SetEnableCursorBlink( false );
 175
 176   DALI_TEST_CHECK( !controller->GetEnableCursorBlink() );
 177
 178   tet_result(TET_PASS);
 179   END_TEST;
 180 }
 181
 182 int UtcDaliTextControllerImfEvent(void)
 183 {
 184   tet_infoline(" UtcDaliTextController");
 185   ToolkitTestApplication application;
 186
 187   // Creates a text controller.
 188   ControllerPtr controller = Controller::New();
 189
 190   std::string text;
 191   InputMethodContext::EventData imfEvent;
 192
 193   DALI_TEST_CHECK( controller );
 194
 195   // Enable the text input.
 196   // Creates a decorator.
 197   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 198                                                        *controller );
 199
 200   InputMethodContext inputMethodContext = InputMethodContext::New();
 201   // Enables the text input.
 202   controller->EnableTextInput( decorator, inputMethodContext );
 203
 204   // Set the placeholder text.
 205   controller->SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, "Hello Dali" );
 206
 207   // For coverage.
 208   imfEvent = InputMethodContext::EventData( InputMethodContext::GET_SURROUNDING, "", 0, 0 );
 209   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 210
 211   // Send VOID event.
 212   imfEvent = InputMethodContext::EventData( InputMethodContext::VOID, "", 0, 0 );
 213   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 214
 215   controller->GetText( text );
 216   DALI_TEST_CHECK( text.empty() );
 217
 218   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 219   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 220   controller->GetNaturalSize();
 221
 222   // Check 'Delete All' key which means the input panel send a big range
 223   imfEvent = InputMethodContext::EventData( InputMethodContext::DELETE_SURROUNDING, "", -100, 100 );
 224   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 225   controller->GetNaturalSize();
 226
 227   controller->GetText( text );
 228   DALI_TEST_EQUALS( "", text, TEST_LOCATION );
 229
 230   // Send COMMIT event.
 231   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "Hello ", 0, 6 );
 232   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 233
 234   // Force to update the model.
 235   controller->GetNaturalSize();
 236
 237   controller->GetText( text );
 238   DALI_TEST_EQUALS( "Hello ", text, TEST_LOCATION );
 239
 240   // Send PRE_EDIT event
 241   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "w", 6, 1 );
 242   controller->OnInputMethodContextEvent( inputMethodContext, imfEvent );
 243
 244   // Force to update the model.
 245   controller->GetNaturalSize();
 246
 247   controller->GetText( text );
 248   DALI_TEST_EQUALS( "Hello w", text, 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
 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 UtcDaliTextControllerTextPopupButtonTouched(void)
 289 {
 290   tet_infoline(" UtcDaliTextControllerTextPopupButtonTouched");
 291   ToolkitTestApplication application;
 292
 293   // Creates a text controller.
 294   ControllerPtr controller = Controller::New();
 295
 296   DALI_TEST_CHECK( controller );
 297
 298   std::string text;
 299   PushButton button;
 300   Property::Map attributes;
 301
 302   // Enable the text input.
 303   // Creates a decorator.
 304   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 305                                                        *controller );
 306
 307   InputMethodContext inputMethodContext = InputMethodContext::New();
 308   // Enables the text input.
 309   controller->EnableTextInput( decorator, inputMethodContext );
 310
 311   // Creates the text's popup.
 312   TextSelectionPopupCallbackInterface& callbackInterface = *controller;
 313   TextSelectionPopup textPopup = TextSelectionPopup::New( &callbackInterface );
 314
 315   Toolkit::TextSelectionPopup::Buttons buttonsToEnable = static_cast<Toolkit::TextSelectionPopup::Buttons>( TextSelectionPopup::CUT        |
 316                                                                                                             TextSelectionPopup::COPY       |
 317                                                                                                             TextSelectionPopup::PASTE      |
 318                                                                                                             TextSelectionPopup::SELECT     |
 319                                                                                                             TextSelectionPopup::SELECT_ALL |
 320                                                                                                             TextSelectionPopup::CLIPBOARD );
 321
 322   textPopup.EnableButtons( buttonsToEnable );
 323   Stage::GetCurrent().Add( textPopup );
 324   textPopup.ShowPopup();
 325
 326   // Render and notify
 327   application.SendNotification();
 328   application.Render();
 329
 330   // Sets some text.
 331   controller->SetText( "Hello world" );
 332
 333   // Select the whole text.
 334   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 335   DALI_TEST_CHECK( button );
 336
 337   button.DoAction( "buttonClick", attributes );
 338
 339   // Call relayout to process the input events.
 340   controller->Relayout( CONTROL_SIZE );
 341
 342   // Cut the text.
 343   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 344   DALI_TEST_CHECK( button );
 345
 346   button.DoAction( "buttonClick", attributes );
 347
 348   // Force to update the model.
 349   controller->GetNaturalSize();
 350
 351   controller->GetText( text );
 352   DALI_TEST_CHECK( text.empty() );
 353
 354   // Set text again.
 355   controller->SetText( "Hello world" );
 356
 357   // Select the whole text.
 358   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_SELECT_ALL ) );
 359   DALI_TEST_CHECK( button );
 360
 361   button.DoAction( "buttonClick", attributes );
 362
 363   // Call relayout to process the input events.
 364   controller->Relayout( CONTROL_SIZE );
 365
 366   // Copy to the clipboard.
 367   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_COPY ) );
 368   DALI_TEST_CHECK( button );
 369
 370   button.DoAction( "buttonClick", attributes );
 371
 372   // Call relayout to process the input events.
 373   controller->Relayout( CONTROL_SIZE );
 374
 375   // Cut the text.
 376   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CUT ) );
 377   DALI_TEST_CHECK( button );
 378
 379   button.DoAction( "buttonClick", attributes );
 380
 381   // Force to update the model.
 382   controller->GetNaturalSize();
 383
 384   controller->GetText( text );
 385   DALI_TEST_CHECK( text.empty() );
 386
 387   ClipboardEventNotifier clipboardEventNotifier = ClipboardEventNotifier::Get();
 388   clipboardEventNotifier.ContentSelectedSignal().Connect( &ContentSelectedCallback );
 389
 390   // Paste the text.
 391   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_PASTE ) );
 392   DALI_TEST_CHECK( button );
 393
 394   button.DoAction( "buttonClick", attributes );
 395
 396   // Call relayout to process the input events.
 397   controller->Relayout( CONTROL_SIZE );
 398
 399   DALI_TEST_EQUALS( "Hello world", gClipboardText, TEST_LOCATION );
 400
 401   // Show the clipboard.
 402   button = PushButton::DownCast( textPopup.FindChildByName( OPTION_CLIPBOARD ) );
 403   DALI_TEST_CHECK( button );
 404
 405   button.DoAction( "buttonClick", attributes );
 406
 407   tet_result(TET_PASS);
 408   END_TEST;
 409 }
 410
 411 int UtcDaliTextControllerGetInputShadowProperty(void)
 412 {
 413   tet_infoline(" UtcDaliTextControllerGetInputShadowProperty");
 414   ToolkitTestApplication application;
 415
 416   // Creates a text controller.
 417   ControllerPtr controller = Controller::New();
 418
 419   DALI_TEST_CHECK( controller );
 420
 421   const std::string& shadowProperties = controller->GetInputShadowProperties();
 422
 423   DALI_TEST_CHECK( shadowProperties.empty() );
 424
 425   tet_result(TET_PASS);
 426   END_TEST;
 427 }
 428
 429 int UtcDaliTextControllerGetInputUnderlineProperty(void)
 430 {
 431   tet_infoline(" UtcDaliTextControllerGetInputUnderlineProperty");
 432   ToolkitTestApplication application;
 433
 434   // Creates a text controller.
 435   ControllerPtr controller = Controller::New();
 436
 437   DALI_TEST_CHECK( controller );
 438
 439   const std::string& underlineProperties = controller->GetInputUnderlineProperties();
 440
 441   DALI_TEST_CHECK( underlineProperties.empty() );
 442
 443   tet_result(TET_PASS);
 444   END_TEST;
 445 }
 446
 447 int UtcDaliTextControllerSetGetAutoScrollEnabled(void)
 448 {
 449   tet_infoline(" UtcDaliTextControllerSetGetAutoScrollEnabled");
 450   ToolkitTestApplication application;
 451
 452   // Creates a text controller.
 453   ControllerPtr controller = Controller::New();
 454
 455   DALI_TEST_CHECK( controller );
 456
 457   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 458
 459   // The auto scrolling shouldn't be enabled if the multi-line is enabled.
 460
 461   // Enable multi-line.
 462   controller->SetMultiLineEnabled( true );
 463
 464   // Enable text scrolling.
 465   controller->SetAutoScrollEnabled( true );
 466
 467   DALI_TEST_CHECK( !controller->IsAutoScrollEnabled() );
 468
 469   // Disable multi-line.
 470   controller->SetMultiLineEnabled( false );
 471
 472   // Enable text scrolling.
 473   controller->SetAutoScrollEnabled( true );
 474
 475   // Should be ebabled now.
 476   DALI_TEST_CHECK( controller->IsAutoScrollEnabled() );
 477
 478   tet_result(TET_PASS);
 479   END_TEST;
 480 }
 481
 482 int UtcDaliTextControllerSetGetCheckProperty(void)
 483 {
 484   tet_infoline(" UtcDaliTextControllerSetGetCheckProperty");
 485   ToolkitTestApplication application;
 486
 487   // Creates a text controller.
 488   ControllerPtr controller = Controller::New();
 489
 490   DALI_TEST_CHECK( controller );
 491
 492   // Enable the text input.
 493   // Creates a decorator.
 494   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 495
 496   InputMethodContext inputMethodContext = InputMethodContext::New();
 497   // Enables the text input.
 498   controller->EnableTextInput( decorator, inputMethodContext );
 499
 500   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 501
 502   // Set the text input to password.
 503   controller->SetInputModePassword( true );
 504
 505   DALI_TEST_CHECK( controller->IsInputModePassword() );
 506
 507   // Unset the text input to password.
 508   controller->SetInputModePassword( false );
 509
 510   DALI_TEST_CHECK( !controller->IsInputModePassword() );
 511
 512   tet_result(TET_PASS);
 513   END_TEST;
 514 }
 515
 516 int UtcDaliTextControllerSetGetTapLongPressAction(void)
 517 {
 518   tet_infoline(" UtcDaliTextControllerSetGetTapLongPressAction");
 519   ToolkitTestApplication application;
 520
 521   // Creates a text controller.
 522   ControllerPtr controller = Controller::New();
 523
 524   DALI_TEST_CHECK( controller );
 525
 526   // Test first with no decorator.
 527
 528   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 529   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 530   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 531
 532   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 533   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 534   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 535
 536   // Add a decorator and re-test.
 537
 538   // Creates a decorator.
 539   Text::DecoratorPtr decorator = Text::Decorator::New( *controller, *controller );
 540
 541   InputMethodContext inputMethodContext = InputMethodContext::New();
 542   // Enables the text input.
 543   controller->EnableTextInput( decorator, inputMethodContext );
 544
 545   DALI_TEST_EQUALS( Controller::NoTextTap::NO_ACTION, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 546   controller->SetNoTextDoubleTapAction( Controller::NoTextTap::HIGHLIGHT );
 547   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextDoubleTapAction(), TEST_LOCATION );
 548
 549   DALI_TEST_EQUALS( Controller::NoTextTap::SHOW_SELECTION_POPUP, controller->GetNoTextLongPressAction(), TEST_LOCATION ); // The default is SHOW_SELECTION_POPUP
 550   controller->SetNoTextLongPressAction( Controller::NoTextTap::HIGHLIGHT );
 551   DALI_TEST_EQUALS( Controller::NoTextTap::HIGHLIGHT, controller->GetNoTextLongPressAction(), TEST_LOCATION );
 552
 553   END_TEST;
 554 }
 555
 556 int UtcDaliTextControllerSetGetLineSpacingProperty(void)
 557 {
 558   tet_infoline(" UtcDaliTextControllerSetGetLineSpacingProperty");
 559   ToolkitTestApplication application;
 560
 561   const Size size( Dali::Stage::GetCurrent().GetSize() );
 562
 563   // single line text
 564   const std::string textSingle("A Quick Brown Fox Jumps Over The Lazy Dog");
 565
 566   // multi-line text
 567   const std::string textMulti("A Quick Brown\nFox Jumps Over\nThe Lazy Dog");
 568
 569   // Creates a text controller.
 570   ControllerPtr controller = Controller::New();
 571
 572   ConfigureTextLabel(controller);
 573
 574   // single line, line spacing = 0px
 575   {
 576     const float EXPECTED_SPACING = 0.0f;
 577     const Vector2 EXPECTED_LAYOUT_SIZE( 343.0f, 19.0f);
 578     const Vector3 EXPECTED_NATURAL_SIZE( 344.0f, 20.0f, 0.0f );
 579
 580     controller->SetText(textSingle);
 581     controller->Relayout(size);
 582     controller->SetMultiLineEnabled( false );
 583
 584     Vector3 naturalSize  = controller->GetNaturalSize();
 585     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 586     float lineSpacing0 = controller->GetDefaultLineSpacing();
 587
 588     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 589     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 590     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 591   }
 592
 593   // single line, line spacing = 20px
 594   {
 595     const float EXPECTED_SPACING = 20.0f;
 596     const Vector2 EXPECTED_LAYOUT_SIZE( 343.0f, 19.0f );
 597     const Vector3 EXPECTED_NATURAL_SIZE( 344.0f, 40.0f, 0.0f );
 598
 599     controller->SetText(textSingle);
 600     controller->Relayout(size);
 601     controller->SetDefaultLineSpacing( 20 );
 602     controller->SetMultiLineEnabled( false );
 603
 604     Vector3 naturalSize  = controller->GetNaturalSize();
 605     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 606     float lineSpacing0 = controller->GetDefaultLineSpacing();
 607
 608     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 609     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 610     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 611   }
 612
 613   // multi-line, line spacing = 0px
 614   {
 615     const float EXPECTED_SPACING = 0.0f;
 616     const Vector2 EXPECTED_LAYOUT_SIZE( 333.0f, 39.0f );
 617     const Vector3 EXPECTED_NATURAL_SIZE( 120.0f, 58.0f, 0.0f );
 618
 619     controller->SetText(textMulti);
 620     controller->Relayout(size);
 621     controller->SetMultiLineEnabled( true );
 622     controller->SetDefaultLineSpacing( 0 );
 623
 624     Vector3 naturalSize  = controller->GetNaturalSize();
 625     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 626     float lineSpacing0 = controller->GetDefaultLineSpacing();
 627
 628     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 629     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 630     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 631   }
 632
 633   // multi-line, line spacing = 20px
 634   {
 635     const float EXPECTED_SPACING = 20.0f;
 636     const Vector2 EXPECTED_LAYOUT_SIZE( 119.0f, 57.0f );
 637     const Vector3 EXPECTED_NATURAL_SIZE( 120.0f, 118.0f, 0.0f );
 638
 639     controller->SetText(textMulti);
 640     controller->Relayout(size);
 641     controller->SetMultiLineEnabled( true );
 642     controller->SetDefaultLineSpacing( 20 );
 643
 644     Vector3 naturalSize  = controller->GetNaturalSize();
 645     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 646     float lineSpacing0 = controller->GetDefaultLineSpacing();
 647
 648     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 649     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 650     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 651   }
 652
 653   // multi-line, line spacing = 30px
 654   {
 655     const float EXPECTED_SPACING = 30.0f;
 656     const Vector2 EXPECTED_LAYOUT_SIZE( 119.0f, 117.0f );
 657     const Vector3 EXPECTED_NATURAL_SIZE( 120.0f, 148.0f, 0.0f );
 658
 659     controller->SetText(textMulti);
 660     controller->Relayout(size);
 661     controller->SetMultiLineEnabled( true );
 662     controller->SetDefaultLineSpacing( 30 );
 663
 664     Vector3 naturalSize  = controller->GetNaturalSize();
 665     Vector2 layoutSize   = controller->GetTextModel()->GetLayoutSize();
 666     float lineSpacing0 = controller->GetDefaultLineSpacing();
 667
 668     DALI_TEST_EQUALS( EXPECTED_SPACING, lineSpacing0, TEST_LOCATION );
 669     DALI_TEST_EQUALS( EXPECTED_LAYOUT_SIZE, layoutSize, TEST_LOCATION );
 670     DALI_TEST_EQUALS( EXPECTED_NATURAL_SIZE, naturalSize, TEST_LOCATION );
 671   }
 672
 673
 674   END_TEST;
 675
 676 }
 677
 678 int UtcDaliTextControllerCheckBufferIndices(void)
 679 {
 680   tet_infoline(" UtcDaliTextControllerCheckBufferIndices");
 681   ToolkitTestApplication application;
 682
 683   // Creates a text controller.
 684   ControllerPtr controller = Controller::New();
 685
 686   ConfigureTextLabel(controller);
 687
 688   // Set the text
 689   const std::string text("A Quick Brown Fox Jumps Over The Lazy Dog");
 690   controller->SetText(text);
 691
 692   // Get the implementation of the text controller
 693   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 694
 695   // Tweak some parameters to make the indices to access the text buffer invalid
 696   mImpl.mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl.mModel->mLogicalModel->mText.Count() * 10u;
 697   mImpl.mTextUpdateInfo.mNumberOfCharactersToRemove = 0u;
 698   mImpl.mTextUpdateInfo.mPreviousNumberOfCharacters = 0u;
 699   mImpl.mOperationsPending = Controller::ALL_OPERATIONS;
 700
 701   // Perform a relayout
 702   const Size size( Dali::Stage::GetCurrent().GetSize() );
 703   controller->Relayout(size);
 704
 705   tet_result(TET_PASS);
 706
 707   END_TEST;
 708 }
 709
 710 int UtcDaliTextControllerCheckInputColorChanged(void)
 711 {
 712   tet_infoline(" UtcDaliTextControllerCheckInputColorChanged");
 713   ToolkitTestApplication application;
 714
 715   // Creates a text controller.
 716   ControllerPtr controller = Controller::New();
 717
 718   ConfigureTextLabel(controller);
 719
 720   // Enable the text input.
 721   // Creates a decorator.
 722   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 723                                                        *controller );
 724   InputMethodContext inputMethodContext = InputMethodContext::New();
 725   // Enables the text input.
 726   controller->EnableTextInput( decorator, inputMethodContext );
 727
 728   // Set the text
 729   const std::string text("Hello World!");
 730   controller->SetText(text);
 731
 732   const Vector4 inputColor( 0.0f, 0.0f, 0.0f, 1.0f );
 733   controller->SetInputColor( inputColor );
 734
 735   // Get the implementation of the text controller
 736   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 737
 738   //  Reset operation
 739   mImpl.mOperationsPending = Controller::NO_OPERATION;
 740
 741   // simulate a key event.
 742   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 743
 744   // change the input color
 745   const Vector4 newInputColor( 1.0f, 0.0f, 0.0f, 1.0f );
 746   controller->SetInputColor( newInputColor );
 747
 748   // Check if relayout is requested or not when event state is INACTIVE.
 749   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 750   DALI_TEST_EQUALS( Controller::COLOR, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::COLOR ), TEST_LOCATION );
 751
 752   // Perform a relayout
 753   const Size size( Dali::Stage::GetCurrent().GetSize() );
 754   controller->Relayout(size);
 755
 756   tet_result(TET_PASS);
 757
 758   END_TEST;
 759 }
 760
 761 int UtcDaliTextControllerCheckInputFontFamilyChanged(void)
 762 {
 763   tet_infoline(" UtcDaliTextControllerCheckInputFontFamilyChanged");
 764   ToolkitTestApplication application;
 765
 766   // Creates a text controller.
 767   ControllerPtr controller = Controller::New();
 768
 769   ConfigureTextLabel(controller);
 770
 771   // Enable the text input.
 772   // Creates a decorator.
 773   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 774                                                        *controller );
 775   InputMethodContext inputMethodContext = InputMethodContext::New();
 776   // Enables the text input.
 777   controller->EnableTextInput( decorator, inputMethodContext );
 778
 779   // Set the text and font family
 780   const std::string text("Hello World!");
 781   controller->SetText(text);
 782   controller->SetInputFontFamily("SamsungOneUI_200");
 783
 784   // Get the implementation of the text controller
 785   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 786
 787   //  Reset operation
 788   mImpl.mOperationsPending = Controller::NO_OPERATION;
 789
 790   // simulate a key event.
 791   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 792
 793   // change the input font family
 794   controller->SetInputFontFamily("SamsungOneUI_300");
 795
 796   // Check if relayout is requested or not when event state is INACTIVE.
 797   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 798   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 799                     TEST_LOCATION );
 800
 801   // Perform a relayout
 802   const Size size( Dali::Stage::GetCurrent().GetSize() );
 803   controller->Relayout(size);
 804
 805   tet_result(TET_PASS);
 806
 807   END_TEST;
 808 }
 809
 810 int UtcDaliTextControllerCheckInputFontWeightChanged(void)
 811 {
 812   tet_infoline(" UtcDaliTextControllerCheckInputFontWeightChanged");
 813   ToolkitTestApplication application;
 814
 815   // Creates a text controller.
 816   ControllerPtr controller = Controller::New();
 817
 818   ConfigureTextLabel(controller);
 819
 820   // Enable the text input.
 821   // Creates a decorator.
 822   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 823                                                        *controller );
 824   InputMethodContext inputMethodContext = InputMethodContext::New();
 825   // Enables the text input.
 826   controller->EnableTextInput( decorator, inputMethodContext );
 827
 828   // Set the text
 829   const std::string text("Hello World!");
 830   controller->SetText(text);
 831   controller->SetInputFontWeight( TextAbstraction::FontWeight::NORMAL );
 832
 833   // Get the implementation of the text controller
 834   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 835
 836   // Reset operation
 837   mImpl.mOperationsPending = Controller::NO_OPERATION;
 838
 839   // simulate a key event.
 840   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 841
 842   // change the input font weight
 843   controller->SetInputFontWeight( TextAbstraction::FontWeight::BOLD );
 844
 845   // Check if relayout is requested or not when event state is INACTIVE.
 846   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 847   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 848                     TEST_LOCATION );
 849
 850   // Perform a relayout
 851   const Size size( Dali::Stage::GetCurrent().GetSize() );
 852   controller->Relayout(size);
 853
 854   tet_result(TET_PASS);
 855
 856   END_TEST;
 857 }
 858
 859 int UtcDaliTextControllerCheckInputFontWidthChanged(void)
 860 {
 861   tet_infoline(" UtcDaliTextControllerCheckInputFontWidthChanged");
 862   ToolkitTestApplication application;
 863
 864   // Creates a text controller.
 865   ControllerPtr controller = Controller::New();
 866
 867   ConfigureTextLabel(controller);
 868
 869   // Enable the text input.
 870   // Creates a decorator.
 871   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 872                                                        *controller );
 873   InputMethodContext inputMethodContext = InputMethodContext::New();
 874   // Enables the text input.
 875   controller->EnableTextInput( decorator, inputMethodContext );
 876
 877   // Set the text
 878   const std::string text("Hello World!");
 879   controller->SetText(text);
 880   controller->SetInputFontWidth( TextAbstraction::FontWidth::NORMAL );
 881
 882   // Get the implementation of the text controller
 883   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 884
 885   // Reset operation
 886   mImpl.mOperationsPending = Controller::NO_OPERATION;
 887
 888   // simulate a key event.
 889   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 890
 891   // change the input font width
 892   controller->SetInputFontWidth( TextAbstraction::FontWidth::EXPANDED );
 893
 894   // Check if relayout is requested or not when event state is INACTIVE.
 895   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 896   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 897                     TEST_LOCATION );
 898
 899   // Perform a relayout
 900   const Size size( Dali::Stage::GetCurrent().GetSize() );
 901   controller->Relayout(size);
 902
 903   tet_result(TET_PASS);
 904
 905   END_TEST;
 906 }
 907
 908 int UtcDaliTextControllerCheckInputFontSlantChanged(void)
 909 {
 910   tet_infoline(" UtcDaliTextControllerCheckInputFontSlantChanged");
 911   ToolkitTestApplication application;
 912
 913   // Creates a text controller.
 914   ControllerPtr controller = Controller::New();
 915
 916   ConfigureTextLabel(controller);
 917
 918   // Enable the text input.
 919   // Creates a decorator.
 920   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 921                                                        *controller );
 922   InputMethodContext inputMethodContext = InputMethodContext::New();
 923   // Enables the text input.
 924   controller->EnableTextInput( decorator, inputMethodContext );
 925
 926   // Set the text
 927   const std::string text("Hello World!");
 928   controller->SetText(text);
 929   controller->SetInputFontSlant( TextAbstraction::FontSlant::NORMAL );
 930
 931   // Get the implementation of the text controller
 932   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 933
 934   //  Reset operation
 935   mImpl.mOperationsPending = Controller::NO_OPERATION;
 936
 937   // simulate a key event.
 938   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 939
 940   // change the input font slant
 941   controller->SetInputFontSlant( TextAbstraction::FontSlant::ROMAN );
 942
 943   // Check if relayout is requested or not when event state is INACTIVE.
 944   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 945   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 946                     TEST_LOCATION );
 947
 948   // Perform a relayout
 949   const Size size( Dali::Stage::GetCurrent().GetSize() );
 950   controller->Relayout(size);
 951
 952   tet_result(TET_PASS);
 953
 954   END_TEST;
 955 }
 956
 957 int UtcDaliTextControllerCheckInputFontPointSizeChanged(void)
 958 {
 959   tet_infoline(" UtcDaliTextControllerCheckInputFontPointSizeChanged");
 960   ToolkitTestApplication application;
 961
 962   // Creates a text controller.
 963   ControllerPtr controller = Controller::New();
 964
 965   ConfigureTextLabel(controller);
 966
 967   // Enable the text input.
 968   // Creates a decorator.
 969   Text::DecoratorPtr decorator = Text::Decorator::New( *controller,
 970                                                        *controller );
 971   InputMethodContext inputMethodContext = InputMethodContext::New();
 972   // Enables the text input.
 973   controller->EnableTextInput( decorator, inputMethodContext );
 974
 975   // Set the text
 976   const std::string text("Hello World!");
 977   controller->SetText(text);
 978   controller->SetInputFontPointSize( 1.0f );
 979
 980   // Get the implementation of the text controller
 981   Controller::Impl& mImpl = Controller::Impl::GetImplementation( *controller.Get() );
 982
 983   //  Reset operation
 984   mImpl.mOperationsPending = Controller::NO_OPERATION;
 985
 986   // simulate a key event.
 987   controller->KeyEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Dali::KeyEvent::Down ) );
 988
 989   // change the input font point size
 990   controller->SetInputFontPointSize( 1.2f );
 991
 992   // Check if relayout is requested or not when event state is INACTIVE.
 993   DALI_TEST_EQUALS( EventData::INACTIVE, mImpl.mEventData->mState, TEST_LOCATION );
 994   DALI_TEST_EQUALS( Controller::VALIDATE_FONTS, static_cast<Controller::OperationsMask>( mImpl.mOperationsPending & Controller::VALIDATE_FONTS ),
 995                     TEST_LOCATION );
 996
 997   // Perform a relayout
 998   const Size size( Dali::Stage::GetCurrent().GetSize() );
 999   controller->Relayout(size);
1000
1001   tet_result(TET_PASS);
1002
1003   END_TEST;
1004 }