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