automated-tests/src/dali-toolkit/utc-Dali-TextField.cpp

   1 /*
   2  * Copyright (c) 2014 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 #include <stdlib.h>
  20 #include <dali/devel-api/rendering/renderer.h>
  21 #include <dali/integration-api/events/key-event-integ.h>
  22 #include <dali/integration-api/events/tap-gesture-event.h>
  23 #include <dali/integration-api/events/touch-event-integ.h>
  24 #include <dali/integration-api/events/pan-gesture-event.h>
  25 #include <dali-toolkit-test-suite-utils.h>
  26 #include <dali-toolkit/dali-toolkit.h>
  27
  28 using namespace Dali;
  29 using namespace Toolkit;
  30
  31 void dali_textfield_startup(void)
  32 {
  33   test_return_value = TET_UNDEF;
  34 }
  35
  36 void dali_textfield_cleanup(void)
  37 {
  38   test_return_value = TET_PASS;
  39 }
  40
  41 namespace
  42 {
  43
  44 const char* const PROPERTY_NAME_RENDERING_BACKEND                    = "renderingBackend";
  45 const char* const PROPERTY_NAME_TEXT                                 = "text";
  46 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT                     = "placeholderText";
  47 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED             = "placeholderTextFocused";
  48 const char* const PROPERTY_NAME_FONT_FAMILY                          = "fontFamily";
  49 const char* const PROPERTY_NAME_FONT_STYLE                           = "fontStyle";
  50 const char* const PROPERTY_NAME_POINT_SIZE                           = "pointSize";
  51 const char* const PROPERTY_NAME_MAX_LENGTH                           = "maxLength";
  52 const char* const PROPERTY_NAME_EXCEED_POLICY                        = "exceedPolicy";
  53 const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT                 = "horizontalAlignment";
  54 const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT                   = "verticalAlignment";
  55 const char* const PROPERTY_NAME_TEXT_COLOR                           = "textColor";
  56 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR               = "placeholderTextColor";
  57 const char* const PROPERTY_NAME_SHADOW_OFFSET                        = "shadowOffset";
  58 const char* const PROPERTY_NAME_SHADOW_COLOR                         = "shadowColor";
  59 const char* const PROPERTY_NAME_PRIMARY_CURSOR_COLOR                 = "primaryCursorColor";
  60 const char* const PROPERTY_NAME_SECONDARY_CURSOR_COLOR               = "secondaryCursorColor";
  61 const char* const PROPERTY_NAME_ENABLE_CURSOR_BLINK                  = "enableCursorBlink";
  62 const char* const PROPERTY_NAME_CURSOR_BLINK_INTERVAL                = "cursorBlinkInterval";
  63 const char* const PROPERTY_NAME_CURSOR_BLINK_DURATION                = "cursorBlinkDuration";
  64 const char* const PROPERTY_NAME_CURSOR_WIDTH                         = "cursorWidth";
  65 const char* const PROPERTY_NAME_GRAB_HANDLE_IMAGE                    = "grabHandleImage";
  66 const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE            = "grabHandlePressedImage";
  67 const char* const PROPERTY_NAME_SCROLL_THRESHOLD                     = "scrollThreshold";
  68 const char* const PROPERTY_NAME_SCROLL_SPEED                         = "scrollSpeed";
  69 const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT          = "selectionHandleImageLeft";
  70 const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT         = "selectionHandleImageRight";
  71 const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT  = "selectionHandlePressedImageLeft";
  72 const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = "selectionHandlePressedImageRight";
  73 const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT   = "selectionHandleMarkerImageLeft";
  74 const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT  = "selectionHandleMarkerImageRight";
  75 const char* const PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR            = "selectionHighlightColor";
  76 const char* const PROPERTY_NAME_DECORATION_BOUNDING_BOX              = "decorationBoundingBox";
  77 const char* const PROPERTY_NAME_INPUT_METHOD_SETTINGS                = "inputMethodSettings";
  78 const char* const PROPERTY_NAME_INPUT_COLOR                          = "inputColor";
  79 const char* const PROPERTY_NAME_ENABLE_MARKUP                        = "enableMarkup";
  80 const char* const PROPERTY_NAME_INPUT_FONT_FAMILY                    = "inputFontFamily";
  81 const char* const PROPERTY_NAME_INPUT_FONT_STYLE                     = "inputFontStyle";
  82 const char* const PROPERTY_NAME_INPUT_POINT_SIZE                     = "inputPointSize";
  83
  84 const char* const PROPERTY_NAME_UNDERLINE                            = "underline";
  85 const char* const PROPERTY_NAME_INPUT_UNDERLINE                      = "inputUnderline";
  86 const char* const PROPERTY_NAME_SHADOW                               = "shadow";
  87 const char* const PROPERTY_NAME_INPUT_SHADOW                         = "inputShadow";
  88 const char* const PROPERTY_NAME_EMBOSS                               = "emboss";
  89 const char* const PROPERTY_NAME_INPUT_EMBOSS                         = "inputEmboss";
  90 const char* const PROPERTY_NAME_OUTLINE                              = "outline";
  91 const char* const PROPERTY_NAME_INPUT_OUTLINE                        = "inputOutline";
  92
  93 const int DEFAULT_RENDERING_BACKEND = Dali::Toolkit::Text::DEFAULT_RENDERING_BACKEND;
  94
  95 const Vector4 PLACEHOLDER_TEXT_COLOR( 0.8f, 0.8f, 0.8f, 0.8f );
  96 const Dali::Vector4 LIGHT_BLUE( 0.75f, 0.96f, 1.f, 1.f ); // The text highlight color.
  97
  98 const unsigned int CURSOR_BLINK_INTERVAL = 500u; // Cursor blink interval
  99 const float RENDER_FRAME_INTERVAL = 16.66f;
 100
 101 const float TO_MILLISECONDS = 1000.f;
 102 const float TO_SECONDS = 1.f / TO_MILLISECONDS;
 103
 104 const float SCROLL_THRESHOLD = 10.f;
 105 const float SCROLL_SPEED = 300.f;
 106
 107 static bool gTextChangedCallBackCalled;
 108 static bool gMaxCharactersCallBackCalled;
 109
 110 static void LoadBitmapResource(TestPlatformAbstraction& platform, int width, int height)
 111 {
 112   Integration::ResourceRequest* request = platform.GetRequest();
 113   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
 114   Integration::ResourcePointer resource(bitmap);
 115   bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, width, height, width, height);
 116
 117   if(request)
 118   {
 119     platform.SetResourceLoaded(request->GetId(), request->GetType()->id, resource);
 120   }
 121 }
 122
 123 static void LoadMarkerImages(ToolkitTestApplication& app, TextField textField)
 124 {
 125   int width(40);
 126   int height(40);
 127   LoadBitmapResource( app.GetPlatform(), width, height );
 128
 129   Property::Map propertyMap;
 130   propertyMap["filename"] = "image.png";
 131   propertyMap["width"] = width;
 132   propertyMap["height"] = height;
 133   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, propertyMap );
 134   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT, propertyMap );
 135   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT, propertyMap );
 136   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, propertyMap );
 137   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, propertyMap );
 138   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, propertyMap );
 139   textField.SetProperty( Toolkit::TextField::Property::GRAB_HANDLE_IMAGE, propertyMap );
 140   textField.SetProperty( Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE, propertyMap );
 141 }
 142
 143 // Generate a PanGestureEvent to send to Core
 144 static Integration::PanGestureEvent GeneratePan(
 145     Gesture::State state,
 146     const Vector2& previousPosition,
 147     const Vector2& currentPosition,
 148     unsigned long timeDelta,
 149     unsigned int numberOfTouches = 1)
 150 {
 151   Integration::PanGestureEvent pan(state);
 152
 153   pan.previousPosition = previousPosition;
 154   pan.currentPosition = currentPosition;
 155   pan.timeDelta = timeDelta;
 156   pan.numberOfTouches = numberOfTouches;
 157
 158   return pan;
 159 }
 160
 161 /**
 162  * Helper to generate PanGestureEvent
 163  *
 164  * @param[in] application Application instance
 165  * @param[in] state The Gesture State
 166  * @param[in] pos The current position of touch.
 167  */
 168 static void SendPan(ToolkitTestApplication& application, Gesture::State state, const Vector2& pos)
 169 {
 170   static Vector2 last;
 171
 172   if( (state == Gesture::Started) ||
 173       (state == Gesture::Possible) )
 174   {
 175     last.x = pos.x;
 176     last.y = pos.y;
 177   }
 178
 179   application.ProcessEvent(GeneratePan(state, last, pos, 16));
 180
 181   last.x = pos.x;
 182   last.y = pos.y;
 183 }
 184
 185 /*
 186  * Simulate time passed by.
 187  *
 188  * @note this will always process at least 1 frame (1/60 sec)
 189  *
 190  * @param application Test application instance
 191  * @param duration Time to pass in milliseconds.
 192  * @return The actual time passed in milliseconds
 193  */
 194 static int Wait(ToolkitTestApplication& application, int duration = 0)
 195 {
 196   int time = 0;
 197
 198   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
 199   {
 200     application.SendNotification();
 201     application.Render(RENDER_FRAME_INTERVAL);
 202     time += RENDER_FRAME_INTERVAL;
 203   }
 204
 205   return time;
 206 }
 207
 208
 209 static void TestTextChangedCallback( TextField control )
 210 {
 211   tet_infoline(" TestTextChangedCallback");
 212
 213   gTextChangedCallBackCalled = true;
 214 }
 215
 216 static void TestMaxLengthReachedCallback( TextField control )
 217 {
 218   tet_infoline(" TestMaxLengthReachedCallback");
 219
 220   gMaxCharactersCallBackCalled = true;
 221 }
 222
 223 // Generate a TapGestureEvent to send to Core.
 224 Integration::TapGestureEvent GenerateTap(
 225     Gesture::State state,
 226     unsigned int numberOfTaps,
 227     unsigned int numberOfTouches,
 228     Vector2 point)
 229 {
 230   Integration::TapGestureEvent tap( state );
 231
 232   tap.numberOfTaps = numberOfTaps;
 233   tap.numberOfTouches = numberOfTouches;
 234   tap.point = point;
 235
 236   return tap;
 237 }
 238
 239 // Generate a KeyEvent to send to Core.
 240 Integration::KeyEvent GenerateKey( const std::string& keyName,
 241                                    const std::string& keyString,
 242                                    int keyCode,
 243                                    int keyModifier,
 244                                    unsigned long timeStamp,
 245                                    const Integration::KeyEvent::State& keyState )
 246 {
 247   return Integration::KeyEvent( keyName,
 248                                 keyString,
 249                                 keyCode,
 250                                 keyModifier,
 251                                 timeStamp,
 252                                 keyState );
 253 }
 254
 255 } // namespace
 256
 257 int UtcDaliToolkitTextFieldConstructorP(void)
 258 {
 259   ToolkitTestApplication application;
 260   tet_infoline(" UtcDaliToolkitTextFieldConstructorP");
 261   TextField textField;
 262   DALI_TEST_CHECK( !textField );
 263   END_TEST;
 264 }
 265
 266 int UtcDaliToolkitTextFieldNewP(void)
 267 {
 268   ToolkitTestApplication application;
 269   tet_infoline(" UtcDaliToolkitTextFieldNewP");
 270   TextField textField = TextField::New();
 271   DALI_TEST_CHECK( textField );
 272   END_TEST;
 273 }
 274
 275 int UtcDaliToolkitTextFieldDownCastP(void)
 276 {
 277   ToolkitTestApplication application;
 278   tet_infoline(" UtcDaliToolkitTextFieldDownCastP");
 279   TextField textField1 = TextField::New();
 280   BaseHandle object( textField1 );
 281
 282   TextField textField2 = TextField::DownCast( object );
 283   DALI_TEST_CHECK( textField2 );
 284
 285   TextField textField3 = DownCast< TextField >( object );
 286   DALI_TEST_CHECK( textField3 );
 287   END_TEST;
 288 }
 289
 290 int UtcDaliToolkitTextFieldDownCastN(void)
 291 {
 292   ToolkitTestApplication application;
 293   tet_infoline(" UtcDaliToolkitTextFieldDownCastN");
 294   BaseHandle uninitializedObject;
 295   TextField textField1 = TextField::DownCast( uninitializedObject );
 296   DALI_TEST_CHECK( !textField1 );
 297
 298   TextField textField2 = DownCast< TextField >( uninitializedObject );
 299   DALI_TEST_CHECK( !textField2 );
 300   END_TEST;
 301 }
 302
 303 int UtcDaliToolkitTextFieldCopyConstructorP(void)
 304 {
 305   ToolkitTestApplication application;
 306   tet_infoline(" UtcDaliToolkitTextFieldCopyConstructorP");
 307   TextField textField = TextField::New();
 308   textField.SetProperty( TextField::Property::TEXT, "Test" );
 309
 310   TextField copy( textField );
 311   DALI_TEST_CHECK( copy );
 312   DALI_TEST_CHECK( copy.GetProperty<std::string>( TextLabel::Property::TEXT ) == textField.GetProperty<std::string>( TextLabel::Property::TEXT ) );
 313   END_TEST;
 314 }
 315
 316 int UtcDaliToolkitTextFieldAssignmentOperatorP(void)
 317 {
 318   ToolkitTestApplication application;
 319   tet_infoline(" UtcDaliToolkitTextFieldAssignmentOperatorP");
 320   TextField textField = TextField::New();
 321   textField.SetProperty( TextField::Property::TEXT, "Test" );
 322
 323   TextField copy = textField;
 324   DALI_TEST_CHECK( copy );
 325   DALI_TEST_CHECK( copy.GetProperty<std::string>( TextField::Property::TEXT ) == textField.GetProperty<std::string>( TextField::Property::TEXT ) );
 326   END_TEST;
 327 }
 328
 329 int UtcDaliTextFieldNewP(void)
 330 {
 331   ToolkitTestApplication application;
 332   tet_infoline(" UtcDaliToolkitTextFieldNewP");
 333   TextField textField = TextField::New();
 334   DALI_TEST_CHECK( textField );
 335   END_TEST;
 336 }
 337
 338 // Positive test case for a method
 339 int UtcDaliTextFieldGetPropertyP(void)
 340 {
 341   ToolkitTestApplication application;
 342   tet_infoline(" UtcDaliToolkitTextFieldGetPropertyP");
 343   TextField field = TextField::New();
 344   DALI_TEST_CHECK( field );
 345
 346   // Check Property Indices are correct
 347   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_RENDERING_BACKEND ) == TextField::Property::RENDERING_BACKEND );
 348   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_TEXT ) == TextField::Property::TEXT );
 349   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT ) == TextField::Property::PLACEHOLDER_TEXT );
 350   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED ) == TextField::Property::PLACEHOLDER_TEXT_FOCUSED );
 351   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_FONT_FAMILY ) == TextField::Property::FONT_FAMILY );
 352   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_FONT_STYLE ) == TextField::Property::FONT_STYLE );
 353   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_POINT_SIZE ) == TextField::Property::POINT_SIZE );
 354   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_MAX_LENGTH ) == TextField::Property::MAX_LENGTH );
 355   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_EXCEED_POLICY ) == TextField::Property::EXCEED_POLICY );
 356   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_HORIZONTAL_ALIGNMENT ) == TextField::Property::HORIZONTAL_ALIGNMENT );
 357   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_VERTICAL_ALIGNMENT ) == TextField::Property::VERTICAL_ALIGNMENT );
 358   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_TEXT_COLOR ) == TextField::Property::TEXT_COLOR );
 359   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR ) == TextField::Property::PLACEHOLDER_TEXT_COLOR );
 360   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SHADOW_OFFSET ) == TextField::Property::SHADOW_OFFSET );
 361   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SHADOW_COLOR ) == TextField::Property::SHADOW_COLOR );
 362   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PRIMARY_CURSOR_COLOR ) == TextField::Property::PRIMARY_CURSOR_COLOR );
 363   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SECONDARY_CURSOR_COLOR ) == TextField::Property::SECONDARY_CURSOR_COLOR );
 364   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_CURSOR_BLINK ) == TextField::Property::ENABLE_CURSOR_BLINK );
 365   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_BLINK_INTERVAL ) == TextField::Property::CURSOR_BLINK_INTERVAL );
 366   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_BLINK_DURATION ) == TextField::Property::CURSOR_BLINK_DURATION );
 367   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_WIDTH ) == TextField::Property::CURSOR_WIDTH );
 368   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_GRAB_HANDLE_IMAGE ) == TextField::Property::GRAB_HANDLE_IMAGE );
 369   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE ) == TextField::Property::GRAB_HANDLE_PRESSED_IMAGE );
 370   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SCROLL_THRESHOLD ) == TextField::Property::SCROLL_THRESHOLD );
 371   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SCROLL_SPEED ) == TextField::Property::SCROLL_SPEED );
 372   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_IMAGE_LEFT );
 373   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT );
 374   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT );
 375   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT );
 376   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT );
 377   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT );
 378   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR ) == TextField::Property::SELECTION_HIGHLIGHT_COLOR );
 379   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_DECORATION_BOUNDING_BOX ) == TextField::Property::DECORATION_BOUNDING_BOX );
 380   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_METHOD_SETTINGS ) == TextField::Property::INPUT_METHOD_SETTINGS );
 381   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_COLOR ) == TextField::Property::INPUT_COLOR );
 382   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_MARKUP ) == TextField::Property::ENABLE_MARKUP );
 383   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_FONT_FAMILY ) == TextField::Property::INPUT_FONT_FAMILY );
 384   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_FONT_STYLE ) == TextField::Property::INPUT_FONT_STYLE );
 385   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_POINT_SIZE ) == TextField::Property::INPUT_POINT_SIZE );
 386   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_UNDERLINE ) == TextField::Property::UNDERLINE );
 387   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_UNDERLINE ) == TextField::Property::INPUT_UNDERLINE );
 388   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SHADOW ) == TextField::Property::SHADOW );
 389   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_SHADOW ) == TextField::Property::INPUT_SHADOW );
 390   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_EMBOSS ) == TextField::Property::EMBOSS );
 391   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_EMBOSS ) == TextField::Property::INPUT_EMBOSS );
 392   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_OUTLINE ) == TextField::Property::OUTLINE );
 393   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_OUTLINE ) == TextField::Property::INPUT_OUTLINE );
 394
 395   END_TEST;
 396 }
 397
 398 bool SetPropertyMapRetrieved( TextField& field, const Property::Index property, const std::string mapKey, const std::string mapValue )
 399 {
 400   bool result = false;
 401   Property::Map imageMap;
 402   imageMap[mapKey] =mapValue;
 403
 404   field.SetProperty( property , imageMap );
 405   Property::Value propValue = field.GetProperty( property );
 406   Property::Map* resultMap = propValue.GetMap();
 407
 408   if ( resultMap->Find( mapKey )->Get< std::string>() == mapValue )
 409   {
 410     result = true;
 411   }
 412
 413   return result;
 414 }
 415
 416 // Positive test case for a method
 417 int UtcDaliTextFieldSetPropertyP(void)
 418 {
 419   ToolkitTestApplication application;
 420   tet_infoline(" UtcDaliToolkitTextFieldSetPropertyP");
 421   TextField field = TextField::New();
 422   DALI_TEST_CHECK( field );
 423   Stage::GetCurrent().Add( field );
 424
 425   // Note - we can't check the defaults since the stylesheets are platform-specific
 426
 427   // Check the render backend property.
 428   field.SetProperty( TextField::Property::RENDERING_BACKEND, Text::RENDERING_SHARED_ATLAS );
 429   DALI_TEST_EQUALS( (Text::RenderingType)field.GetProperty<int>( TextField::Property::RENDERING_BACKEND ), Text::RENDERING_SHARED_ATLAS, TEST_LOCATION );
 430
 431   // Check text property.
 432   field.SetProperty( TextField::Property::TEXT, "Setting Text" );
 433   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("Setting Text"), TEST_LOCATION );
 434
 435   // Check placeholder text properties.
 436   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "Setting Placeholder Text" );
 437   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::PLACEHOLDER_TEXT ), std::string("Setting Placeholder Text"), TEST_LOCATION );
 438
 439   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_FOCUSED, "Setting Placeholder Text Focused" );
 440   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::PLACEHOLDER_TEXT_FOCUSED ), std::string("Setting Placeholder Text Focused"), TEST_LOCATION );
 441
 442   // Check font properties.
 443   field.SetProperty( TextField::Property::FONT_FAMILY, "Setting font family" );
 444   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::FONT_FAMILY ), std::string("Setting font family"), TEST_LOCATION );
 445   field.SetProperty( TextField::Property::FONT_STYLE, "Setting font style" );
 446   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::FONT_STYLE ), std::string("Setting font style"), TEST_LOCATION );
 447   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
 448   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::POINT_SIZE ), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 449
 450   // Check that the MAX_LENGTH property can be correctly set
 451   const int maxNumberOfCharacters = 20;
 452   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
 453   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::MAX_LENGTH ), maxNumberOfCharacters, TEST_LOCATION );
 454
 455   // Check exceed policy
 456   // Set a different exceed policy is not implemented.
 457
 458   // Check that the Alignment properties can be correctly set
 459   field.SetProperty( TextField::Property::HORIZONTAL_ALIGNMENT, "END" );
 460   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::HORIZONTAL_ALIGNMENT ), "END", TEST_LOCATION );
 461   field.SetProperty( TextField::Property::VERTICAL_ALIGNMENT, "CENTER" );
 462   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::VERTICAL_ALIGNMENT ), "CENTER", TEST_LOCATION );
 463
 464   // Check text's color property
 465   field.SetProperty( TextField::Property::TEXT_COLOR, Color::WHITE );
 466   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::TEXT_COLOR ), Color::WHITE, TEST_LOCATION );
 467
 468   // Check placeholder text's color property.
 469   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_COLOR, Color::RED );
 470   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::PLACEHOLDER_TEXT_COLOR ), Color::RED, TEST_LOCATION );
 471
 472   // Check shadow properties.
 473   field.SetProperty( TextField::Property::SHADOW_OFFSET, Vector2( 1.f, 1.f ) );
 474   DALI_TEST_EQUALS( field.GetProperty<Vector2>( TextField::Property::SHADOW_OFFSET ), Vector2( 1.f, 1.f ), TEST_LOCATION );
 475   field.SetProperty( TextField::Property::SHADOW_COLOR, Color::GREEN );
 476   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::SHADOW_COLOR ), Color::GREEN, TEST_LOCATION );
 477
 478   // Check cursor properties
 479   field.SetProperty( TextField::Property::PRIMARY_CURSOR_COLOR, Color::RED );
 480   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::PRIMARY_CURSOR_COLOR ), Color::RED, TEST_LOCATION );
 481   field.SetProperty( TextField::Property::SECONDARY_CURSOR_COLOR, Color::BLUE );
 482   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::SECONDARY_CURSOR_COLOR ), Color::BLUE, TEST_LOCATION );
 483
 484   field.SetProperty( TextField::Property::ENABLE_CURSOR_BLINK, false );
 485   DALI_TEST_EQUALS( field.GetProperty<bool>( TextField::Property::ENABLE_CURSOR_BLINK ), false, TEST_LOCATION );
 486   field.SetProperty( TextField::Property::CURSOR_BLINK_INTERVAL, 1.f );
 487   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::CURSOR_BLINK_INTERVAL ), 1.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 488   field.SetProperty( TextField::Property::CURSOR_BLINK_DURATION, 10.f );
 489   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::CURSOR_BLINK_DURATION ), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 490   field.SetProperty( TextField::Property::CURSOR_WIDTH, 1 );
 491   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::CURSOR_WIDTH ), 1, TEST_LOCATION );
 492
 493   // Check scroll properties.
 494   field.SetProperty( TextField::Property::SCROLL_THRESHOLD, 1.f );
 495   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::SCROLL_THRESHOLD ), 1.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 496   field.SetProperty( TextField::Property::SCROLL_SPEED, 100.f );
 497   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::SCROLL_SPEED ), 100.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 498
 499   // Check handle images
 500   field.SetProperty( TextField::Property::GRAB_HANDLE_IMAGE, "image1" );
 501   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::GRAB_HANDLE_IMAGE ), "image1", TEST_LOCATION );
 502   field.SetProperty( TextField::Property::GRAB_HANDLE_PRESSED_IMAGE, "image2" );
 503   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::GRAB_HANDLE_PRESSED_IMAGE ), "image2", TEST_LOCATION );
 504   field.SetProperty( TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, "image3" );
 505
 506   // Check handle images
 507   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, "filename", "leftHandleImage" )  );
 508   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT, "filename", "rightHandleImage" )  );
 509   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT, "filename", "leftHandleImagePressed" )  );
 510   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, "filename", "rightHandleImagePressed" )  );
 511   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, "filename", "leftHandleMarkerImage" )  );
 512   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, "filename", "rightHandleMarkerImage" )  );
 513
 514   // Check the highlight color
 515   field.SetProperty( TextField::Property::SELECTION_HIGHLIGHT_COLOR, Color::GREEN );
 516   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::SELECTION_HIGHLIGHT_COLOR ), Color::GREEN, TEST_LOCATION );
 517
 518   // Decoration bounding box
 519   field.SetProperty( TextField::Property::DECORATION_BOUNDING_BOX, Rect<int>( 0, 0, 1, 1 ) );
 520   DALI_TEST_EQUALS( field.GetProperty<Rect <int > >( TextField::Property::DECORATION_BOUNDING_BOX ), Rect<int>( 0, 0, 1, 1 ), TEST_LOCATION );
 521
 522   // Check input color property.
 523   field.SetProperty( TextField::Property::INPUT_COLOR, Color::YELLOW );
 524   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::INPUT_COLOR ), Color::YELLOW, TEST_LOCATION );
 525
 526   // Check the enable markup property.
 527   DALI_TEST_CHECK( !field.GetProperty<bool>( TextField::Property::ENABLE_MARKUP ) );
 528   field.SetProperty( TextField::Property::ENABLE_MARKUP, true );
 529   DALI_TEST_CHECK( field.GetProperty<bool>( TextField::Property::ENABLE_MARKUP ) );
 530
 531   // Check input font properties.
 532   field.SetProperty( TextField::Property::INPUT_FONT_FAMILY, "Setting input font family" );
 533   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_FONT_FAMILY ), "Setting input font family", TEST_LOCATION );
 534   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, "Setting input font style" );
 535   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_FONT_STYLE ), "Setting input font style", TEST_LOCATION );
 536   field.SetProperty( TextField::Property::INPUT_POINT_SIZE, 12.f );
 537   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::INPUT_POINT_SIZE ), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
 538
 539   // Check the underline property
 540   field.SetProperty( TextField::Property::UNDERLINE, "Underline properties" );
 541   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::UNDERLINE ), std::string("Underline properties"), TEST_LOCATION );
 542
 543   // Check the input underline property
 544   field.SetProperty( TextField::Property::INPUT_UNDERLINE, "Underline input properties" );
 545   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_UNDERLINE ), std::string("Underline input properties"), TEST_LOCATION );
 546
 547   // Check the shadow property
 548   field.SetProperty( TextField::Property::SHADOW, "Shadow properties" );
 549   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::SHADOW ), std::string("Shadow properties"), TEST_LOCATION );
 550
 551   // Check the input shadow property
 552   field.SetProperty( TextField::Property::INPUT_SHADOW, "Shadow input properties" );
 553   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_SHADOW ), std::string("Shadow input properties"), TEST_LOCATION );
 554
 555   // Check the emboss property
 556   field.SetProperty( TextField::Property::EMBOSS, "Emboss properties" );
 557   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::EMBOSS ), std::string("Emboss properties"), TEST_LOCATION );
 558
 559   // Check the input emboss property
 560   field.SetProperty( TextField::Property::INPUT_EMBOSS, "Emboss input properties" );
 561   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_EMBOSS ), std::string("Emboss input properties"), TEST_LOCATION );
 562
 563   // Check the outline property
 564   field.SetProperty( TextField::Property::OUTLINE, "Outline properties" );
 565   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::OUTLINE ), std::string("Outline properties"), TEST_LOCATION );
 566
 567   // Check the input outline property
 568   field.SetProperty( TextField::Property::INPUT_OUTLINE, "Outline input properties" );
 569   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_OUTLINE ), std::string("Outline input properties"), TEST_LOCATION );
 570
 571   END_TEST;
 572 }
 573
 574 // Positive Atlas Text Renderer test
 575 int utcDaliTextFieldAtlasRenderP(void)
 576 {
 577   ToolkitTestApplication application;
 578   tet_infoline(" UtcDaliToolkitTextFieldAtlasRenderP");
 579   StyleManager styleManager = StyleManager::Get();
 580   styleManager.ApplyDefaultTheme();
 581   TextField field = TextField::New();
 582   DALI_TEST_CHECK( field );
 583
 584   field.SetProperty( TextField::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
 585
 586   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
 587
 588   Stage::GetCurrent().Add( field );
 589
 590   try
 591   {
 592     // Render some text with the shared atlas backend
 593     field.SetProperty( TextField::Property::RENDERING_BACKEND, Text::RENDERING_SHARED_ATLAS );
 594     application.SendNotification();
 595     application.Render();
 596   }
 597   catch( ... )
 598   {
 599     tet_result(TET_FAIL);
 600   }
 601   END_TEST;
 602 }
 603
 604 // Positive test for the textChanged signal.
 605 int utcDaliTextFieldTextChangedP(void)
 606 {
 607   ToolkitTestApplication application;
 608   tet_infoline(" utcDaliTextFieldTextChangedP");
 609   TextField field = TextField::New();
 610   DALI_TEST_CHECK( field );
 611
 612   Stage::GetCurrent().Add( field );
 613
 614   field.TextChangedSignal().Connect(&TestTextChangedCallback);
 615
 616   gTextChangedCallBackCalled = false;
 617   field.SetProperty( TextField::Property::TEXT, "ABC" );
 618   DALI_TEST_CHECK( gTextChangedCallBackCalled );
 619
 620   application.SendNotification();
 621
 622   field.SetKeyInputFocus();
 623
 624   gTextChangedCallBackCalled = false;
 625   application.ProcessEvent( GenerateKey( "D", "D", 0, 0, 0, Integration::KeyEvent::Down ) );
 626   DALI_TEST_CHECK( gTextChangedCallBackCalled );
 627
 628   END_TEST;
 629 }
 630
 631 // Negative test for the textChanged signal.
 632 int utcDaliTextFieldTextChangedN(void)
 633 {
 634   ToolkitTestApplication application;
 635   tet_infoline(" utcDaliTextFieldTextChangedN");
 636   TextField field = TextField::New();
 637   DALI_TEST_CHECK( field );
 638
 639   Stage::GetCurrent().Add( field );
 640
 641   field.TextChangedSignal().Connect(&TestTextChangedCallback);
 642
 643   gTextChangedCallBackCalled = false;
 644   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "ABC" ); // Setting placeholder, not TEXT
 645   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
 646
 647   END_TEST;
 648 }
 649
 650 // Positive test for Max Characters reached signal.
 651 int utcDaliTextFieldMaxCharactersReachedP(void)
 652 {
 653   ToolkitTestApplication application;
 654   tet_infoline(" utcDaliTextFieldMaxCharactersReachedP");
 655   TextField field = TextField::New();
 656   DALI_TEST_CHECK( field );
 657
 658   Stage::GetCurrent().Add( field );
 659
 660   const int maxNumberOfCharacters = 1;
 661   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
 662
 663   field.SetKeyInputFocus();
 664
 665   gMaxCharactersCallBackCalled = false;
 666   field.MaxLengthReachedSignal().Connect(&TestMaxLengthReachedCallback);
 667
 668   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 669   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 670
 671   DALI_TEST_CHECK( gMaxCharactersCallBackCalled );
 672
 673   END_TEST;
 674 }
 675
 676 // Negative test for Max Characters reached signal.
 677 int utcDaliTextFieldMaxCharactersReachedN(void)
 678 {
 679   ToolkitTestApplication application;
 680   tet_infoline(" utcDaliTextFieldMaxCharactersReachedN");
 681   TextField field = TextField::New();
 682   DALI_TEST_CHECK( field );
 683
 684   Stage::GetCurrent().Add( field );
 685
 686   const int maxNumberOfCharacters = 3;
 687   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
 688
 689   field.SetKeyInputFocus();
 690
 691   gMaxCharactersCallBackCalled = false;
 692   field.MaxLengthReachedSignal().Connect(&TestMaxLengthReachedCallback);
 693
 694   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 695   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 696
 697   DALI_TEST_CHECK( !gMaxCharactersCallBackCalled );
 698
 699   END_TEST;
 700 }
 701
 702 int utcDaliTextFieldEvent01(void)
 703 {
 704   ToolkitTestApplication application;
 705   tet_infoline(" utcDaliTextFieldEvent01");
 706
 707   // Creates a tap event. After creating a tap event the text field should
 708   // have the focus and add text with key events should be possible.
 709
 710   TextField field = TextField::New();
 711   DALI_TEST_CHECK( field );
 712
 713   Stage::GetCurrent().Add( field );
 714
 715   field.SetSize( 300.f, 50.f );
 716   field.SetParentOrigin( ParentOrigin::TOP_LEFT );
 717   field.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 718
 719   // Avoid a crash when core load gl resources.
 720   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
 721
 722   // Render and notify
 723   application.SendNotification();
 724   application.Render();
 725
 726   // Add a key event but as the text field has not the focus it should do nothing.
 727   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 728
 729   // Render and notify
 730   application.SendNotification();
 731   application.Render();
 732
 733   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string(""), TEST_LOCATION );
 734
 735   // Create a tap event to touch the text field.
 736   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
 737   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
 738
 739   // Render and notify
 740   application.SendNotification();
 741   application.Render();
 742
 743   // Now the text field has the focus, so it can handle the key events.
 744   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 745   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 746
 747   // Render and notify
 748   application.SendNotification();
 749   application.Render();
 750
 751   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("aa"), TEST_LOCATION );
 752
 753   // Create a second text field and send key events to it.
 754   TextField field2 = TextField::New();
 755
 756   field2.SetParentOrigin( ParentOrigin::TOP_LEFT );
 757   field2.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 758   field2.SetSize( 100.f, 100.f );
 759   field2.SetPosition( 100.f, 100.f );
 760
 761   Stage::GetCurrent().Add( field2 );
 762
 763   // Render and notify
 764   application.SendNotification();
 765   application.Render();
 766
 767   // Create a tap event on the second text field.
 768   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 150.0f, 125.0f ) ) );
 769   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 150.0f, 125.0f ) ) );
 770
 771   // Render and notify
 772   application.SendNotification();
 773   application.Render();
 774
 775   // The second text field has the focus. It should handle the key events.
 776   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 777   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 778
 779   // Render and notify
 780   application.SendNotification();
 781   application.Render();
 782
 783   // Check the text has been added to the second text field.
 784   DALI_TEST_EQUALS( field2.GetProperty<std::string>( TextField::Property::TEXT ), std::string("aa"), TEST_LOCATION );
 785
 786   END_TEST;
 787 }
 788
 789 int utcDaliTextFieldEvent02(void)
 790 {
 791   ToolkitTestApplication application;
 792   tet_infoline(" utcDaliTextFieldEvent02");
 793
 794   // Checks if the right number of actors are created.
 795
 796   TextField field = TextField::New();
 797   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
 798   DALI_TEST_CHECK( field );
 799   LoadMarkerImages(application, field);
 800
 801   Stage::GetCurrent().Add( field );
 802
 803   field.SetSize( 300.f, 50.f );
 804   field.SetParentOrigin( ParentOrigin::TOP_LEFT );
 805   field.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 806
 807   // Avoid a crash when core load gl resources.
 808   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
 809
 810   // Render and notify
 811   application.SendNotification();
 812   application.Render();
 813
 814   // Check there are the expected number of children ( offscreen root actor, and the offscreen image view
 815   DALI_TEST_EQUALS( field.GetChildCount(), 2u, TEST_LOCATION );
 816
 817   Actor offscreenRoot = field.GetChildAt( 0u );
 818   DALI_TEST_CHECK( offscreenRoot.IsLayer() );
 819   DALI_TEST_EQUALS( offscreenRoot.GetChildCount(), 1u, TEST_LOCATION ); // The camera actor.
 820
 821   Actor offscreenImage = field.GetChildAt( 1u );
 822   DALI_TEST_CHECK( offscreenImage );
 823
 824   // Create a tap event to touch the text field.
 825   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
 826   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
 827
 828   // Render and notify
 829   application.SendNotification();
 830   application.Render();
 831
 832   Actor layer = field.GetChildAt( 2u );
 833   DALI_TEST_CHECK( layer.IsLayer() );
 834
 835   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
 836   DALI_TEST_EQUALS( offscreenRoot.GetChildCount(), 1u, TEST_LOCATION ); // The camera actor.
 837
 838   // Now the text field has the focus, so it can handle the key events.
 839   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 840   application.ProcessEvent( GenerateKey( "a", "a", 0, 0, 0, Integration::KeyEvent::Down ) );
 841
 842   // Render and notify
 843   application.SendNotification();
 844   application.Render();
 845
 846   // Checks the cursor and the renderer have been created.
 847   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
 848   DALI_TEST_EQUALS( offscreenRoot.GetChildCount(), 2u, TEST_LOCATION ); // The camera actor and the renderer
 849
 850   Control cursor = Control::DownCast( layer.GetChildAt( 0u ) );
 851   DALI_TEST_CHECK( cursor );
 852
 853   CameraActor camera = CameraActor::DownCast( offscreenRoot.GetChildAt( 0u ) );
 854   DALI_TEST_CHECK( camera );
 855
 856   Renderer renderer = offscreenRoot.GetChildAt( 1u ).GetRendererAt( 0u );
 857   DALI_TEST_CHECK( renderer );
 858
 859   // Move the cursor and check the position changes.
 860   Vector3 position1 = cursor.GetCurrentPosition();
 861
 862   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down ) );
 863   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::Down ) );
 864
 865   // Render and notify
 866   application.SendNotification();
 867   application.Render();
 868
 869   Vector3 position2 = cursor.GetCurrentPosition();
 870
 871   DALI_TEST_CHECK( position2.x < position1.x );
 872
 873   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down ) );
 874   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::Down ) );
 875
 876   // Render and notify
 877   application.SendNotification();
 878   application.Render();
 879
 880   Vector3 position3 = cursor.GetCurrentPosition();
 881
 882   DALI_TEST_EQUALS( position1, position3, TEST_LOCATION ); // Should be in the same position1.
 883
 884   // Send some taps and check the cursor positions.
 885
 886   // Try to tap at the beginning.
 887   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
 888   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
 889
 890   // Render and notify
 891   application.SendNotification();
 892   application.Render();
 893
 894   // Cursor position should be the same than position1.
 895   Vector3 position4 = cursor.GetCurrentPosition();
 896
 897   DALI_TEST_EQUALS( position2, position4, TEST_LOCATION ); // Should be in the same position2.
 898
 899   // Tap away from the start position.
 900   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 16.f, 25.0f ) ) );
 901   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 16.0f, 25.0f ) ) );
 902
 903   // Render and notify
 904   application.SendNotification();
 905   application.Render();
 906
 907   Vector3 position5 = cursor.GetCurrentPosition();
 908
 909   DALI_TEST_CHECK( position5.x > position4.x );
 910
 911   // Remove all the text.
 912   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down ) );
 913   application.ProcessEvent( GenerateKey( "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::Down ) );
 914   field.SetProperty( TextField::Property::TEXT, "" );
 915
 916   // Render and notify
 917   application.SendNotification();
 918   application.Render();
 919
 920   // Cursor position should be the same than position2.
 921   Vector3 position6 = cursor.GetCurrentPosition();
 922
 923   DALI_TEST_EQUALS( position2, position6, TEST_LOCATION );// Should be in the same position2.
 924
 925   // Should not be a renderer.
 926   DALI_TEST_EQUALS( offscreenRoot.GetChildCount(), 1u, TEST_LOCATION ); // The camera actor only.
 927
 928   END_TEST;
 929 }
 930
 931 int utcDaliTextFieldEvent03(void)
 932 {
 933   ToolkitTestApplication application;
 934   tet_infoline(" utcDaliTextFieldEvent03");
 935
 936   // Checks if the highlight actor is created.
 937
 938   TextField field = TextField::New();
 939   DALI_TEST_CHECK( field );
 940
 941   Stage::GetCurrent().Add( field );
 942
 943   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
 944   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
 945   field.SetSize( 30.f, 50.f );
 946   field.SetParentOrigin( ParentOrigin::TOP_LEFT );
 947   field.SetAnchorPoint( AnchorPoint::TOP_LEFT );
 948
 949   // Avoid a crash when core load gl resources.
 950   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
 951   LoadMarkerImages(application, field);
 952
 953   // Render and notify
 954   application.SendNotification();
 955   application.Render();
 956
 957   // Tap first to get the focus.
 958   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 3.f, 25.0f ) ) );
 959   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 3.f, 25.0f ) ) );
 960
 961   // Render and notify
 962   application.SendNotification();
 963   application.Render();
 964
 965   // Double tap to select a word.
 966   application.ProcessEvent( GenerateTap( Gesture::Possible, 2u, 1u, Vector2( 3.f, 25.0f ) ) );
 967   application.ProcessEvent( GenerateTap( Gesture::Started, 2u, 1u, Vector2( 3.f, 25.0f ) ) );
 968
 969   // Render and notify
 970   application.SendNotification();
 971   application.Render();
 972
 973   // The offscreen root actor should have three actors: the camera, a renderer and the highlight actor.
 974   Actor offscreenRoot = field.GetChildAt( 1u );
 975   DALI_TEST_CHECK( offscreenRoot.IsLayer() );
 976
 977   CameraActor camera = CameraActor::DownCast( offscreenRoot.GetChildAt( 0u ) );
 978   DALI_TEST_CHECK( camera );
 979
 980   Renderer renderer = offscreenRoot.GetChildAt( 1u ).GetRendererAt( 0u );
 981   DALI_TEST_CHECK( renderer );
 982
 983   Renderer highlight = offscreenRoot.GetChildAt( 2u ).GetRendererAt( 0u );
 984   DALI_TEST_CHECK( highlight );
 985
 986   END_TEST;
 987 }
 988
 989 int utcDaliTextFieldEvent04(void)
 990 {
 991   ToolkitTestApplication application;
 992   tet_infoline(" utcDaliTextFieldEvent04");
 993
 994   // Checks if the highlight actor is created.
 995
 996   TextField field = TextField::New();
 997   DALI_TEST_CHECK( field );
 998   Stage::GetCurrent().Add( field );
 999   LoadMarkerImages(application, field);
1000   // Render and notify
1001   application.SendNotification();
1002   application.Render();
1003
1004   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
1005   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
1006   field.SetSize( 300.f, 50.f );
1007   field.SetParentOrigin( ParentOrigin::TOP_LEFT );
1008   field.SetAnchorPoint( AnchorPoint::TOP_LEFT );
1009
1010   // Avoid a crash when core load gl resources.
1011   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1012   // Render and notify
1013   application.SendNotification();
1014   application.Render();
1015
1016   // Create a tap event to touch the text field.
1017   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
1018   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
1019   // Render and notify
1020   application.SendNotification();
1021   application.Render();
1022
1023
1024   // Tap first to get the focus.
1025   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
1026   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
1027
1028   // Render and notify
1029   application.SendNotification();
1030   application.Render();
1031
1032   // Double tap to select a word.
1033   application.ProcessEvent( GenerateTap( Gesture::Possible, 2u, 1u, Vector2( 1.f, 25.0f ) ) );
1034   application.ProcessEvent( GenerateTap( Gesture::Started, 2u, 1u, Vector2( 1.f, 25.0f ) ) );
1035
1036   // Render and notify
1037   application.SendNotification();
1038   application.Render();
1039
1040   // Tap grab handle
1041   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 0.f, 40.0f ) ) );
1042   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 0.f, 40.0f ) ) );
1043   END_TEST;
1044 }
1045
1046 int utcDaliTextFieldEvent05(void)
1047 {
1048   ToolkitTestApplication application;
1049   tet_infoline(" utcDaliTextFieldEvent05");
1050
1051   // Checks if the highlight actor is created.
1052
1053   TextField field = TextField::New();
1054   DALI_TEST_CHECK( field );
1055   Stage::GetCurrent().Add( field );
1056   LoadMarkerImages(application, field);
1057   // Render and notify
1058   application.SendNotification();
1059   application.Render();
1060
1061   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
1062   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
1063   field.SetSize( 300.f, 50.f );
1064   field.SetParentOrigin( ParentOrigin::TOP_LEFT );
1065   field.SetAnchorPoint( AnchorPoint::TOP_LEFT );
1066
1067   // Avoid a crash when core load gl resources.
1068   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1069   // Render and notify
1070   application.SendNotification();
1071   application.Render();
1072
1073   // Create a tap event to touch the text field.
1074   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
1075   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 150.0f, 25.0f ) ) );
1076   // Render and notify
1077   application.SendNotification();
1078   application.Render();
1079
1080
1081   // Tap first to get the focus.
1082   application.ProcessEvent( GenerateTap( Gesture::Possible, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
1083   application.ProcessEvent( GenerateTap( Gesture::Started, 1u, 1u, Vector2( 1.f, 25.0f ) ) );
1084
1085   // Render and notify
1086   application.SendNotification();
1087   application.Render();
1088
1089   // Double tap to select a word.
1090   application.ProcessEvent( GenerateTap( Gesture::Possible, 2u, 1u, Vector2( 1.f, 25.0f ) ) );
1091   application.ProcessEvent( GenerateTap( Gesture::Started, 2u, 1u, Vector2( 1.f, 25.0f ) ) );
1092
1093   // Render and notify
1094   application.SendNotification();
1095   application.Render();
1096
1097   // drag grab handle right
1098   Vector2 pos(0.0f, 40.0f);
1099   SendPan(application, Gesture::Possible, pos);
1100   SendPan(application, Gesture::Started, pos);
1101   pos.x += 5.0f;
1102   Wait(application, 100);
1103
1104   for(int i = 0;i<20;i++)
1105   {
1106     SendPan(application, Gesture::Continuing, pos);
1107     pos.x += 5.0f;
1108     Wait(application);
1109   }
1110
1111   SendPan(application, Gesture::Finished, pos);
1112   Wait(application, RENDER_FRAME_INTERVAL);
1113
1114   Actor offscreenRoot = field.GetChildAt( 1u );
1115   END_TEST;
1116 }