Fix underline issue when PreeditStyle is REVERSE, HIGHLIGHT
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-TextField.cpp
1 /*
2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #include <iostream>
19 #include <stdlib.h>
20 #include <unistd.h>
21
22 #include <dali/public-api/rendering/renderer.h>
23 #include <dali/integration-api/events/key-event-integ.h>
24 #include <dali/integration-api/events/touch-event-integ.h>
25
26 #include <dali/devel-api/adaptor-framework/key-devel.h>
27 #include <dali/devel-api/text-abstraction/font-client.h>
28 #include <dali-toolkit-test-suite-utils.h>
29 #include <dali-toolkit/dali-toolkit.h>
30 #include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
31 #include <dali-toolkit/devel-api/text/rendering-backend.h>
32 #include "toolkit-clipboard.h"
33
34 using namespace Dali;
35 using namespace Toolkit;
36
37 void dali_textfield_startup(void)
38 {
39   test_return_value = TET_UNDEF;
40 }
41
42 void dali_textfield_cleanup(void)
43 {
44   test_return_value = TET_PASS;
45 }
46
47 namespace
48 {
49
50 const char* const PROPERTY_NAME_RENDERING_BACKEND                    = "renderingBackend";
51 const char* const PROPERTY_NAME_TEXT                                 = "text";
52 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT                     = "placeholderText";
53 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED             = "placeholderTextFocused";
54 const char* const PROPERTY_NAME_FONT_FAMILY                          = "fontFamily";
55 const char* const PROPERTY_NAME_FONT_STYLE                           = "fontStyle";
56 const char* const PROPERTY_NAME_POINT_SIZE                           = "pointSize";
57 const char* const PROPERTY_NAME_MAX_LENGTH                           = "maxLength";
58 const char* const PROPERTY_NAME_EXCEED_POLICY                        = "exceedPolicy";
59 const char* const PROPERTY_NAME_HORIZONTAL_ALIGNMENT                 = "horizontalAlignment";
60 const char* const PROPERTY_NAME_VERTICAL_ALIGNMENT                   = "verticalAlignment";
61 const char* const PROPERTY_NAME_TEXT_COLOR                           = "textColor";
62 const char* const PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR               = "placeholderTextColor";
63 const char* const PROPERTY_NAME_PRIMARY_CURSOR_COLOR                 = "primaryCursorColor";
64 const char* const PROPERTY_NAME_SECONDARY_CURSOR_COLOR               = "secondaryCursorColor";
65 const char* const PROPERTY_NAME_ENABLE_CURSOR_BLINK                  = "enableCursorBlink";
66 const char* const PROPERTY_NAME_CURSOR_BLINK_INTERVAL                = "cursorBlinkInterval";
67 const char* const PROPERTY_NAME_CURSOR_BLINK_DURATION                = "cursorBlinkDuration";
68 const char* const PROPERTY_NAME_CURSOR_WIDTH                         = "cursorWidth";
69 const char* const PROPERTY_NAME_GRAB_HANDLE_IMAGE                    = "grabHandleImage";
70 const char* const PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE            = "grabHandlePressedImage";
71 const char* const PROPERTY_NAME_SCROLL_THRESHOLD                     = "scrollThreshold";
72 const char* const PROPERTY_NAME_SCROLL_SPEED                         = "scrollSpeed";
73 const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT          = "selectionHandleImageLeft";
74 const char* const PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT         = "selectionHandleImageRight";
75 const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT  = "selectionHandlePressedImageLeft";
76 const char* const PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT = "selectionHandlePressedImageRight";
77 const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT   = "selectionHandleMarkerImageLeft";
78 const char* const PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT  = "selectionHandleMarkerImageRight";
79 const char* const PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR            = "selectionHighlightColor";
80 const char* const PROPERTY_NAME_DECORATION_BOUNDING_BOX              = "decorationBoundingBox";
81 const char* const PROPERTY_NAME_INPUT_METHOD_SETTINGS                = "inputMethodSettings";
82 const char* const PROPERTY_NAME_INPUT_COLOR                          = "inputColor";
83 const char* const PROPERTY_NAME_ENABLE_MARKUP                        = "enableMarkup";
84 const char* const PROPERTY_NAME_INPUT_FONT_FAMILY                    = "inputFontFamily";
85 const char* const PROPERTY_NAME_INPUT_FONT_STYLE                     = "inputFontStyle";
86 const char* const PROPERTY_NAME_INPUT_POINT_SIZE                     = "inputPointSize";
87
88 const char* const PROPERTY_NAME_UNDERLINE                            = "underline";
89 const char* const PROPERTY_NAME_INPUT_UNDERLINE                      = "inputUnderline";
90 const char* const PROPERTY_NAME_SHADOW                               = "shadow";
91 const char* const PROPERTY_NAME_INPUT_SHADOW                         = "inputShadow";
92 const char* const PROPERTY_NAME_EMBOSS                               = "emboss";
93 const char* const PROPERTY_NAME_INPUT_EMBOSS                         = "inputEmboss";
94 const char* const PROPERTY_NAME_OUTLINE                              = "outline";
95 const char* const PROPERTY_NAME_INPUT_OUTLINE                        = "inputOutline";
96
97 const char* const PROPERTY_NAME_HIDDEN_INPUT_SETTINGS                = "hiddenInputSettings";
98 const char* const PROPERTY_NAME_PIXEL_SIZE                           = "pixelSize";
99 const char* const PROPERTY_NAME_ENABLE_SELECTION                     = "enableSelection";
100 const char* const PROPERTY_NAME_PLACEHOLDER                          = "placeholder";
101 const char* const PROPERTY_NAME_ELLIPSIS                             = "ellipsis";
102 const char* const PROPERTY_NAME_ENABLE_SHIFT_SELECTION               = "enableShiftSelection";
103 const char* const PROPERTY_NAME_ENABLE_GRAB_HANDLE                   = "enableGrabHandle";
104 const char* const PROPERTY_NAME_MATCH_SYSTEM_LANGUAGE_DIRECTION      = "matchSystemLanguageDirection";
105 const char* const PROPERTY_NAME_ENABLE_GRAB_HANDLE_POPUP             = "enableGrabHandlePopup";
106 const char* const PROPERTY_NAME_BACKGROUND                           = "textBackground";
107 const char* const PROPERTY_NAME_FONT_SIZE_SCALE                      = "fontSizeScale";
108 const char* const PROPERTY_NAME_GRAB_HANDLE_COLOR                    = "grabHandleColor";
109
110 const Vector4 PLACEHOLDER_TEXT_COLOR( 0.8f, 0.8f, 0.8f, 0.8f );
111 const Dali::Vector4 LIGHT_BLUE( 0.75f, 0.96f, 1.f, 1.f ); // The text highlight color.
112
113 const float RENDER_FRAME_INTERVAL = 16.66f;
114
115 const unsigned int DEFAULT_FONT_SIZE = 1152u;
116 const std::string DEFAULT_FONT_DIR( "/resources/fonts" );
117
118 const int KEY_RETURN_CODE = 36;
119 const int KEY_A_CODE = 38;
120 const int KEY_D_CODE = 40;
121
122 const std::string DEFAULT_DEVICE_NAME("hwKeyboard");
123
124 static bool gAnchorClickedCallBackCalled;
125 static bool gAnchorClickedCallBackNotCalled;
126 static bool gTextChangedCallBackCalled;
127 static bool gMaxCharactersCallBackCalled;
128 static bool gInputStyleChangedCallbackCalled;
129 static Dali::Toolkit::TextField::InputStyle::Mask gInputStyleMask;
130
131 static void LoadBitmapResource(TestPlatformAbstraction& platform, int width, int height)
132 {
133   Integration::Bitmap* bitmap = Integration::Bitmap::New( Integration::Bitmap::BITMAP_2D_PACKED_PIXELS, ResourcePolicy::OWNED_DISCARD );
134   Integration::ResourcePointer resource(bitmap);
135   bitmap->GetPackedPixelsProfile()->ReserveBuffer(Pixel::RGBA8888, width, height, width, height);
136 }
137
138 static void LoadMarkerImages(ToolkitTestApplication& app, TextField textField)
139 {
140   int width(40);
141   int height(40);
142   LoadBitmapResource( app.GetPlatform(), width, height );
143
144   Property::Map propertyMap;
145   propertyMap["filename"] = "image.png";
146   propertyMap["width"] = width;
147   propertyMap["height"] = height;
148   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, propertyMap );
149   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT, propertyMap );
150   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT, propertyMap );
151   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, propertyMap );
152   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, propertyMap );
153   textField.SetProperty( Toolkit::TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, propertyMap );
154   textField.SetProperty( Toolkit::TextField::Property::GRAB_HANDLE_IMAGE, propertyMap );
155   textField.SetProperty( Toolkit::TextField::Property::GRAB_HANDLE_PRESSED_IMAGE, propertyMap );
156 }
157
158 /*
159  * Simulate time passed by.
160  *
161  * @note this will always process at least 1 frame (1/60 sec)
162  *
163  * @param application Test application instance
164  * @param duration Time to pass in milliseconds.
165  * @return The actual time passed in milliseconds
166  */
167 static int Wait(ToolkitTestApplication& application, int duration = 0)
168 {
169   int time = 0;
170
171   for(int i = 0; i <= ( duration / RENDER_FRAME_INTERVAL); i++)
172   {
173     application.SendNotification();
174     application.Render(RENDER_FRAME_INTERVAL);
175     time += RENDER_FRAME_INTERVAL;
176   }
177
178   return time;
179 }
180
181 Dali::Integration::Point GetPointDownInside( Vector2& pos )
182 {
183   Dali::Integration::Point point;
184   point.SetState( PointState::DOWN );
185   point.SetScreenPosition( pos );
186   return point;
187 }
188
189 Dali::Integration::Point GetPointUpInside( Vector2& pos )
190 {
191   Dali::Integration::Point point;
192   point.SetState( PointState::UP );
193   point.SetScreenPosition( pos );
194   return point;
195 }
196
197 struct CallbackFunctor
198 {
199   CallbackFunctor(bool* callbackFlag)
200   : mCallbackFlag( callbackFlag )
201   {
202   }
203
204   void operator()()
205   {
206     *mCallbackFlag = true;
207   }
208   bool* mCallbackFlag;
209 };
210
211 static void TestAnchorClickedCallback(TextField control, const char* href, unsigned int hrefLength)
212 {
213   tet_infoline(" TestAnchorClickedCallback");
214
215   gAnchorClickedCallBackNotCalled = false;
216
217   if (!strcmp(href, "https://www.tizen.org") && hrefLength == strlen(href))
218   {
219     gAnchorClickedCallBackCalled = true;
220   }
221 }
222
223 static void TestTextChangedCallback( TextField control )
224 {
225   tet_infoline(" TestTextChangedCallback");
226
227   gTextChangedCallBackCalled = true;
228 }
229
230 static void TestMaxLengthReachedCallback( TextField control )
231 {
232   tet_infoline(" TestMaxLengthReachedCallback");
233
234   gMaxCharactersCallBackCalled = true;
235 }
236
237 static void TestInputStyleChangedCallback( TextField control, TextField::InputStyle::Mask mask )
238 {
239   tet_infoline(" TestInputStyleChangedCallback");
240
241   gInputStyleChangedCallbackCalled = true;
242   gInputStyleMask = mask;
243 }
244
245 // Generate a KeyEvent to send to Core.
246 Integration::KeyEvent GenerateKey( const std::string& keyName,
247                                    const std::string& logicalKey,
248                                    const std::string& keyString,
249                                    int keyCode,
250                                    int keyModifier,
251                                    unsigned long timeStamp,
252                                    const Integration::KeyEvent::State& keyState,
253                                    const std::string& compose = "",
254                                    const std::string& deviceName = DEFAULT_DEVICE_NAME,
255                                    const Device::Class::Type& deviceClass = Device::Class::NONE,
256                                    const Device::Subclass::Type& deviceSubclass = Device::Subclass::NONE )
257 {
258   return Integration::KeyEvent( keyName,
259                                 logicalKey,
260                                 keyString,
261                                 keyCode,
262                                 keyModifier,
263                                 timeStamp,
264                                 keyState,
265                                 compose,
266                                 deviceName,
267                                 deviceClass,
268                                 deviceSubclass );
269 }
270
271 bool DaliTestCheckMaps( const Property::Map& fontStyleMapGet, const Property::Map& fontStyleMapSet )
272 {
273   if( fontStyleMapGet.Count() == fontStyleMapSet.Count() )
274   {
275     for( unsigned int index = 0u; index < fontStyleMapGet.Count(); ++index )
276     {
277       const KeyValuePair& valueGet = fontStyleMapGet.GetKeyValue( index );
278
279       Property::Value* valueSet = NULL;
280       if ( valueGet.first.type == Property::Key::INDEX )
281       {
282         valueSet = fontStyleMapSet.Find( valueGet.first.indexKey );
283       }
284       else
285       {
286         // Get Key is a string so searching Set Map for a string key
287         valueSet = fontStyleMapSet.Find( valueGet.first.stringKey );
288       }
289
290       if( NULL != valueSet )
291       {
292         if( valueSet->GetType() == Dali::Property::STRING && ( valueGet.second.Get<std::string>() != valueSet->Get<std::string>() ) )
293         {
294           tet_printf( "Value got : [%s], expected : [%s]", valueGet.second.Get<std::string>().c_str(), valueSet->Get<std::string>().c_str() );
295           return false;
296         }
297         else if( valueSet->GetType() == Dali::Property::BOOLEAN && ( valueGet.second.Get<bool>() != valueSet->Get<bool>() ) )
298         {
299           tet_printf( "Value got : [%d], expected : [%d]", valueGet.second.Get<bool>(), valueSet->Get<bool>() );
300           return false;
301         }
302         else if( valueSet->GetType() == Dali::Property::INTEGER && ( valueGet.second.Get<int>() != valueSet->Get<int>() ) )
303         {
304           tet_printf( "Value got : [%d], expected : [%d]", valueGet.second.Get<int>(), valueSet->Get<int>() );
305           return false;
306         }
307         else if( valueSet->GetType() == Dali::Property::FLOAT && ( valueGet.second.Get<float>() != valueSet->Get<float>() ) )
308         {
309           tet_printf( "Value got : [%f], expected : [%f]", valueGet.second.Get<float>(), valueSet->Get<float>() );
310           return false;
311         }
312         else if( valueSet->GetType() == Dali::Property::VECTOR2 && ( valueGet.second.Get<Vector2>() != valueSet->Get<Vector2>() ) )
313         {
314           Vector2 vector2Get = valueGet.second.Get<Vector2>();
315           Vector2 vector2Set = valueSet->Get<Vector2>();
316           tet_printf( "Value got : [%f, %f], expected : [%f, %f]", vector2Get.x, vector2Get.y, vector2Set.x, vector2Set.y );
317           return false;
318         }
319         else if( valueSet->GetType() == Dali::Property::VECTOR4 && ( valueGet.second.Get<Vector4>() != valueSet->Get<Vector4>() ) )
320         {
321           Vector4 vector4Get = valueGet.second.Get<Vector4>();
322           Vector4 vector4Set = valueSet->Get<Vector4>();
323           tet_printf( "Value got : [%f, %f, %f, %f], expected : [%f, %f, %f, %f]", vector4Get.r, vector4Get.g, vector4Get.b, vector4Get.a, vector4Set.r, vector4Set.g, vector4Set.b, vector4Set.a );
324           return false;
325         }
326       }
327       else
328       {
329         if ( valueGet.first.type == Property::Key::INDEX )
330         {
331           tet_printf( "  The key %d doesn't exist.", valueGet.first.indexKey );
332         }
333         else
334         {
335           tet_printf( "  The key %s doesn't exist.", valueGet.first.stringKey.c_str() );
336         }
337         return false;
338       }
339     }
340   }
341
342   return true;
343 }
344
345 } // namespace
346
347 int UtcDaliToolkitTextFieldConstructorP(void)
348 {
349   ToolkitTestApplication application;
350   tet_infoline(" UtcDaliToolkitTextFieldConstructorP");
351   TextField textField;
352   DALI_TEST_CHECK( !textField );
353   END_TEST;
354 }
355
356 int UtcDaliToolkitTextFieldNewP(void)
357 {
358   ToolkitTestApplication application;
359   tet_infoline(" UtcDaliToolkitTextFieldNewP");
360   TextField textField = TextField::New();
361   DALI_TEST_CHECK( textField );
362   END_TEST;
363 }
364
365 int UtcDaliToolkitTextFieldDownCastP(void)
366 {
367   ToolkitTestApplication application;
368   tet_infoline(" UtcDaliToolkitTextFieldDownCastP");
369   TextField textField1 = TextField::New();
370   BaseHandle object( textField1 );
371
372   TextField textField2 = TextField::DownCast( object );
373   DALI_TEST_CHECK( textField2 );
374
375   TextField textField3 = DownCast< TextField >( object );
376   DALI_TEST_CHECK( textField3 );
377   END_TEST;
378 }
379
380 int UtcDaliToolkitTextFieldDownCastN(void)
381 {
382   ToolkitTestApplication application;
383   tet_infoline(" UtcDaliToolkitTextFieldDownCastN");
384   BaseHandle uninitializedObject;
385   TextField textField1 = TextField::DownCast( uninitializedObject );
386   DALI_TEST_CHECK( !textField1 );
387
388   TextField textField2 = DownCast< TextField >( uninitializedObject );
389   DALI_TEST_CHECK( !textField2 );
390   END_TEST;
391 }
392
393 int UtcDaliToolkitTextFieldCopyConstructorP(void)
394 {
395   ToolkitTestApplication application;
396   tet_infoline(" UtcDaliToolkitTextFieldCopyConstructorP");
397   TextField textField = TextField::New();
398   textField.SetProperty( TextField::Property::TEXT, "Test" );
399
400   TextField copy( textField );
401   DALI_TEST_CHECK( copy );
402   DALI_TEST_CHECK( copy.GetProperty<std::string>( TextLabel::Property::TEXT ) == textField.GetProperty<std::string>( TextLabel::Property::TEXT ) );
403   END_TEST;
404 }
405
406 int UtcDaliTextFieldMoveConstructor(void)
407 {
408   ToolkitTestApplication application;
409
410   TextField textField = TextField::New();
411   textField.SetProperty( TextEditor::Property::TEXT, "Test" );
412   DALI_TEST_CHECK( textField.GetProperty<std::string>( TextField::Property::TEXT ) == "Test" );
413
414   TextField moved = std::move( textField );
415   DALI_TEST_CHECK( moved );
416   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
417   DALI_TEST_CHECK( moved.GetProperty<std::string>( TextField::Property::TEXT ) == "Test" );
418   DALI_TEST_CHECK( !textField );
419
420   END_TEST;
421 }
422
423 int UtcDaliToolkitTextFieldAssignmentOperatorP(void)
424 {
425   ToolkitTestApplication application;
426   tet_infoline(" UtcDaliToolkitTextFieldAssignmentOperatorP");
427   TextField textField = TextField::New();
428   textField.SetProperty( TextField::Property::TEXT, "Test" );
429
430   TextField copy = textField;
431   DALI_TEST_CHECK( copy );
432   DALI_TEST_CHECK( copy.GetProperty<std::string>( TextField::Property::TEXT ) == textField.GetProperty<std::string>( TextField::Property::TEXT ) );
433   END_TEST;
434 }
435
436 int UtcDaliTextFieldMoveAssignment(void)
437 {
438   ToolkitTestApplication application;
439
440   TextField textField = TextField::New();
441   textField.SetProperty( TextEditor::Property::TEXT, "Test" );
442   DALI_TEST_CHECK( textField.GetProperty<std::string>( TextField::Property::TEXT ) == "Test" );
443
444   TextField moved;
445   moved = std::move( textField );
446   DALI_TEST_CHECK( moved );
447   DALI_TEST_EQUALS( 1, moved.GetBaseObject().ReferenceCount(), TEST_LOCATION );
448   DALI_TEST_CHECK( moved.GetProperty<std::string>( TextField::Property::TEXT ) == "Test" );
449   DALI_TEST_CHECK( !textField );
450
451   END_TEST;
452 }
453
454 int UtcDaliTextFieldNewP(void)
455 {
456   ToolkitTestApplication application;
457   tet_infoline(" UtcDaliToolkitTextFieldNewP");
458   TextField textField = TextField::New();
459   DALI_TEST_CHECK( textField );
460   END_TEST;
461 }
462
463 // Positive test case for a method
464 int UtcDaliTextFieldGetPropertyP(void)
465 {
466   ToolkitTestApplication application;
467   tet_infoline(" UtcDaliToolkitTextFieldGetPropertyP");
468   TextField field = TextField::New();
469   DALI_TEST_CHECK( field );
470
471   // Check Property Indices are correct
472   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_RENDERING_BACKEND ) == DevelTextField::Property::RENDERING_BACKEND );
473   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_TEXT ) == TextField::Property::TEXT );
474   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT ) == TextField::Property::PLACEHOLDER_TEXT );
475   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT_FOCUSED ) == TextField::Property::PLACEHOLDER_TEXT_FOCUSED );
476   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_FONT_FAMILY ) == TextField::Property::FONT_FAMILY );
477   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_FONT_STYLE ) == TextField::Property::FONT_STYLE );
478   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_POINT_SIZE ) == TextField::Property::POINT_SIZE );
479   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_MAX_LENGTH ) == TextField::Property::MAX_LENGTH );
480   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_EXCEED_POLICY ) == TextField::Property::EXCEED_POLICY );
481   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_HORIZONTAL_ALIGNMENT ) == TextField::Property::HORIZONTAL_ALIGNMENT );
482   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_VERTICAL_ALIGNMENT ) == TextField::Property::VERTICAL_ALIGNMENT );
483   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_TEXT_COLOR ) == TextField::Property::TEXT_COLOR );
484   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER_TEXT_COLOR ) == TextField::Property::PLACEHOLDER_TEXT_COLOR );
485   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PRIMARY_CURSOR_COLOR ) == TextField::Property::PRIMARY_CURSOR_COLOR );
486   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SECONDARY_CURSOR_COLOR ) == TextField::Property::SECONDARY_CURSOR_COLOR );
487   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_CURSOR_BLINK ) == TextField::Property::ENABLE_CURSOR_BLINK );
488   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_BLINK_INTERVAL ) == TextField::Property::CURSOR_BLINK_INTERVAL );
489   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_BLINK_DURATION ) == TextField::Property::CURSOR_BLINK_DURATION );
490   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_CURSOR_WIDTH ) == TextField::Property::CURSOR_WIDTH );
491   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_GRAB_HANDLE_IMAGE ) == TextField::Property::GRAB_HANDLE_IMAGE );
492   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_GRAB_HANDLE_PRESSED_IMAGE ) == TextField::Property::GRAB_HANDLE_PRESSED_IMAGE );
493   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SCROLL_THRESHOLD ) == TextField::Property::SCROLL_THRESHOLD );
494   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SCROLL_SPEED ) == TextField::Property::SCROLL_SPEED );
495   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_IMAGE_LEFT );
496   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT );
497   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT );
498   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_PRESSED_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT );
499   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_LEFT ) == TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT );
500   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HANDLE_MARKER_IMAGE_RIGHT ) == TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT );
501   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SELECTION_HIGHLIGHT_COLOR ) == TextField::Property::SELECTION_HIGHLIGHT_COLOR );
502   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_DECORATION_BOUNDING_BOX ) == TextField::Property::DECORATION_BOUNDING_BOX );
503   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_METHOD_SETTINGS ) == TextField::Property::INPUT_METHOD_SETTINGS );
504   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_COLOR ) == TextField::Property::INPUT_COLOR );
505   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_MARKUP ) == TextField::Property::ENABLE_MARKUP );
506   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_FONT_FAMILY ) == TextField::Property::INPUT_FONT_FAMILY );
507   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_FONT_STYLE ) == TextField::Property::INPUT_FONT_STYLE );
508   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_POINT_SIZE ) == TextField::Property::INPUT_POINT_SIZE );
509   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_UNDERLINE ) == TextField::Property::UNDERLINE );
510   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_UNDERLINE ) == TextField::Property::INPUT_UNDERLINE );
511   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_SHADOW ) == TextField::Property::SHADOW );
512   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_SHADOW ) == TextField::Property::INPUT_SHADOW );
513   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_EMBOSS ) == TextField::Property::EMBOSS );
514   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_EMBOSS ) == TextField::Property::INPUT_EMBOSS );
515   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_OUTLINE ) == TextField::Property::OUTLINE );
516   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_INPUT_OUTLINE ) == TextField::Property::INPUT_OUTLINE );
517   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_HIDDEN_INPUT_SETTINGS ) == TextField::Property::HIDDEN_INPUT_SETTINGS );
518   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PIXEL_SIZE ) == TextField::Property::PIXEL_SIZE );
519   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_SELECTION ) == TextField::Property::ENABLE_SELECTION );
520   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_PLACEHOLDER ) == TextField::Property::PLACEHOLDER );
521   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ELLIPSIS ) == TextField::Property::ELLIPSIS );
522   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_FONT_SIZE_SCALE ) == DevelTextField::Property::FONT_SIZE_SCALE );
523   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_SHIFT_SELECTION ) == DevelTextField::Property::ENABLE_SHIFT_SELECTION );
524   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_GRAB_HANDLE ) == DevelTextField::Property::ENABLE_GRAB_HANDLE );
525   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_MATCH_SYSTEM_LANGUAGE_DIRECTION ) == DevelTextField::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION );
526   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_ENABLE_GRAB_HANDLE_POPUP ) == DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP );
527   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_BACKGROUND ) == DevelTextField::Property::BACKGROUND );
528   DALI_TEST_CHECK( field.GetPropertyIndex( PROPERTY_NAME_GRAB_HANDLE_COLOR ) == DevelTextField::Property::GRAB_HANDLE_COLOR );
529
530   END_TEST;
531 }
532
533 bool SetPropertyMapRetrieved( TextField& field, const Property::Index property, const std::string mapKey, const std::string mapValue )
534 {
535   bool result = false;
536   Property::Map imageMap;
537   imageMap[mapKey] =mapValue;
538
539   field.SetProperty( property , imageMap );
540   Property::Value propValue = field.GetProperty( property );
541   Property::Map* resultMap = propValue.GetMap();
542
543   if ( resultMap->Find( mapKey )->Get< std::string>() == mapValue )
544   {
545     result = true;
546   }
547
548   return result;
549 }
550
551 // Positive test case for a method
552 int UtcDaliTextFieldSetPropertyP(void)
553 {
554   ToolkitTestApplication application;
555   tet_infoline(" UtcDaliToolkitTextFieldSetPropertyP");
556   TextField field = TextField::New();
557   DALI_TEST_CHECK( field );
558   application.GetScene().Add( field );
559
560   // Note - we can't check the defaults since the stylesheets are platform-specific
561
562   // Check the render backend property.
563   field.SetProperty( DevelTextField::Property::RENDERING_BACKEND, DevelText::RENDERING_SHARED_ATLAS );
564   DALI_TEST_EQUALS( (DevelText::RenderingType)field.GetProperty<int>( DevelTextField::Property::RENDERING_BACKEND ), DevelText::RENDERING_SHARED_ATLAS, TEST_LOCATION );
565
566   field.SetProperty( DevelTextField::Property::RENDERING_BACKEND, DevelText::RENDERING_VECTOR_BASED );
567   DALI_TEST_EQUALS( (DevelText::RenderingType)field.GetProperty<int>( DevelTextField::Property::RENDERING_BACKEND ), DevelText::RENDERING_VECTOR_BASED, TEST_LOCATION );
568
569   // Check text property.
570   field.SetProperty( TextField::Property::TEXT, "Setting Text" );
571   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("Setting Text"), TEST_LOCATION );
572
573   // Check placeholder text properties.
574   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "Setting Placeholder Text" );
575   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::PLACEHOLDER_TEXT ), std::string("Setting Placeholder Text"), TEST_LOCATION );
576
577   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_FOCUSED, "Setting Placeholder Text Focused" );
578   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::PLACEHOLDER_TEXT_FOCUSED ), std::string("Setting Placeholder Text Focused"), TEST_LOCATION );
579
580   // Check font properties.
581   field.SetProperty( TextField::Property::FONT_FAMILY, "Setting font family" );
582   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::FONT_FAMILY ), std::string("Setting font family"), TEST_LOCATION );
583
584   Property::Map fontStyleMapSet;
585   Property::Map fontStyleMapGet;
586   Property::Value* slantValue = NULL;
587
588   fontStyleMapSet.Insert( "weight", "bold" );
589   fontStyleMapSet.Insert( "width", "condensed" );
590   fontStyleMapSet.Insert( "slant", "italic" );
591   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
592
593   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
594   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
595   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
596
597   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
598   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::POINT_SIZE ), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
599
600   field.SetProperty( DevelTextField::Property::FONT_SIZE_SCALE, 2.5f );
601   DALI_TEST_EQUALS( field.GetProperty<float>( DevelTextField::Property::FONT_SIZE_SCALE ), 2.5f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
602   field.SetProperty( DevelTextField::Property::FONT_SIZE_SCALE, 1.0f );
603
604   // Reset font style.
605   fontStyleMapSet.Clear();
606   fontStyleMapSet.Insert( "weight", "normal" );
607   fontStyleMapSet.Insert( "slant", "oblique" );
608   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
609
610   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
611   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
612   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
613
614   fontStyleMapSet.Clear();
615   fontStyleMapSet.Insert( "slant", "roman" );
616   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
617   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
618
619   // Replace 'roman' for 'normal'.
620   slantValue = fontStyleMapGet.Find( "slant" );
621   if( NULL != slantValue )
622   {
623     if( "normal" == slantValue->Get<std::string>() )
624     {
625       fontStyleMapGet["slant"] = "roman";
626     }
627   }
628   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
629   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
630
631   fontStyleMapSet.Clear();
632
633   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
634   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
635   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
636   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
637
638   // Check that the MAX_LENGTH property can be correctly set
639   const int maxNumberOfCharacters = 20;
640   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
641   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::MAX_LENGTH ), maxNumberOfCharacters, TEST_LOCATION );
642
643   // Check exceed policy
644   field.SetProperty( TextField::Property::EXCEED_POLICY, Dali::Toolkit::TextField::EXCEED_POLICY_CLIP );
645   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::EXCEED_POLICY ), static_cast<int>( Dali::Toolkit::TextField::EXCEED_POLICY_CLIP ), TEST_LOCATION );
646   field.SetProperty( TextField::Property::EXCEED_POLICY, Dali::Toolkit::TextField::EXCEED_POLICY_ORIGINAL );
647   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::EXCEED_POLICY ), static_cast<int>( Dali::Toolkit::TextField::EXCEED_POLICY_ORIGINAL ), TEST_LOCATION );
648
649   // Check that the Alignment properties can be correctly set
650   field.SetProperty( TextField::Property::HORIZONTAL_ALIGNMENT, "END" );
651   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::HORIZONTAL_ALIGNMENT ), "END", TEST_LOCATION );
652   field.SetProperty( TextField::Property::VERTICAL_ALIGNMENT, "CENTER" );
653   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::VERTICAL_ALIGNMENT ), "CENTER", TEST_LOCATION );
654
655   // Check text's color property
656   field.SetProperty( TextField::Property::TEXT_COLOR, Color::WHITE );
657   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::TEXT_COLOR ), Color::WHITE, TEST_LOCATION );
658
659   // Check placeholder text's color property.
660   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT_COLOR, Color::RED );
661   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::PLACEHOLDER_TEXT_COLOR ), Color::RED, TEST_LOCATION );
662
663   // Check cursor properties
664   field.SetProperty( TextField::Property::PRIMARY_CURSOR_COLOR, Color::RED );
665   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::PRIMARY_CURSOR_COLOR ), Color::RED, TEST_LOCATION );
666   field.SetProperty( TextField::Property::SECONDARY_CURSOR_COLOR, Color::BLUE );
667   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::SECONDARY_CURSOR_COLOR ), Color::BLUE, TEST_LOCATION );
668
669   field.SetProperty( TextField::Property::ENABLE_CURSOR_BLINK, false );
670   DALI_TEST_EQUALS( field.GetProperty<bool>( TextField::Property::ENABLE_CURSOR_BLINK ), false, TEST_LOCATION );
671   field.SetProperty( TextField::Property::CURSOR_BLINK_INTERVAL, 1.f );
672   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::CURSOR_BLINK_INTERVAL ), 1.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
673   field.SetProperty( TextField::Property::CURSOR_BLINK_DURATION, 10.f );
674   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::CURSOR_BLINK_DURATION ), 10.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
675   field.SetProperty( TextField::Property::CURSOR_WIDTH, 1 );
676   DALI_TEST_EQUALS( field.GetProperty<int>( TextField::Property::CURSOR_WIDTH ), 1, TEST_LOCATION );
677
678   // Check scroll properties.
679   field.SetProperty( TextField::Property::SCROLL_THRESHOLD, 1.f );
680   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::SCROLL_THRESHOLD ), 1.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
681   field.SetProperty( TextField::Property::SCROLL_SPEED, 100.f );
682   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::SCROLL_SPEED ), 100.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
683
684   // Check handle images
685   field.SetProperty( TextField::Property::GRAB_HANDLE_IMAGE, "image1" );
686   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::GRAB_HANDLE_IMAGE ), "image1", TEST_LOCATION );
687   field.SetProperty( TextField::Property::GRAB_HANDLE_PRESSED_IMAGE, "image2" );
688   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::GRAB_HANDLE_PRESSED_IMAGE ), "image2", TEST_LOCATION );
689   field.SetProperty( TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, "image3" );
690
691   // Check handle images
692   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_IMAGE_LEFT, "filename", "leftHandleImage" )  );
693   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_IMAGE_RIGHT, "filename", "rightHandleImage" )  );
694   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT, "filename", "leftHandleImagePressed" )  );
695   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, "filename", "rightHandleImagePressed" )  );
696   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_LEFT, "filename", "leftHandleMarkerImage" )  );
697   DALI_TEST_CHECK( SetPropertyMapRetrieved( field, TextField::Property::SELECTION_HANDLE_MARKER_IMAGE_RIGHT, "filename", "rightHandleMarkerImage" )  );
698
699   // Check the highlight color
700   field.SetProperty( TextField::Property::SELECTION_HIGHLIGHT_COLOR, Color::GREEN );
701   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::SELECTION_HIGHLIGHT_COLOR ), Color::GREEN, TEST_LOCATION );
702
703   // Decoration bounding box
704   field.SetProperty( TextField::Property::DECORATION_BOUNDING_BOX, Rect<int>( 0, 0, 1, 1 ) );
705   DALI_TEST_EQUALS( field.GetProperty<Rect <int > >( TextField::Property::DECORATION_BOUNDING_BOX ), Rect<int>( 0, 0, 1, 1 ), TEST_LOCATION );
706
707   // Check the input method setting
708   Property::Map propertyMap;
709   InputMethod::PanelLayout::Type panelLayout = InputMethod::PanelLayout::NUMBER;
710   InputMethod::AutoCapital::Type autoCapital = InputMethod::AutoCapital::WORD;
711   InputMethod::ButtonAction::Type buttonAction = InputMethod::ButtonAction::GO;
712   int inputVariation = 1;
713   propertyMap["PANEL_LAYOUT"] = panelLayout;
714   propertyMap["AUTO_CAPITALIZE"] = autoCapital;
715   propertyMap["BUTTON_ACTION"] = buttonAction;
716   propertyMap["VARIATION"] = inputVariation;
717   field.SetProperty( TextField::Property::INPUT_METHOD_SETTINGS, propertyMap );
718
719   Property::Value value = field.GetProperty( TextField::Property::INPUT_METHOD_SETTINGS );
720   Property::Map map;
721   DALI_TEST_CHECK( value.Get( map ) );
722
723   int layout = 0;
724   DALI_TEST_CHECK( map[ "PANEL_LAYOUT" ].Get( layout ) );
725   DALI_TEST_EQUALS( static_cast<int>(panelLayout), layout, TEST_LOCATION );
726
727   int capital = 0;
728   DALI_TEST_CHECK( map[ "AUTO_CAPITALIZE" ].Get( capital ) );
729   DALI_TEST_EQUALS( static_cast<int>(autoCapital), capital, TEST_LOCATION );
730
731   int action = 0;
732   DALI_TEST_CHECK( map[ "BUTTON_ACTION" ].Get( action ) );
733   DALI_TEST_EQUALS( static_cast<int>(buttonAction), action, TEST_LOCATION );
734
735   int variation = 0;
736   DALI_TEST_CHECK( map[ "VARIATION" ].Get( variation ) );
737   DALI_TEST_EQUALS( inputVariation, variation, TEST_LOCATION );
738
739   // Check input color property.
740   field.SetProperty( TextField::Property::INPUT_COLOR, Color::YELLOW );
741   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::INPUT_COLOR ), Color::YELLOW, TEST_LOCATION );
742
743   // Check the enable markup property.
744   DALI_TEST_CHECK( !field.GetProperty<bool>( TextField::Property::ENABLE_MARKUP ) );
745   field.SetProperty( TextField::Property::ENABLE_MARKUP, true );
746   DALI_TEST_CHECK( field.GetProperty<bool>( TextField::Property::ENABLE_MARKUP ) );
747
748   // Check input font properties.
749   field.SetProperty( TextField::Property::INPUT_FONT_FAMILY, "Setting input font family" );
750   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_FONT_FAMILY ), "Setting input font family", TEST_LOCATION );
751
752   fontStyleMapSet.Clear();
753   fontStyleMapSet.Insert( "weight", "bold" );
754   fontStyleMapSet.Insert( "width", "condensed" );
755   fontStyleMapSet.Insert( "slant", "italic" );
756
757   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
758   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
759   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
760   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
761
762   field.SetProperty( TextField::Property::INPUT_POINT_SIZE, 12.f );
763   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::INPUT_POINT_SIZE ), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
764
765   // Reset input font style.
766   fontStyleMapSet.Clear();
767   fontStyleMapSet.Insert( "weight", "normal" );
768   fontStyleMapSet.Insert( "slant", "oblique" );
769
770   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
771   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
772   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
773   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
774
775   fontStyleMapSet.Clear();
776   fontStyleMapSet.Insert( "slant", "roman" );
777
778   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
779   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
780
781   // Replace 'roman' for 'normal'.
782   slantValue = fontStyleMapGet.Find( "slant" );
783   if( NULL != slantValue )
784   {
785     if( "normal" == slantValue->Get<std::string>() )
786     {
787       fontStyleMapGet["slant"] = "roman";
788     }
789   }
790   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
791   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
792
793   fontStyleMapSet.Clear();
794
795   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
796   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
797   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
798   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
799
800   Property::Map underlineMapSet;
801   Property::Map underlineMapGet;
802
803   underlineMapSet.Insert( "enable", true );
804   underlineMapSet.Insert( "color", Color::RED );
805   underlineMapSet.Insert( "height", 1 );
806
807   // Check the underline property
808   field.SetProperty( TextField::Property::UNDERLINE, underlineMapSet );
809
810   underlineMapGet = field.GetProperty<Property::Map>( TextField::Property::UNDERLINE );
811   DALI_TEST_EQUALS( underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION );
812   DALI_TEST_EQUALS( DaliTestCheckMaps( underlineMapGet, underlineMapSet ), true, TEST_LOCATION );
813
814   // Check the input underline property
815   field.SetProperty( TextField::Property::INPUT_UNDERLINE, "Underline input properties" );
816   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_UNDERLINE ), std::string("Underline input properties"), TEST_LOCATION );
817
818   // Check the shadow property
819   Property::Map shadowMapSet;
820   Property::Map shadowMapGet;
821
822   shadowMapSet.Insert( "color", Color::GREEN );
823   shadowMapSet.Insert( "offset", Vector2(2.0f, 2.0f) );
824   shadowMapSet.Insert( "blurRadius", 3.0f );
825
826   field.SetProperty( TextField::Property::SHADOW, shadowMapSet );
827
828   shadowMapGet = field.GetProperty<Property::Map>( TextField::Property::SHADOW );
829   DALI_TEST_EQUALS( shadowMapGet.Count(), shadowMapSet.Count(), TEST_LOCATION );
830   DALI_TEST_EQUALS( DaliTestCheckMaps( shadowMapGet, shadowMapSet ), true, TEST_LOCATION );
831
832   // Check the input shadow property
833   field.SetProperty( TextField::Property::INPUT_SHADOW, "Shadow input properties" );
834   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_SHADOW ), std::string("Shadow input properties"), TEST_LOCATION );
835
836   // Check the emboss property
837   field.SetProperty( TextField::Property::EMBOSS, "Emboss properties" );
838   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::EMBOSS ), std::string("Emboss properties"), TEST_LOCATION );
839
840   // Check the input emboss property
841   field.SetProperty( TextField::Property::INPUT_EMBOSS, "Emboss input properties" );
842   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_EMBOSS ), std::string("Emboss input properties"), TEST_LOCATION );
843
844   // Check the outline property
845
846   // Test string type first
847   // This is purely to maintain backward compatibility, but we don't support string as the outline property type.
848   field.SetProperty( TextField::Property::OUTLINE, "Outline properties" );
849   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::OUTLINE ), std::string("Outline properties"), TEST_LOCATION );
850
851   // Then test the property map type
852   Property::Map outlineMapSet;
853   Property::Map outlineMapGet;
854
855   outlineMapSet["color"] = Color::RED;
856   outlineMapSet["width"] = 2.0f;
857
858   field.SetProperty( TextField::Property::OUTLINE, outlineMapSet );
859
860   outlineMapGet = field.GetProperty<Property::Map>( TextField::Property::OUTLINE );
861   DALI_TEST_EQUALS( outlineMapGet.Count(), outlineMapSet.Count(), TEST_LOCATION );
862   DALI_TEST_EQUALS( DaliTestCheckMaps( outlineMapGet, outlineMapSet ), true, TEST_LOCATION );
863
864   // Check the input outline property
865   field.SetProperty( TextField::Property::INPUT_OUTLINE, "Outline input properties" );
866   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_OUTLINE ), std::string("Outline input properties"), TEST_LOCATION );
867
868   // Check the hidden input settings property
869   Property::Map hiddenMapSet;
870   Property::Map hiddenMapGet;
871   hiddenMapSet[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_ALL;
872   hiddenMapSet[ HiddenInput::Property::SHOW_LAST_CHARACTER_DURATION ] = 2;
873   hiddenMapSet[ HiddenInput::Property::SUBSTITUTE_COUNT ] = 4;
874   hiddenMapSet[ HiddenInput::Property::SUBSTITUTE_CHARACTER ] = 0x23;
875   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, hiddenMapSet );
876
877   hiddenMapGet = field.GetProperty<Property::Map>( TextField::Property::HIDDEN_INPUT_SETTINGS );
878   DALI_TEST_EQUALS( hiddenMapSet.Count(), hiddenMapGet.Count(), TEST_LOCATION );
879   DALI_TEST_EQUALS( DaliTestCheckMaps( hiddenMapSet, hiddenMapGet ), true, TEST_LOCATION );
880
881   // Check the pixel size of font
882   field.SetProperty( TextField::Property::PIXEL_SIZE, 20.f );
883   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::PIXEL_SIZE ), 20.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
884
885   // Check the enable selection property
886   field.SetProperty( TextField::Property::ENABLE_SELECTION, false );
887   DALI_TEST_EQUALS( field.GetProperty<bool>( TextField::Property::ENABLE_SELECTION ), false, TEST_LOCATION );
888
889   // Check the placeholder property with pixel size
890   Property::Map placeholderPixelSizeMapSet;
891   Property::Map placeholderPixelSizeMapGet;
892   Property::Map placeholderFontstyleMap;
893   placeholderPixelSizeMapSet["text"] = "Setting Placeholder Text";
894   placeholderPixelSizeMapSet["textFocused"] = "Setting Placeholder Text Focused";
895   placeholderPixelSizeMapSet["color"] = Color::BLUE;
896   placeholderPixelSizeMapSet["fontFamily"] = "Arial";
897   placeholderPixelSizeMapSet["pixelSize"] = 15.0f;
898   placeholderPixelSizeMapSet["ellipsis"] = true;
899
900   placeholderFontstyleMap.Insert( "weight", "bold" );
901   placeholderPixelSizeMapSet["placeholderFontStyle"] = placeholderFontstyleMap;
902   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderPixelSizeMapSet );
903
904   placeholderPixelSizeMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
905   DALI_TEST_EQUALS( placeholderPixelSizeMapGet.Count(), placeholderPixelSizeMapSet.Count(), TEST_LOCATION );
906
907   tet_infoline("Test Placeholder settings set as strings is converted correctly to Property Index key and holds set value");
908   Property::Map placeholderConversionMap;
909   placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderPixelSizeMapSet["text"];
910   placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderPixelSizeMapSet["textFocused"] ;
911   placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderPixelSizeMapSet["color"];
912   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
913   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderPixelSizeMapSet["fontFamily"];
914   placeholderConversionMap[ Text::PlaceHolder::Property::PIXEL_SIZE ] = placeholderPixelSizeMapSet["pixelSize"];
915
916   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderConversionMap ), true, TEST_LOCATION );
917
918   // Check the placeholder property with point size
919   Property::Map placeholderMapSet;
920   Property::Map placeholderMapGet;
921   placeholderMapSet["text"] = "Setting Placeholder Text";
922   placeholderMapSet["textFocused"] = "Setting Placeholder Text Focused";
923   placeholderMapSet["color"] = Color::RED;
924   placeholderMapSet["fontFamily"] = "Arial";
925   placeholderMapSet["pointSize"] = 12.0f;
926   placeholderMapSet["ellipsis"] = false;
927
928   // Check the placeholder font style property
929   placeholderFontstyleMap.Clear();
930
931   placeholderFontstyleMap.Insert( "weight", "bold" );
932   placeholderFontstyleMap.Insert( "width", "condensed" );
933   placeholderFontstyleMap.Insert( "slant", "italic" );
934   placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
935   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
936
937   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
938   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
939
940   placeholderConversionMap.Clear();
941   placeholderConversionMap[ Text::PlaceHolder::Property::TEXT ] = placeholderPixelSizeMapSet["text"];
942   placeholderConversionMap[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = placeholderPixelSizeMapSet["textFocused"] ;
943   placeholderConversionMap[ Text::PlaceHolder::Property::COLOR ] = placeholderPixelSizeMapSet["color"];
944   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
945   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_FAMILY ] = placeholderPixelSizeMapSet["fontFamily"];
946   placeholderConversionMap[ Text::PlaceHolder::Property::POINT_SIZE ] = placeholderPixelSizeMapSet["pointSize"];
947
948   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
949
950   // Reset font style.
951   placeholderFontstyleMap.Clear();
952   placeholderFontstyleMap.Insert( "weight", "normal" );
953   placeholderFontstyleMap.Insert( "slant", "oblique" );
954   placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
955   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
956
957   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
958   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
959
960   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
961   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
962
963   placeholderFontstyleMap.Clear();
964   placeholderFontstyleMap.Insert( "slant", "roman" );
965   placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
966   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
967
968   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
969
970   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
971
972   placeholderFontstyleMap.Clear();
973   placeholderMapSet["fontStyle"] = placeholderFontstyleMap;
974   placeholderConversionMap[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderPixelSizeMapSet["fontStyle"];
975
976   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
977   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
978   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
979
980   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderConversionMap ), true, TEST_LOCATION );
981
982   // Check the ellipsis property
983   DALI_TEST_CHECK( !field.GetProperty<bool>( TextField::Property::ELLIPSIS ) );
984   field.SetProperty( TextField::Property::ELLIPSIS, true );
985   DALI_TEST_CHECK( field.GetProperty<bool>( TextField::Property::ELLIPSIS ) );
986
987   field.SetProperty( Actor::Property::LAYOUT_DIRECTION, LayoutDirection::RIGHT_TO_LEFT );
988   DALI_TEST_EQUALS( field.GetProperty<int>( Actor::Property::LAYOUT_DIRECTION ), static_cast<int>( LayoutDirection::RIGHT_TO_LEFT ), TEST_LOCATION );
989
990   // Test the ENABLE_GRAB_HANDLE_POPUP property
991   DALI_TEST_CHECK( field.GetProperty<bool>( DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP ) );
992   field.SetProperty( DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP, false );
993   DALI_TEST_CHECK( !field.GetProperty<bool>( DevelTextField::Property::ENABLE_GRAB_HANDLE_POPUP ) );
994
995   // Check the background property
996   field.SetProperty( DevelTextField::Property::BACKGROUND, Color::RED );
997   DALI_TEST_EQUALS( field.GetProperty<Vector4>( DevelTextField::Property::BACKGROUND ), Color::RED, TEST_LOCATION );
998
999   //Check handle color
1000   field.SetProperty( DevelTextField::Property::GRAB_HANDLE_COLOR, Color::GREEN );
1001   DALI_TEST_EQUALS( field.GetProperty<Vector4>( DevelTextField::Property::GRAB_HANDLE_COLOR ), Color::GREEN, TEST_LOCATION );
1002
1003   application.SendNotification();
1004   application.Render();
1005
1006   END_TEST;
1007 }
1008
1009 // Positive Atlas Text Renderer test
1010 int utcDaliTextFieldAtlasRenderP(void)
1011 {
1012   ToolkitTestApplication application;
1013   tet_infoline(" UtcDaliToolkitTextFieldAtlasRenderP");
1014   StyleManager styleManager = StyleManager::Get();
1015   styleManager.ApplyDefaultTheme();
1016   TextField field = TextField::New();
1017   DALI_TEST_CHECK( field );
1018
1019   field.SetProperty( TextField::Property::HORIZONTAL_ALIGNMENT, "CENTER" );
1020
1021   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1022
1023   application.GetScene().Add( field );
1024
1025   try
1026   {
1027     // Render some text with the shared atlas backend
1028     field.SetProperty( DevelTextField::Property::RENDERING_BACKEND, DevelText::RENDERING_SHARED_ATLAS );
1029     application.SendNotification();
1030     application.Render();
1031   }
1032   catch( ... )
1033   {
1034     tet_result(TET_FAIL);
1035   }
1036   END_TEST;
1037 }
1038
1039 // Positive test for the anchorClicked signal.
1040 int utcDaliTextFieldAnchorClicked01(void)
1041 {
1042   ToolkitTestApplication application;
1043   tet_infoline(" utcDaliTextFieldAnchorClicked01");
1044   TextField field = TextField::New();
1045   DALI_TEST_CHECK(field);
1046
1047   application.GetScene().Add(field);
1048
1049   // connect to the anchor clicked signal.
1050   ConnectionTracker* testTracker = new ConnectionTracker();
1051   DevelTextField::AnchorClickedSignal(field).Connect(&TestAnchorClickedCallback);
1052   bool anchorClickedSignal = false;
1053   field.ConnectSignal(testTracker, "anchorClicked", CallbackFunctor(&anchorClickedSignal));
1054
1055   gAnchorClickedCallBackCalled = false;
1056   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1057   field.SetProperty(TextField::Property::ENABLE_MARKUP, true);
1058   field.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
1059   field.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1060   field.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1061
1062   application.SendNotification();
1063   application.Render();
1064   field.SetKeyInputFocus();
1065
1066   // Create a tap event to touch the text field.
1067   TestGenerateTap(application, 5.0f, 25.0f);
1068   application.SendNotification();
1069   application.Render();
1070
1071   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1072   DALI_TEST_CHECK(anchorClickedSignal);
1073
1074   gAnchorClickedCallBackNotCalled = true;
1075   // Tap the outside of anchor, callback should not be called.
1076   TestGenerateTap(application, 150.f, 100.f);
1077   application.SendNotification();
1078   application.Render();
1079
1080   DALI_TEST_CHECK(gAnchorClickedCallBackNotCalled);
1081
1082   END_TEST;
1083 }
1084
1085 // Positive test for the anchorClicked signal.
1086 int utcDaliTextFieldAnchorClicked02(void)
1087 {
1088   ToolkitTestApplication application;
1089   tet_infoline(" utcDaliTextFieldAnchorClicked02");
1090   TextField field = TextField::New();
1091   DALI_TEST_CHECK(field);
1092
1093   application.GetScene().Add(field);
1094
1095   // connect to the anchor clicked signal.
1096   ConnectionTracker* testTracker = new ConnectionTracker();
1097   DevelTextField::AnchorClickedSignal(field).Connect(&TestAnchorClickedCallback);
1098   bool anchorClickedSignal = false;
1099   field.ConnectSignal(testTracker, "anchorClicked", CallbackFunctor(&anchorClickedSignal));
1100
1101   gAnchorClickedCallBackCalled = false;
1102   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1103   field.SetProperty(TextField::Property::ENABLE_MARKUP, true);
1104   field.SetProperty(Actor::Property::SIZE, Vector2(100.f, 50.f));
1105   field.SetProperty(Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT);
1106   field.SetProperty(Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT);
1107
1108   application.SendNotification();
1109   application.Render();
1110   field.SetKeyInputFocus();
1111
1112   // Avoid a crash when core load gl resources.
1113   application.GetGlAbstraction().SetCheckFramebufferStatusResult(GL_FRAMEBUFFER_COMPLETE);
1114
1115   // Create a tap event to touch the text field.
1116   TestGenerateTap(application, 30.0f, 25.0f, 100);
1117   application.SendNotification();
1118   application.Render();
1119
1120   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1121   DALI_TEST_CHECK(anchorClickedSignal);
1122
1123
1124   // For coverage InsertTextAnchor, RemoveTextAnchor
1125   // first index insert
1126   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1127   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 0);
1128   application.SendNotification();
1129   application.Render();
1130
1131   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1132   application.SendNotification();
1133   application.Render();
1134
1135   gAnchorClickedCallBackCalled = false;
1136   // Create a tap event to touch the text field.
1137   TestGenerateTap(application, 30.0f, 25.0f, 700);
1138   application.SendNotification();
1139   field.SetKeyInputFocus();
1140
1141   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1142
1143   // last index insert
1144   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1145   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 5);
1146   application.SendNotification();
1147   application.Render();
1148
1149   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1150   application.SendNotification();
1151   application.Render();
1152
1153   gAnchorClickedCallBackCalled = false;
1154   // Create a tap event to touch the text field.
1155   TestGenerateTap(application, 30.0f, 25.0f, 1300);
1156   application.SendNotification();
1157   field.SetKeyInputFocus();
1158
1159   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1160
1161   // mid index insert
1162   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1163   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 2);
1164   application.SendNotification();
1165   application.Render();
1166
1167   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1168   application.SendNotification();
1169   application.Render();
1170
1171   gAnchorClickedCallBackCalled = false;
1172   // Create a tap event to touch the text field.
1173   TestGenerateTap(application, 30.0f, 25.0f, 1900);
1174   application.SendNotification();
1175   field.SetKeyInputFocus();
1176
1177   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1178
1179   // first index remove
1180   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1181   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 0);
1182   application.SendNotification();
1183   application.Render();
1184
1185   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1186   application.ProcessEvent(GenerateKey("Delete", "", "Delete", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1187   application.SendNotification();
1188   application.Render();
1189
1190   gAnchorClickedCallBackCalled = false;
1191   // Create a tap event to touch the text field.
1192   TestGenerateTap(application, 30.0f, 25.0f, 2500);
1193   application.SendNotification();
1194   field.SetKeyInputFocus();
1195
1196   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1197
1198   // last index remove
1199   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1200   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 5);
1201   application.SendNotification();
1202   application.Render();
1203
1204   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1205   application.ProcessEvent(GenerateKey("Delete", "", "Delete", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1206   application.SendNotification();
1207   application.Render();
1208
1209   gAnchorClickedCallBackCalled = false;
1210   // Create a tap event to touch the text field.
1211   TestGenerateTap(application, 30.0f, 25.0f, 3100);
1212   application.SendNotification();
1213   application.Render();
1214
1215   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1216
1217   // middle index
1218   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1219   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 2);
1220   application.SendNotification();
1221   application.Render();
1222
1223   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1224   application.ProcessEvent(GenerateKey("Delete", "", "Delete", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1225   application.SendNotification();
1226   application.Render();
1227
1228   gAnchorClickedCallBackCalled = false;
1229   // Create a tap event to touch the text field.
1230   TestGenerateTap(application, 30.0f, 25.0f, 3700);
1231   application.SendNotification();
1232   application.Render();
1233
1234   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1235
1236   // 0 ~ 1 index remove
1237   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1238   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_START, 0);
1239   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_END, 1);
1240   application.SendNotification();
1241   application.Render();
1242
1243   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1244   application.SendNotification();
1245   application.Render();
1246
1247   gAnchorClickedCallBackCalled = false;
1248   // Create a tap event to touch the text field.
1249   TestGenerateTap(application, 30.0f, 25.0f, 4300);
1250   application.SendNotification();
1251   application.Render();
1252
1253   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1254
1255   // 1 ~ 3 index remove
1256   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1257   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_START, 1);
1258   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_END, 3);
1259   application.SendNotification();
1260   application.Render();
1261
1262   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1263   application.SendNotification();
1264   application.Render();
1265
1266   gAnchorClickedCallBackCalled = false;
1267   // Create a tap event to touch the text field.
1268   TestGenerateTap(application, 30.0f, 25.0f, 4900);
1269   application.SendNotification();
1270   application.Render();
1271
1272   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1273
1274   // 3 ~ 4 index remove
1275   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1276   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_START, 3);
1277   field.SetProperty( DevelTextField::Property::SELECTED_TEXT_END, 4);
1278   application.SendNotification();
1279   application.Render();
1280
1281   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1282   application.SendNotification();
1283   application.Render();
1284
1285   gAnchorClickedCallBackCalled = false;
1286   // Create a tap event to touch the text field.
1287   TestGenerateTap(application, 30.0f, 25.0f, 5500);
1288   application.SendNotification();
1289   application.Render();
1290
1291   DALI_TEST_CHECK(gAnchorClickedCallBackCalled);
1292
1293   // Remove front of anchor
1294   field.SetProperty(TextField::Property::TEXT, "TIZEN<a href='https://www.tizen.org'>TIZEN</a>");
1295   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 3);
1296   application.SendNotification();
1297   application.Render();
1298
1299   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1300   application.SendNotification();
1301   application.Render();
1302
1303   // Remove whole text
1304   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>TIZEN</a>");
1305   DevelTextField::SelectWholeText(field);
1306   application.SendNotification();
1307   application.Render();
1308
1309   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1310   application.SendNotification();
1311   application.Render();
1312
1313   // Remove all with backspace
1314   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>T</a>");
1315   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 1);
1316   application.SendNotification();
1317   application.Render();
1318
1319   application.ProcessEvent(GenerateKey("", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1320   application.SendNotification();
1321   application.Render();
1322
1323   // Remove all with delete
1324   field.SetProperty(TextField::Property::TEXT, "<a href='https://www.tizen.org'>T</a>");
1325   field.SetProperty(DevelTextField::Property::PRIMARY_CURSOR_POSITION, 0);
1326   application.SendNotification();
1327   application.Render();
1328
1329   application.ProcessEvent(GenerateKey("Delete", "", "Delete", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE));
1330   application.SendNotification();
1331   application.Render();
1332
1333   END_TEST;
1334 }
1335
1336 // Positive test for the textChanged signal.
1337 int utcDaliTextFieldTextChangedP(void)
1338 {
1339   ToolkitTestApplication application;
1340   tet_infoline(" utcDaliTextFieldTextChangedP");
1341   TextField field = TextField::New();
1342   DALI_TEST_CHECK( field );
1343
1344   application.GetScene().Add( field );
1345
1346   // connect to the text changed signal.
1347   ConnectionTracker* testTracker = new ConnectionTracker();
1348   field.TextChangedSignal().Connect(&TestTextChangedCallback);
1349   bool textChangedSignal = false;
1350   field.ConnectSignal( testTracker, "textChanged",   CallbackFunctor(&textChangedSignal) );
1351
1352   gTextChangedCallBackCalled = false;
1353   field.SetProperty( TextField::Property::TEXT, "ABC" );
1354   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1355   DALI_TEST_CHECK( textChangedSignal );
1356
1357   application.SendNotification();
1358   field.SetKeyInputFocus();
1359
1360   gTextChangedCallBackCalled = false;
1361   application.ProcessEvent( GenerateKey( "D", "", "D", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "D", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1362   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1363
1364   // Remove all text
1365   field.SetProperty( TextField::Property::TEXT, "" );
1366
1367   // Pressing backspace key: TextChangedCallback should not be called when there is no text in textfield.
1368   gTextChangedCallBackCalled = false;
1369   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1370   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1371
1372   // Pressing delete key: TextChangedCallback should not be called when there is no text in textfield.
1373   gTextChangedCallBackCalled = false;
1374   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1375   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1376
1377   END_TEST;
1378 }
1379
1380 int utcDaliTextFieldTextChangedWithInputMethodContext(void)
1381 {
1382   ToolkitTestApplication application;
1383   tet_infoline(" utcDaliTextFieldTextChangedWithInputMethodContext");
1384   TextField field = TextField::New();
1385   DALI_TEST_CHECK( field );
1386
1387
1388   application.GetScene().Add( field );
1389
1390   // connect to the text changed signal.
1391   ConnectionTracker* testTracker = new ConnectionTracker();
1392   field.TextChangedSignal().Connect(&TestTextChangedCallback);
1393   bool textChangedSignal = false;
1394   field.ConnectSignal( testTracker, "textChanged",   CallbackFunctor(&textChangedSignal) );
1395
1396
1397   // get InputMethodContext
1398   std::string text;
1399   InputMethodContext::EventData imfEvent;
1400   InputMethodContext inputMethodContext = DevelTextField::GetInputMethodContext( field );
1401
1402   field.SetKeyInputFocus();
1403   field.SetProperty( DevelTextField::Property::ENABLE_EDITING, true );
1404
1405   // input text
1406   gTextChangedCallBackCalled = false;
1407   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "ㅎ", 0, 1 );
1408   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1409   application.SendNotification();
1410   application.Render();
1411   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1412   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("ㅎ"), TEST_LOCATION );
1413
1414   gTextChangedCallBackCalled = false;
1415   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "호", 0, 1 );
1416   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1417   application.SendNotification();
1418   application.Render();
1419   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1420   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("호"), TEST_LOCATION );
1421
1422   gTextChangedCallBackCalled = false;
1423   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "혿", 0, 1 );
1424   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1425   application.SendNotification();
1426   application.Render();
1427   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1428   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("혿"), TEST_LOCATION );
1429
1430   gTextChangedCallBackCalled = false;
1431   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "", 0, 1 );
1432   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1433   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1434
1435   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "호", 0, 1 );
1436   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1437   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1438
1439   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "두", 1, 2 );
1440   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1441   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1442
1443   application.SendNotification();
1444   application.Render();
1445   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1446   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("호두"), TEST_LOCATION );
1447
1448   END_TEST;
1449 }
1450
1451
1452 // Negative test for the textChanged signal.
1453 int utcDaliTextFieldTextChangedN(void)
1454 {
1455   ToolkitTestApplication application;
1456   tet_infoline(" utcDaliTextFieldTextChangedN");
1457   TextField field = TextField::New();
1458   DALI_TEST_CHECK( field );
1459
1460   application.GetScene().Add( field );
1461
1462   // connect to the text changed signal.
1463   ConnectionTracker* testTracker = new ConnectionTracker();
1464   field.TextChangedSignal().Connect(&TestTextChangedCallback);
1465   bool textChangedSignal = false;
1466   field.ConnectSignal( testTracker, "textChanged",   CallbackFunctor(&textChangedSignal) );
1467
1468   gTextChangedCallBackCalled = false;
1469   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "ABC" ); // Setting placeholder, not TEXT
1470   application.SendNotification();
1471   application.Render();
1472   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1473   DALI_TEST_CHECK( !textChangedSignal );
1474
1475   END_TEST;
1476 }
1477
1478 // Positive test for Max Characters reached signal.
1479 int utcDaliTextFieldMaxCharactersReachedP(void)
1480 {
1481   ToolkitTestApplication application;
1482   tet_infoline(" utcDaliTextFieldMaxCharactersReachedP");
1483   TextField field = TextField::New();
1484   DALI_TEST_CHECK( field );
1485
1486   application.GetScene().Add( field );
1487
1488   const int maxNumberOfCharacters = 1;
1489   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
1490
1491   field.SetKeyInputFocus();
1492
1493   // connect to the text changed signal.
1494   ConnectionTracker* testTracker = new ConnectionTracker();
1495   field.MaxLengthReachedSignal().Connect(&TestMaxLengthReachedCallback);
1496   bool maxLengthReachedSignal = false;
1497   field.ConnectSignal( testTracker, "maxLengthReached",   CallbackFunctor(&maxLengthReachedSignal) );
1498
1499   gMaxCharactersCallBackCalled = false;
1500
1501   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1502   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1503
1504   DALI_TEST_CHECK( gMaxCharactersCallBackCalled );
1505   DALI_TEST_CHECK( maxLengthReachedSignal );
1506
1507   END_TEST;
1508 }
1509
1510 // Negative test for Max Characters reached signal.
1511 int utcDaliTextFieldMaxCharactersReachedN(void)
1512 {
1513   ToolkitTestApplication application;
1514   tet_infoline(" utcDaliTextFieldMaxCharactersReachedN");
1515   TextField field = TextField::New();
1516   DALI_TEST_CHECK( field );
1517
1518   application.GetScene().Add( field );
1519
1520   const int maxNumberOfCharacters = 3;
1521   field.SetProperty( TextField::Property::MAX_LENGTH, maxNumberOfCharacters );
1522
1523   field.SetKeyInputFocus();
1524
1525   // connect to the text changed signal.
1526   ConnectionTracker* testTracker = new ConnectionTracker();
1527   field.MaxLengthReachedSignal().Connect(&TestMaxLengthReachedCallback);
1528   bool maxLengthReachedSignal = false;
1529   field.ConnectSignal( testTracker, "maxLengthReached",   CallbackFunctor(&maxLengthReachedSignal) );
1530
1531   gMaxCharactersCallBackCalled = false;
1532
1533   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1534   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1535
1536   DALI_TEST_CHECK( !gMaxCharactersCallBackCalled );
1537   DALI_TEST_CHECK( !maxLengthReachedSignal );
1538
1539   application.ProcessEvent( GenerateKey( "Return", "", "\r", KEY_RETURN_CODE, 0, 0, Integration::KeyEvent::DOWN, "\r", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1540
1541   DALI_TEST_CHECK( !gMaxCharactersCallBackCalled );
1542   DALI_TEST_CHECK( !maxLengthReachedSignal );
1543
1544   END_TEST;
1545 }
1546
1547 int utcDaliTextFieldInputStyleChanged01(void)
1548 {
1549   // The text-field emits signals when the input style changes. These changes of style are
1550   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1551   // can't be emitted during the size negotiation as the callbacks may update the UI.
1552   // The text-field adds an idle callback to the adaptor to emit the signals after the size negotiation.
1553   // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
1554   ToolkitTestApplication application;
1555   tet_infoline(" utcDaliTextFieldInputStyleChanged01");
1556
1557   // Load some fonts.
1558
1559   char* pathNamePtr = get_current_dir_name();
1560   const std::string pathName( pathNamePtr );
1561   free( pathNamePtr );
1562
1563   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1564   fontClient.SetDpi( 93u, 93u );
1565
1566   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif.ttf", DEFAULT_FONT_SIZE );
1567   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif-Bold.ttf", DEFAULT_FONT_SIZE );
1568
1569   TextField field = TextField::New();
1570   DALI_TEST_CHECK( field );
1571
1572
1573   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1574   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1575   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1576
1577   field.SetProperty( TextField::Property::ENABLE_MARKUP, true );
1578   field.SetProperty( TextField::Property::TEXT, "<font family='DejaVuSerif' size='18'>He<color value='green'>llo</color> <font weight='bold'>world</font> demo</font>" );
1579
1580   // connect to the text changed signal.
1581   ConnectionTracker* testTracker = new ConnectionTracker();
1582   field.InputStyleChangedSignal().Connect( &TestInputStyleChangedCallback );
1583   bool inputStyleChangedSignal = false;
1584   field.ConnectSignal( testTracker, "inputStyleChanged",   CallbackFunctor(&inputStyleChangedSignal) );
1585
1586   application.GetScene().Add( field );
1587
1588   // Render and notify
1589   application.SendNotification();
1590   application.Render();
1591
1592   // Executes the idle callbacks added by the text control on the change of input style.
1593   application.RunIdles();
1594
1595   gInputStyleChangedCallbackCalled = false;
1596   gInputStyleMask = TextField::InputStyle::NONE;
1597   inputStyleChangedSignal = false;
1598
1599   // Create a tap event to touch the text field.
1600   TestGenerateTap( application, 18.0f, 25.0f );
1601
1602   // Render and notify
1603   application.SendNotification();
1604   application.Render();
1605
1606   // Executes the idle callbacks added by the text control on the change of input style.
1607   application.RunIdles();
1608
1609   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1610   if( gInputStyleChangedCallbackCalled )
1611   {
1612     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextField::InputStyle::FONT_FAMILY | TextField::InputStyle::POINT_SIZE ), TEST_LOCATION );
1613
1614     const std::string fontFamily = field.GetProperty( TextField::Property::INPUT_FONT_FAMILY ).Get<std::string>();
1615     DALI_TEST_EQUALS( fontFamily, "DejaVuSerif", TEST_LOCATION );
1616
1617     const float pointSize = field.GetProperty( TextField::Property::INPUT_POINT_SIZE ).Get<float>();
1618     DALI_TEST_EQUALS( pointSize, 18.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1619   }
1620   DALI_TEST_CHECK( inputStyleChangedSignal );
1621
1622   gInputStyleChangedCallbackCalled = false;
1623   gInputStyleMask = TextField::InputStyle::NONE;
1624   inputStyleChangedSignal = false;
1625
1626   // Create a tap event to touch the text field.
1627   TestGenerateTap( application, 30.0f, 25.0f );
1628
1629   // Render and notify
1630   application.SendNotification();
1631   application.Render();
1632
1633   // Executes the idle callbacks added by the text control on the change of input style.
1634   application.RunIdles();
1635
1636   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1637   DALI_TEST_CHECK( !inputStyleChangedSignal );
1638
1639   gInputStyleChangedCallbackCalled = false;
1640   gInputStyleMask = TextField::InputStyle::NONE;
1641   inputStyleChangedSignal = false;
1642
1643   // Create a tap event to touch the text field.
1644   TestGenerateTap( application, 43.0f, 25.0f );
1645
1646   // Render and notify
1647   application.SendNotification();
1648   application.Render();
1649
1650   // Executes the idle callbacks added by the text control on the change of input style.
1651   application.RunIdles();
1652
1653   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1654   if( gInputStyleChangedCallbackCalled )
1655   {
1656     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextField::InputStyle::COLOR ), TEST_LOCATION );
1657
1658     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1659     DALI_TEST_EQUALS( color, Color::GREEN, TEST_LOCATION );
1660   }
1661   DALI_TEST_CHECK( inputStyleChangedSignal );
1662
1663   gInputStyleChangedCallbackCalled = false;
1664   gInputStyleMask = TextField::InputStyle::NONE;
1665   inputStyleChangedSignal = false;
1666
1667   // Create a tap event to touch the text field.
1668   TestGenerateTap( application, 88.0f, 25.0f );
1669
1670   // Render and notify
1671   application.SendNotification();
1672   application.Render();
1673
1674   // Executes the idle callbacks added by the text control on the change of input style.
1675   application.RunIdles();
1676
1677   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1678   if( gInputStyleChangedCallbackCalled )
1679   {
1680     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextField::InputStyle::COLOR | TextField::InputStyle::FONT_STYLE ), TEST_LOCATION );
1681
1682     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1683     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1684
1685     const Property::Map fontStyleMapGet = field.GetProperty( TextField::Property::INPUT_FONT_STYLE ).Get<Property::Map>();
1686
1687     Property::Map fontStyleMapSet;
1688     fontStyleMapSet.Insert( "weight", "bold" );
1689
1690     DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1691     DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1692   }
1693   DALI_TEST_CHECK( inputStyleChangedSignal );
1694
1695   gInputStyleChangedCallbackCalled = false;
1696   gInputStyleMask = TextField::InputStyle::NONE;
1697   inputStyleChangedSignal = false;
1698
1699   // Create a tap event to touch the text field.
1700   TestGenerateTap( application, 115.0f, 25.0f );
1701
1702   // Render and notify
1703   application.SendNotification();
1704   application.Render();
1705
1706   // Executes the idle callbacks added by the text control on the change of input style.
1707   application.RunIdles();
1708
1709   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1710   DALI_TEST_CHECK( !inputStyleChangedSignal );
1711
1712   gInputStyleChangedCallbackCalled = false;
1713   gInputStyleMask = TextField::InputStyle::NONE;
1714   inputStyleChangedSignal = false;
1715
1716   // Create a tap event to touch the text field.
1717   TestGenerateTap( application, 164.0f, 25.0f );
1718
1719   // Render and notify
1720   application.SendNotification();
1721   application.Render();
1722
1723   // Executes the idle callbacks added by the text control on the change of input style.
1724   application.RunIdles();
1725
1726   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1727   if( gInputStyleChangedCallbackCalled )
1728   {
1729     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextField::InputStyle::FONT_STYLE ), TEST_LOCATION );
1730
1731     const std::string style = field.GetProperty( TextField::Property::INPUT_FONT_STYLE ).Get<std::string>();
1732     DALI_TEST_CHECK( style.empty() );
1733   }
1734   DALI_TEST_CHECK( inputStyleChangedSignal );
1735
1736   gInputStyleChangedCallbackCalled = false;
1737   gInputStyleMask = TextField::InputStyle::NONE;
1738   inputStyleChangedSignal = false;
1739
1740   // Create a tap event to touch the text field.
1741   TestGenerateTap( application, 191.0f, 25.0f );
1742
1743   // Render and notify
1744   application.SendNotification();
1745   application.Render();
1746
1747   // Executes the idle callbacks added by the text control on the change of input style.
1748   application.RunIdles();
1749
1750   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1751   DALI_TEST_CHECK( !inputStyleChangedSignal );
1752
1753   END_TEST;
1754 }
1755
1756 int utcDaliTextFieldInputStyleChanged02(void)
1757 {
1758   // The text-field emits signals when the input style changes. These changes of style are
1759   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1760   // can't be emitted during the size negotiation as the callbacks may update the UI.
1761   // The text-field adds an idle callback to the adaptor to emit the signals after the size negotiation.
1762   // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
1763   ToolkitTestApplication application;
1764   tet_infoline(" utcDaliTextFieldInputStyleChanged02");
1765
1766   // Load some fonts.
1767
1768   char* pathNamePtr = get_current_dir_name();
1769   const std::string pathName( pathNamePtr );
1770   free( pathNamePtr );
1771
1772   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1773   fontClient.SetDpi( 93u, 93u );
1774
1775   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif.ttf", DEFAULT_FONT_SIZE );
1776   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif-Bold.ttf", DEFAULT_FONT_SIZE );
1777
1778   TextField field = TextField::New();
1779   DALI_TEST_CHECK( field );
1780
1781   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1782   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1783   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1784
1785   field.SetProperty( TextField::Property::ENABLE_MARKUP, true );
1786   field.SetProperty( TextField::Property::TEXT, "<font family='DejaVuSerif' size='18'>He<color value='blue'> l</color><color value='green'>lo</color> <font weight='bold'>world</font> demo</font>" );
1787
1788   // connect to the text changed signal.
1789   ConnectionTracker* testTracker = new ConnectionTracker();
1790   field.InputStyleChangedSignal().Connect( &TestInputStyleChangedCallback );
1791   bool inputStyleChangedSignal = false;
1792   field.ConnectSignal( testTracker, "inputStyleChanged",   CallbackFunctor(&inputStyleChangedSignal) );
1793
1794   application.GetScene().Add( field );
1795
1796   // Render and notify
1797   application.SendNotification();
1798   application.Render();
1799
1800   // Executes the idle callbacks added by the text control on the change of input style.
1801   application.RunIdles();
1802
1803   gInputStyleChangedCallbackCalled = false;
1804   gInputStyleMask = TextField::InputStyle::NONE;
1805   inputStyleChangedSignal = false;
1806
1807   // Create a tap event to touch the text field.
1808   TestGenerateTap( application, 53.0f, 25.0f, 100 );
1809   TestGenerateTap( application, 53.0f, 25.0f, 200 );
1810
1811   // Render and notify
1812   application.SendNotification();
1813   application.Render();
1814
1815   // Executes the idle callbacks added by the text control on the change of input style.
1816   application.RunIdles();
1817
1818   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1819   if( gInputStyleChangedCallbackCalled )
1820   {
1821     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1822                       static_cast<unsigned int>( TextField::InputStyle::FONT_FAMILY |
1823                                                  TextField::InputStyle::POINT_SIZE  |
1824                                                  TextField::InputStyle::COLOR ),
1825                       TEST_LOCATION );
1826
1827     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1828     DALI_TEST_EQUALS( color, Color::GREEN, TEST_LOCATION );
1829
1830     const std::string fontFamily = field.GetProperty( TextField::Property::INPUT_FONT_FAMILY ).Get<std::string>();
1831     DALI_TEST_EQUALS( fontFamily, "DejaVuSerif", TEST_LOCATION );
1832
1833     const float pointSize = field.GetProperty( TextField::Property::INPUT_POINT_SIZE ).Get<float>();
1834     DALI_TEST_EQUALS( pointSize, 18.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1835   }
1836   DALI_TEST_CHECK( inputStyleChangedSignal );
1837
1838   gInputStyleChangedCallbackCalled = false;
1839   gInputStyleMask = TextField::InputStyle::NONE;
1840   inputStyleChangedSignal = false;
1841
1842   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1843
1844   // Render and notify
1845   application.SendNotification();
1846   application.Render();
1847
1848   // Executes the idle callbacks added by the text control on the change of input style.
1849   application.RunIdles();
1850
1851   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1852   if( gInputStyleChangedCallbackCalled )
1853   {
1854     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1855                       static_cast<unsigned int>( TextField::InputStyle::COLOR ),
1856                       TEST_LOCATION );
1857
1858     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1859     DALI_TEST_EQUALS( color, Color::BLUE, TEST_LOCATION );
1860   }
1861   DALI_TEST_CHECK( inputStyleChangedSignal );
1862
1863   gInputStyleChangedCallbackCalled = false;
1864   gInputStyleMask = TextField::InputStyle::NONE;
1865   inputStyleChangedSignal = false;
1866
1867   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1868
1869   // Render and notify
1870   application.SendNotification();
1871   application.Render();
1872
1873   // Executes the idle callbacks added by the text control on the change of input style.
1874   application.RunIdles();
1875
1876   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1877   DALI_TEST_CHECK( !inputStyleChangedSignal );
1878
1879   gInputStyleChangedCallbackCalled = false;
1880   gInputStyleMask = TextField::InputStyle::NONE;
1881   inputStyleChangedSignal = false;
1882
1883   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1884
1885   // Render and notify
1886   application.SendNotification();
1887   application.Render();
1888
1889   // Executes the idle callbacks added by the text control on the change of input style.
1890   application.RunIdles();
1891
1892   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1893   if( gInputStyleChangedCallbackCalled )
1894   {
1895     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1896                       static_cast<unsigned int>( TextField::InputStyle::COLOR ),
1897                       TEST_LOCATION );
1898
1899     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1900     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1901   }
1902   DALI_TEST_CHECK( inputStyleChangedSignal );
1903
1904   gInputStyleChangedCallbackCalled = false;
1905   gInputStyleMask = TextField::InputStyle::NONE;
1906   inputStyleChangedSignal = false;
1907
1908   field.SetProperty( TextField::Property::INPUT_COLOR, Color::YELLOW );
1909
1910   Property::Map fontStyleMapSet;
1911   fontStyleMapSet.Insert( "weight", "thin" );
1912   fontStyleMapSet.Insert( "width", "condensed" );
1913   fontStyleMapSet.Insert( "slant", "italic" );
1914
1915   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
1916   field.SetProperty( TextField::Property::INPUT_POINT_SIZE, 20.f );
1917
1918   field.SetProperty( TextField::Property::INPUT_UNDERLINE, "underline" );
1919   field.SetProperty( TextField::Property::INPUT_SHADOW, "shadow" );
1920   field.SetProperty( TextField::Property::INPUT_EMBOSS, "emboss" );
1921   field.SetProperty( TextField::Property::INPUT_OUTLINE, "outline" );
1922
1923   // Render and notify
1924   application.SendNotification();
1925   application.Render();
1926
1927   // Executes the idle callbacks added by the text control on the change of input style.
1928   application.RunIdles();
1929
1930   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1931   DALI_TEST_CHECK( !inputStyleChangedSignal );
1932
1933   // Create a tap event to touch the text field.
1934   TestGenerateTap( application, 63.0f, 25.0f, 700 );
1935
1936   // Render and notify
1937   application.SendNotification();
1938   application.Render();
1939
1940   // Executes the idle callbacks added by the text control on the change of input style.
1941   application.RunIdles();
1942
1943   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1944   if( gInputStyleChangedCallbackCalled )
1945   {
1946     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1947                       static_cast<unsigned int>( TextField::InputStyle::COLOR |
1948                                                  TextField::InputStyle::POINT_SIZE |
1949                                                  TextField::InputStyle::FONT_STYLE |
1950                                                  TextField::InputStyle::UNDERLINE |
1951                                                  TextField::InputStyle::SHADOW |
1952                                                  TextField::InputStyle::EMBOSS |
1953                                                  TextField::InputStyle::OUTLINE ),
1954                       TEST_LOCATION );
1955
1956     const Vector4 color = field.GetProperty( TextField::Property::INPUT_COLOR ).Get<Vector4>();
1957     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1958   }
1959   DALI_TEST_CHECK( inputStyleChangedSignal );
1960
1961   END_TEST;
1962 }
1963
1964 int utcDaliTextFieldEvent01(void)
1965 {
1966   ToolkitTestApplication application;
1967   tet_infoline(" utcDaliTextFieldEvent01");
1968
1969   // Creates a tap event. After creating a tap event the text field should
1970   // have the focus and add text with key events should be possible.
1971
1972   TextField field = TextField::New();
1973   DALI_TEST_CHECK( field );
1974
1975   application.GetScene().Add( field );
1976
1977   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1978   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1979   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1980
1981   // Render and notify
1982   application.SendNotification();
1983   application.Render();
1984
1985   // Avoid a crash when core load gl resources.
1986   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1987
1988   // Render and notify
1989   application.SendNotification();
1990   application.Render();
1991
1992   // Add a key event but as the text field has not the focus it should do nothing.
1993   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1994
1995   // Render and notify
1996   application.SendNotification();
1997   application.Render();
1998
1999   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string(""), TEST_LOCATION );
2000
2001   // Create a tap event to touch the text field.
2002   TestGenerateTap( application, 150.0f, 25.0f );
2003
2004   // Render and notify
2005   application.SendNotification();
2006   application.Render();
2007
2008   // Pressing delete key should be fine even if there is no text in TextField.
2009   application.ProcessEvent( GenerateKey( "Delete", "", "Delete", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2010   // Render and notify
2011   application.SendNotification();
2012   application.Render();
2013
2014   // Now the text field has the focus, so it can handle the key events.
2015   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2016   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2017
2018   // Render and notify
2019   application.SendNotification();
2020   application.Render();
2021
2022   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("aa"), TEST_LOCATION );
2023
2024   // Create a second text field and send key events to it.
2025   TextField field2 = TextField::New();
2026
2027   field2.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2028   field2.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2029   field2.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 100.f ) );
2030   field2.SetProperty( Actor::Property::POSITION, Vector2( 100.0f, 100.0f ));
2031
2032   application.GetScene().Add( field2 );
2033
2034   // Render and notify
2035   application.SendNotification();
2036   application.Render();
2037
2038   // Create a tap event on the second text field.
2039   TestGenerateTap( application, 150.0f, 125.0f );
2040
2041   // Render and notify
2042   application.SendNotification();
2043   application.Render();
2044
2045   // The second text field has the focus. It should handle the key events.
2046   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2047   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2048
2049   // Render and notify
2050   application.SendNotification();
2051   application.Render();
2052
2053   // Check the text has been added to the second text field.
2054   DALI_TEST_EQUALS( field2.GetProperty<std::string>( TextField::Property::TEXT ), std::string("aa"), TEST_LOCATION );
2055
2056   END_TEST;
2057 }
2058
2059 int utcDaliTextFieldEvent02(void)
2060 {
2061   ToolkitTestApplication application;
2062   tet_infoline(" utcDaliTextFieldEvent02");
2063
2064   // Checks if the right number of actors are created.
2065
2066   TextField field = TextField::New();
2067   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2068   DALI_TEST_CHECK( field );
2069   LoadMarkerImages(application, field);
2070
2071   application.GetScene().Add( field );
2072
2073   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2074   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2075   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2076
2077   // Avoid a crash when core load gl resources.
2078   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2079
2080   // Render and notify
2081   application.SendNotification();
2082   application.Render();
2083
2084   // Check there are the expected number of children ( stencil ).
2085   DALI_TEST_EQUALS( field.GetChildCount(), 1u, TEST_LOCATION );
2086
2087   Actor stencil = field.GetChildAt( 0u );
2088   DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
2089
2090   // Create a tap event to touch the text field.
2091   TestGenerateTap( application, 150.0f, 25.0f, 300 );
2092
2093   // Render and notify
2094   application.SendNotification();
2095   application.Render();
2096
2097   Actor layer = field.GetChildAt( 1u );
2098   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
2099   DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
2100
2101   // Now the text field has the focus, so it can handle the key events.
2102   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2103   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2104
2105   // Render and notify
2106   application.SendNotification();
2107   application.Render();
2108
2109   // Checks the cursor and the renderer have been created.
2110   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
2111   DALI_TEST_EQUALS( stencil.GetChildCount(), 1u, TEST_LOCATION ); // The renderer
2112
2113   Control cursor = Control::DownCast( layer.GetChildAt( 0u ) );
2114   DALI_TEST_CHECK( cursor );
2115
2116   // The offscreen root actor has a container with all the actors which contain the text renderers.
2117   Actor container = stencil.GetChildAt( 0u );
2118   for( unsigned int index = 0; index < container.GetChildCount(); ++index )
2119   {
2120     Renderer renderer = container.GetChildAt( index ).GetRendererAt( 0u );
2121     DALI_TEST_CHECK( renderer );
2122   }
2123
2124   // Move the cursor and check the position changes.
2125   Vector3 position1 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2126   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2127
2128   // Render and notify
2129   application.SendNotification();
2130   application.Render();
2131
2132   Vector3 position2 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2133   DALI_TEST_CHECK( position2.x < position1.x );
2134
2135   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2136
2137   // Render and notify
2138   application.SendNotification();
2139   application.Render();
2140
2141   Vector3 position3 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2142   DALI_TEST_EQUALS( position1, position3, TEST_LOCATION ); // Should be in the same position1.
2143
2144
2145   // Move the cursor to the first position.
2146   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2147   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2148
2149   // Render and notify
2150   application.SendNotification();
2151   application.Render();
2152
2153   Vector3 position4 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2154
2155   // Send some taps and check the cursor positions.
2156
2157   // Try to tap at the beginning.
2158   TestGenerateTap( application, 1.0f, 25.0f, 900 );
2159
2160   // Render and notify
2161   application.SendNotification();
2162   application.Render();
2163
2164   // Cursor position should be the same than position1.
2165   Vector3 position5 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2166
2167   DALI_TEST_EQUALS( position4, position5, TEST_LOCATION ); // Should be in the same position2.
2168
2169   // Tap away from the start position.
2170   TestGenerateTap( application, 16.0f, 25.0f, 1500 );
2171
2172   // Render and notify
2173   application.SendNotification();
2174   application.Render();
2175
2176   Vector3 position6 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2177
2178   DALI_TEST_CHECK( position6.x > position5.x );
2179
2180   // Remove all the text.
2181   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2182   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2183   field.SetProperty( TextField::Property::TEXT, "" );
2184
2185   // Render and notify
2186   application.SendNotification();
2187   application.Render();
2188
2189   // Cursor position should be the same than position2.
2190   Vector3 position7 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
2191
2192   DALI_TEST_EQUALS( position4, position7, TEST_LOCATION );// Should be in the same position2.
2193
2194   // Should not be a renderer.
2195   DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
2196
2197   // Chanege exceed policy (EXCEED_POLICY_ORIGINAL doesn't use stencil )
2198   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
2199   field.SetProperty( TextField::Property::EXCEED_POLICY, Dali::Toolkit::TextField::EXCEED_POLICY_ORIGINAL );
2200
2201   application.SendNotification();
2202   application.Render();
2203
2204   // There are renderer and decorator layer
2205   DALI_TEST_EQUALS( field.GetChildCount(), 2u, TEST_LOCATION );
2206
2207   END_TEST;
2208 }
2209
2210 int utcDaliTextFieldEvent03(void)
2211 {
2212   ToolkitTestApplication application;
2213   tet_infoline(" utcDaliTextFieldEvent03");
2214
2215   // Checks if the highlight actor is created.
2216
2217   TextField field = TextField::New();
2218   DALI_TEST_CHECK( field );
2219
2220   application.GetScene().Add( field );
2221
2222   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
2223   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2224   field.SetProperty( Actor::Property::SIZE, Vector2( 30.f, 50.f ) );
2225   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2226   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2227
2228   // Avoid a crash when core load gl resources.
2229   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2230   LoadMarkerImages(application, field);
2231
2232   // Render and notify
2233   application.SendNotification();
2234   application.Render();
2235
2236   // Tap first to get the focus.
2237   TestGenerateTap( application, 3.0f, 25.0f );
2238
2239   // Render and notify
2240   application.SendNotification();
2241   application.Render();
2242
2243   // Double tap to select a word.
2244   TestGenerateTap( application, 3.0f, 25.0f );
2245
2246   // Render and notify
2247   application.SendNotification();
2248   application.Render();
2249
2250   // The offscreen root actor should have two actors: the renderer and the highlight actor.
2251   Actor stencil = field.GetChildAt( 0u );
2252
2253   // The highlight actor is drawn first, so is the first actor in the list
2254   Renderer highlight = stencil.GetChildAt( 0u ).GetRendererAt( 0u );
2255   DALI_TEST_CHECK( highlight );
2256
2257   // The offscreen root actor has a container with all the actors which contain the text renderers.
2258   Actor container = stencil.GetChildAt( 1u );
2259   for( unsigned int index = 0; index < container.GetChildCount(); ++index )
2260   {
2261     Renderer renderer = container.GetChildAt( index ).GetRendererAt( 0u );
2262     DALI_TEST_CHECK( renderer );
2263   }
2264
2265   END_TEST;
2266 }
2267
2268 int utcDaliTextFieldEvent04(void)
2269 {
2270   ToolkitTestApplication application;
2271   tet_infoline(" utcDaliTextFieldEvent04");
2272
2273   // Checks if the highlight actor is created.
2274
2275   TextField field = TextField::New();
2276   DALI_TEST_CHECK( field );
2277   application.GetScene().Add( field );
2278   LoadMarkerImages(application, field);
2279   // Render and notify
2280   application.SendNotification();
2281   application.Render();
2282
2283   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
2284   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2285   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2286   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2287   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2288
2289   // Avoid a crash when core load gl resources.
2290   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2291   // Render and notify
2292   application.SendNotification();
2293   application.Render();
2294
2295   // Create a tap event to touch the text field.
2296   TestGenerateTap( application, 150.0f, 25.0f );
2297   // Render and notify
2298   application.SendNotification();
2299   application.Render();
2300
2301
2302   // Tap first to get the focus.
2303   TestGenerateTap( application, 1.0f, 25.0f );
2304
2305   // Render and notify
2306   application.SendNotification();
2307   application.Render();
2308
2309   // Double tap to select a word.
2310   TestGenerateTap( application, 1.0f, 25.0f );
2311
2312   // Render and notify
2313   application.SendNotification();
2314   application.Render();
2315
2316   // Tap grab handle
2317   TestGenerateTap( application, 0.0f, 40.0f );
2318   END_TEST;
2319 }
2320
2321 int utcDaliTextFieldEvent05(void)
2322 {
2323   ToolkitTestApplication application;
2324   tet_infoline(" utcDaliTextFieldEvent05");
2325
2326   // Checks dragging of cursor/grab handle
2327
2328   TextField field = TextField::New();
2329   DALI_TEST_CHECK( field );
2330   application.GetScene().Add( field );
2331   LoadMarkerImages(application, field);
2332   // Render and notify
2333   application.SendNotification();
2334   application.Render();
2335
2336   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
2337   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2338   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2339   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2340   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2341
2342   // Avoid a crash when core load gl resources.
2343   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2344   // Render and notify
2345   application.SendNotification();
2346   application.Render();
2347
2348   // Create a tap event to touch the text field.
2349   TestGenerateTap( application, 150.0f, 25.0f );
2350   // Render and notify
2351   application.SendNotification();
2352   application.Render();
2353
2354   // Tap first to get the focus.
2355   TestGenerateTap( application, 1.0f, 25.0f );
2356
2357   // Render and notify
2358   application.SendNotification();
2359   application.Render();
2360
2361   // Double tap to select a word.
2362   TestGenerateTap( application, 1.0f, 25.0f );
2363
2364   // Render and notify
2365   application.SendNotification();
2366   application.Render();
2367
2368   Actor stencil = field.GetChildAt( 1u );
2369   END_TEST;
2370 }
2371
2372 int utcDaliTextFieldEvent06(void)
2373 {
2374   ToolkitTestApplication application;
2375   tet_infoline(" utcDaliTextFieldEvent06");
2376
2377   // Checks Longpress when in edit mode
2378
2379   TextField field = TextField::New();
2380   DALI_TEST_CHECK( field );
2381   application.GetScene().Add( field );
2382   LoadMarkerImages(application, field);
2383   // Render and notify
2384   application.SendNotification();
2385   application.Render();
2386
2387   field.SetProperty( TextField::Property::TEXT, "Thisisalongtextforthesizeofthetextfield." );
2388   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2389   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2390   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2391   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2392
2393   // Avoid a crash when core load gl resources.
2394   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2395   // Render and notify
2396   application.SendNotification();
2397   application.Render();
2398
2399   // Create a tap event to touch the text field.
2400   TestGenerateTap( application, 150.0f, 25.0f );
2401   // Render and notify
2402   application.SendNotification();
2403   application.Render();
2404
2405
2406   // Tap first to get the focus.
2407   TestGenerateTap( application, 1.0f, 25.0f );
2408
2409   // Render and notify
2410   application.SendNotification();
2411   application.Render();
2412
2413   // Long Press
2414   TestGenerateLongPress(application, 1.0f, 25.0f);
2415
2416   // Render and notify
2417   application.SendNotification();
2418   application.Render();
2419
2420   END_TEST;
2421 }
2422
2423 int utcDaliTextFieldEvent07(void)
2424 {
2425   ToolkitTestApplication application;
2426   tet_infoline(" utcDaliTextFieldEvent07");
2427
2428   // Checks Longpress to start edit mode
2429
2430   TextField field = TextField::New();
2431   DALI_TEST_CHECK( field );
2432   application.GetScene().Add( field );
2433   LoadMarkerImages(application, field);
2434   // Render and notify
2435   application.SendNotification();
2436   application.Render();
2437
2438   field.SetProperty( TextField::Property::TEXT, "Thisisalongtextforthesizeofthetextfield." );
2439   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2440   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2441   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2442   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2443   Property::Map propertyMap;
2444   propertyMap["PANEL_LAYOUT"] = InputMethod::PanelLayout::PASSWORD;
2445   field.SetProperty( TextField::Property::INPUT_METHOD_SETTINGS, propertyMap );
2446
2447   // Avoid a crash when core load gl resources.
2448   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2449   // Render and notify
2450   application.SendNotification();
2451   application.Render();
2452
2453   // Long Press
2454   TestGenerateLongPress(application, 1.0f, 25.0f);
2455
2456   // Render and notify
2457   application.SendNotification();
2458   application.Render();
2459
2460   END_TEST;
2461 }
2462
2463 int utcDaliTextFieldEvent08(void)
2464 {
2465   ToolkitTestApplication application;
2466   tet_infoline(" utcDaliTextFieldEvent08");
2467
2468   Dali::Clipboard clipboard = Clipboard::Get();
2469   clipboard.SetItem("testTextFieldEvent");
2470
2471   // Checks Longpress when only place holder text
2472
2473   TextField field = TextField::New();
2474   DALI_TEST_CHECK( field );
2475   application.GetScene().Add( field );
2476   LoadMarkerImages(application, field);
2477   // Render and notify
2478   application.SendNotification();
2479   application.Render();
2480
2481   field.SetProperty( TextField::Property::PLACEHOLDER_TEXT, "Setting Placeholder Text" );
2482   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2483   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2484   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2485   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2486
2487   // Avoid a crash when core load gl resources.
2488   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2489   // Render and notify
2490   application.SendNotification();
2491   application.Render();
2492
2493   // Long Press
2494   TestGenerateLongPress( application, 1.0f, 25.0f, 20 );
2495
2496   // Render and notify
2497   application.SendNotification();
2498   application.Render();
2499
2500   Wait(application, 500);
2501
2502   TestEndLongPress( application, 1.0f, 25.0f, 520 );
2503
2504   // Long Press
2505   TestGenerateLongPress( application, 1.0f, 25.0f, 600 );
2506
2507   // Render and notify
2508   application.Render();
2509
2510   Wait(application, 500);
2511
2512   Integration::Scene stage = application.GetScene();
2513   Layer layer = stage.GetRootLayer();
2514   Actor actor = layer.FindChildByName("optionPaste");
2515
2516   if (actor)
2517   {
2518     Vector3 worldPosition = actor.GetCurrentProperty< Vector3 >( Actor::Property::WORLD_POSITION );
2519     Vector2 halfStageSize = stage.GetSize() / 2.0f;
2520     Vector2 position(worldPosition.x + halfStageSize.width, worldPosition.y + halfStageSize.height);
2521
2522     Dali::Integration::TouchEvent event;
2523     event = Dali::Integration::TouchEvent();
2524     event.AddPoint( GetPointDownInside( position ) );
2525     application.ProcessEvent( event );
2526
2527     event = Dali::Integration::TouchEvent();
2528     event.AddPoint( GetPointUpInside( position ) );
2529     application.ProcessEvent( event );
2530   }
2531   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("testTextFieldEvent"), TEST_LOCATION );
2532
2533   END_TEST;
2534 }
2535
2536 int utcDaliTextFieldEvent09(void)
2537 {
2538   ToolkitTestApplication application;
2539   tet_infoline(" utcDaliTextFieldEvent09");
2540
2541   TextField field = TextField::New();
2542   DALI_TEST_CHECK( field );
2543   application.GetScene().Add( field );
2544   LoadMarkerImages(application, field);
2545   // Render and notify
2546   application.SendNotification();
2547   application.Render();
2548
2549   field.SetProperty( TextField::Property::TEXT, "Hello" );
2550   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2551   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2552   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2553   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2554
2555   // Avoid a crash when core load gl resources.
2556   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2557
2558   // Create a tap event to touch the text field.
2559   TestGenerateTap( application, 150.0f, 25.0f );
2560   application.SendNotification();
2561   application.Render();
2562
2563   Property::Map map;
2564   map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_NONE;
2565   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2566   application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2567   application.SendNotification();
2568   application.Render();
2569
2570   map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_ALL;
2571   map[ HiddenInput::Property::SUBSTITUTE_CHARACTER ] = 0x23;
2572   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2573   application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2574   application.SendNotification();
2575   application.Render();
2576
2577   map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::HIDE_COUNT;
2578   map[ HiddenInput::Property::SUBSTITUTE_COUNT ] = 2;
2579   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2580   for( unsigned int index = 0u; index < 5u; ++index )
2581   {
2582     application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2583     application.SendNotification();
2584     application.Render();
2585   }
2586
2587   map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::SHOW_COUNT;
2588   map[ HiddenInput::Property::SUBSTITUTE_COUNT ] = 2;
2589   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2590   for( unsigned int index = 0u; index < 5u; ++index )
2591   {
2592     application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2593     application.SendNotification();
2594     application.Render();
2595   }
2596
2597   map[ HiddenInput::Property::MODE ] = HiddenInput::Mode::SHOW_LAST_CHARACTER;
2598   map[ HiddenInput::Property::SHOW_LAST_CHARACTER_DURATION ] = 0;
2599   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2600   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2601   application.SendNotification();
2602   application.Render();
2603   application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2604   application.SendNotification();
2605   application.Render();
2606
2607   map[ HiddenInput::Property::SHOW_LAST_CHARACTER_DURATION ] = 100;
2608   field.SetProperty( TextField::Property::HIDDEN_INPUT_SETTINGS, map );
2609   application.ProcessEvent( GenerateKey( "d", "", "d", 0, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2610   application.SendNotification();
2611   application.Render();
2612
2613   Property::Map mapGet;
2614   mapGet = field.GetProperty<Property::Map>( TextField::Property::HIDDEN_INPUT_SETTINGS );
2615   DALI_TEST_EQUALS( map.Count(), mapGet.Count(), TEST_LOCATION );
2616   DALI_TEST_EQUALS( DaliTestCheckMaps( map, mapGet ), true, TEST_LOCATION );
2617   END_TEST;
2618 }
2619
2620
2621 int utcDaliTextFieldStyleWhilstSelected(void)
2622 {
2623   ToolkitTestApplication application;
2624   tet_infoline(" utcDaliTextFieldStyleWhilstSelected");
2625
2626   // Change font and styles whilst text is selected whilst word selected
2627
2628   TextField field = TextField::New();
2629   DALI_TEST_CHECK( field );
2630   application.GetScene().Add( field );
2631   LoadMarkerImages(application, field);
2632   // Render and notify
2633   application.SendNotification();
2634   application.Render();
2635
2636   field.SetProperty( TextField::Property::TEXT, "This is a long text for the size of the text-field." );
2637   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2638   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2639   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2640   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2641
2642   // Avoid a crash when core load gl resources.
2643   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2644   // Render and notify
2645   application.SendNotification();
2646   application.Render();
2647
2648   // Create a tap event to touch the text field.
2649   TestGenerateTap( application, 150.0f, 25.0f );
2650   // Render and notify
2651   application.SendNotification();
2652   application.Render();
2653
2654
2655   // Tap first to get the focus.
2656   TestGenerateTap( application, 1.0f, 25.0f );
2657
2658   // Render and notify
2659   application.SendNotification();
2660   application.Render();
2661
2662   // Double tap to select a word.
2663   TestGenerateTap( application, 1.0f, 25.0f );
2664
2665   // Render and notify
2666   application.SendNotification();
2667   application.Render();
2668
2669   field.SetProperty( TextField::Property::INPUT_FONT_FAMILY, "Setting input font family" );
2670   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::INPUT_FONT_FAMILY ), "Setting input font family", TEST_LOCATION );
2671
2672   Property::Map fontStyleMapSet;
2673   Property::Map fontStyleMapGet;
2674
2675   fontStyleMapSet.Insert( "weight", "bold" );
2676   fontStyleMapSet.Insert( "slant", "italic" );
2677   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
2678
2679   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
2680   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
2681   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
2682
2683   fontStyleMapSet.Clear();
2684   fontStyleMapSet.Insert( "width", "expanded" );
2685   fontStyleMapSet.Insert( "slant", "italic" );
2686   field.SetProperty( TextField::Property::INPUT_FONT_STYLE, fontStyleMapSet );
2687
2688   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::INPUT_FONT_STYLE );
2689   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
2690   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
2691
2692   field.SetProperty( TextField::Property::INPUT_POINT_SIZE, 12.f );
2693   DALI_TEST_EQUALS( field.GetProperty<float>( TextField::Property::INPUT_POINT_SIZE ), 12.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2694
2695   field.SetProperty( TextField::Property::TEXT_COLOR, Color::RED );
2696   DALI_TEST_EQUALS( field.GetProperty<Vector4>( TextField::Property::TEXT_COLOR ), Color::RED, TEST_LOCATION );
2697
2698   fontStyleMapSet.Clear();
2699   fontStyleMapSet.Insert( "weight", "bold" );
2700   fontStyleMapSet.Insert( "slant", "italic" );
2701
2702   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
2703
2704   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
2705   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
2706   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
2707
2708   fontStyleMapSet.Clear();
2709   fontStyleMapSet.Insert( "width", "expanded" );
2710
2711   field.SetProperty( TextField::Property::FONT_STYLE, fontStyleMapSet );
2712
2713   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
2714   DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
2715   DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
2716
2717   // Press Escape to increase coverage
2718   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::UP, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2719   application.SendNotification();
2720   application.Render();
2721
2722   DALI_TEST_CHECK( !field.HasKeyInputFocus() );
2723
2724   END_TEST;
2725 }
2726
2727 int utcDaliTextFieldEscKeyLoseFocus(void)
2728 {
2729   ToolkitTestApplication application;
2730   tet_infoline(" utcDaliTextFieldEscKeyLoseFocus");
2731
2732   // Creates a tap event. After creating a tap event the text field should
2733   // have the focus and add text with key events should be possible.
2734
2735   TextField field = TextField::New();
2736   DALI_TEST_CHECK( field );
2737
2738   application.GetScene().Add( field );
2739
2740   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2741   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2742   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2743
2744   // Avoid a crash when core load gl resources.
2745   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2746
2747   // Render and notify
2748   application.SendNotification();
2749   application.Render();
2750
2751   // Add a key event but as the text field has not the focus it should do nothing.
2752   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2753   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2754
2755   // Render and notify
2756   application.SendNotification();
2757   application.Render();
2758
2759   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string(""), TEST_LOCATION );
2760
2761   // Create a tap event to touch the text field.
2762   TestGenerateTap( application, 150.0f, 25.0f );
2763
2764   // Render and notify
2765   application.SendNotification();
2766   application.Render();
2767
2768   // Now the text field has the focus, so it can handle the key events.
2769   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2770   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2771   application.ProcessEvent( GenerateKey( "d", "", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2772   application.ProcessEvent( GenerateKey( "d", "", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::UP, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2773
2774   // Render and notify
2775   application.SendNotification();
2776   application.Render();
2777
2778   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("ad"), TEST_LOCATION );
2779
2780   // Generate a Esc key event. The text field should lose the focus.
2781   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2782   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::UP, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2783
2784   // Render and notify
2785   application.SendNotification();
2786   application.Render();
2787
2788   DALI_TEST_EQUALS( false, field.HasKeyInputFocus(), TEST_LOCATION );
2789
2790   // No more text should be introduced
2791   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2792   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::UP, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2793
2794   // Render and notify
2795   application.SendNotification();
2796   application.Render();
2797
2798   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), std::string("ad"), TEST_LOCATION );
2799
2800   END_TEST;
2801 }
2802
2803 int utcDaliTextFieldSomeSpecialKeys(void)
2804 {
2805   ToolkitTestApplication application;
2806   tet_infoline(" utcDaliTextFieldSomeSpecialKeys");
2807
2808   // Checks some special keys when the text is selected.
2809
2810   TextField field = TextField::New();
2811   DALI_TEST_CHECK( field );
2812   application.GetScene().Add( field );
2813   LoadMarkerImages(application, field);
2814   // Render and notify
2815   application.SendNotification();
2816   application.Render();
2817
2818   const std::string longText( "This is a long text for the size of the text-field." );
2819
2820   field.SetProperty( TextField::Property::TEXT, longText );
2821   field.SetProperty( TextField::Property::POINT_SIZE, 10.f );
2822   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2823   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2824   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2825
2826   // Avoid a crash when core load gl resources.
2827   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2828   // Render and notify
2829   application.SendNotification();
2830   application.Render();
2831
2832   // Create a tap event to touch the text field.
2833   TestGenerateTap( application, 150.0f, 25.0f );
2834
2835   // Render and notify
2836   application.SendNotification();
2837   application.Render();
2838
2839   // Tap first to get the focus.
2840   TestGenerateTap( application, 1.0f, 25.0f );
2841
2842   // Render and notify
2843   application.SendNotification();
2844   application.Render();
2845
2846   // Double tap to select a word.
2847   TestGenerateTap( application, 1.0f, 25.0f );
2848
2849   // Render and notify
2850   application.SendNotification();
2851   application.Render();
2852
2853   // Generate a Esc key event. The text field should lose the focus.
2854   application.ProcessEvent( GenerateKey( "XF86PowerOff", "", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::DOWN, "XF86PowerOff", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2855   application.ProcessEvent( GenerateKey( "XF86PowerOff", "", "XF86PowerOff", DALI_KEY_POWER, 0, 0, Integration::KeyEvent::UP, "XF86PowerOff", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2856
2857   // Render and notify
2858   application.SendNotification();
2859   application.Render();
2860
2861   // Generate a Esc key event. The text field should lose the focus.
2862   application.ProcessEvent( GenerateKey( "XF86Menu", "", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::DOWN, "XF86Menu", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2863   application.ProcessEvent( GenerateKey( "XF86Menu", "", "XF86Menu", DALI_KEY_MENU, 0, 0, Integration::KeyEvent::UP, "XF86Menu", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2864
2865   // Render and notify
2866   application.SendNotification();
2867   application.Render();
2868
2869   // Generate a Esc key event. The text field should lose the focus.
2870   application.ProcessEvent( GenerateKey( "XF86Home", "", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::DOWN, "XF86Home", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2871   application.ProcessEvent( GenerateKey( "XF86Home", "", "XF86Home", DALI_KEY_HOME, 0, 0, Integration::KeyEvent::UP, "XF86Home", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2872
2873   // Render and notify
2874   application.SendNotification();
2875   application.Render();
2876
2877   // The text shouldn't be deleted.
2878   DALI_TEST_EQUALS( field.GetProperty<std::string>( TextField::Property::TEXT ), longText, TEST_LOCATION );
2879
2880   END_TEST;
2881 }
2882
2883 int utcDaliTextFieldSizeUpdate(void)
2884 {
2885   ToolkitTestApplication application;
2886   tet_infoline("utcDaliTextFieldSizeUpdate");
2887
2888   // Checks some special keys when the text is selected.
2889   TextField field = TextField::New();
2890   DALI_TEST_CHECK( field );
2891   application.GetScene().Add( field );
2892
2893   float previousHeight = 0.0f;
2894   float currentHeight = 0.0f;
2895   const float fieldWidth = 1920.0f;
2896
2897
2898   // "ㅁ" is bigger then "ኢ"
2899   field.SetProperty( Actor::Property::SIZE, Vector2( fieldWidth ,10.0f ) );
2900   field.SetResizePolicy( ResizePolicy::FIXED , Dimension::WIDTH );
2901   field.SetResizePolicy( ResizePolicy::DIMENSION_DEPENDENCY , Dimension::HEIGHT );
2902
2903   field.SetProperty( TextField::Property::TEXT, "ኢ");
2904   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2905   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2906
2907   field.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
2908   KeyboardFocusManager::Get().SetCurrentFocusActor( field );
2909
2910   application.SendNotification();
2911   application.Render();
2912
2913   previousHeight = field.GetHeightForWidth( fieldWidth );
2914   DALI_TEST_EQUALS( previousHeight, field.GetProperty<float>( Actor::Property::SIZE_HEIGHT ) , TEST_LOCATION );
2915
2916   // Add  another script characters ( glyph height is defferent )
2917   application.ProcessEvent( GenerateKey( "ㅁ", "", "ㅁ", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "ㅁ", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2918   application.ProcessEvent( GenerateKey( "ㅁ", "", "ㅁ", KEY_A_CODE, 0, 0, Integration::KeyEvent::UP, "ㅁ", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2919
2920   application.SendNotification();
2921   application.Render();
2922
2923   currentHeight = field.GetHeightForWidth( fieldWidth );
2924   DALI_TEST_EQUALS( currentHeight, field.GetProperty<float>( Actor::Property::SIZE_HEIGHT ), TEST_LOCATION );
2925   DALI_TEST_EQUALS( (previousHeight < currentHeight), true , TEST_LOCATION );
2926
2927   END_TEST;
2928 }
2929
2930 int utcDaliTextFieldExtremlyLargePointSize(void)
2931 {
2932   ToolkitTestApplication application;
2933   tet_infoline(" utcDaliTextFieldExtremlyLargePointSize");
2934
2935   TextField field = TextField::New();
2936
2937   field.SetProperty( TextField::Property::TEXT, "Text" );
2938   field.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2939   field.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2940   field.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2941   application.GetScene().Add( field );
2942
2943   try
2944   {
2945     field.SetProperty( TextField::Property::POINT_SIZE, 160.0f );
2946     application.SendNotification();
2947     DALI_TEST_CHECK( field );
2948   }
2949   catch (...)
2950   {
2951     tet_result(TET_FAIL);
2952   }
2953   END_TEST;
2954 }
2955
2956 int UtcDaliTextFieldDefaultFontStylePropertyCoverage(void)
2957 {
2958   ToolkitTestApplication application;
2959   tet_infoline("UtcDaliTextFieldFontStylePorpertyCoverage");
2960   TextField field = TextField::New();
2961   DALI_TEST_CHECK( field );
2962   application.GetScene().Add( field );
2963
2964   Property::Map fontStyleMapGet;
2965
2966   fontStyleMapGet = field.GetProperty<Property::Map>( TextField::Property::FONT_STYLE );
2967
2968   Property::Value* weightValue = NULL;
2969   Property::Value* widthValue = NULL;
2970   Property::Value* slantValue = NULL;
2971   weightValue = fontStyleMapGet.Find( "weight" );
2972   widthValue = fontStyleMapGet.Find( "width" );
2973   slantValue = fontStyleMapGet.Find( "slant" );
2974   DALI_TEST_CHECK( !weightValue );
2975   DALI_TEST_CHECK( !widthValue );
2976   DALI_TEST_CHECK( !slantValue );
2977
2978   END_TEST;
2979 }
2980
2981 int UtcDaliTextFieldSettingPlaceholder(void)
2982 {
2983   ToolkitTestApplication application;
2984   tet_infoline("UtcDaliTextFieldSettingPlaceholder");
2985
2986   TextField field = TextField::New();
2987   DALI_TEST_CHECK( field );
2988   application.GetScene().Add( field );
2989
2990   // Check the placeholder property with pixel size
2991   Property::Map placeholderPixelSizeMapSet;
2992   Property::Map placeholderPixelSizeMapGet;
2993   Property::Map placeholderFontstyleMap;
2994   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::TEXT ] = "Setting Placeholder Text";
2995   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = "Setting Placeholder Text Focused";
2996   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::COLOR ] = Color::BLUE;
2997   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::FONT_FAMILY ] = "Arial";
2998   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::PIXEL_SIZE ] = 15.0f;
2999   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::ELLIPSIS ] = true;
3000
3001   placeholderFontstyleMap.Insert( "weight", "bold" );
3002   placeholderPixelSizeMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
3003   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderPixelSizeMapSet );
3004
3005   placeholderPixelSizeMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
3006   DALI_TEST_EQUALS( placeholderPixelSizeMapGet.Count(), placeholderPixelSizeMapSet.Count(), TEST_LOCATION );
3007   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderPixelSizeMapGet, placeholderPixelSizeMapSet ), true, TEST_LOCATION );
3008
3009   // Check the placeholder property with point size
3010   Property::Map placeholderMapSet;
3011   Property::Map placeholderMapGet;
3012   placeholderMapSet[ Text::PlaceHolder::Property::TEXT ] = "Setting Placeholder Text";
3013   placeholderMapSet[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = "Setting Placeholder Text Focused";
3014   placeholderMapSet[ Text::PlaceHolder::Property::COLOR ] = Color::RED;
3015   placeholderMapSet[ Text::PlaceHolder::Property::FONT_FAMILY ] = "Arial";
3016   placeholderMapSet[ Text::PlaceHolder::Property::POINT_SIZE ] = 12.0f;
3017   placeholderMapSet[ Text::PlaceHolder::Property::ELLIPSIS ] = false;
3018
3019   // Check the placeholder font style property
3020   placeholderFontstyleMap.Clear();
3021
3022   placeholderFontstyleMap.Insert( "weight", "bold" );
3023   placeholderFontstyleMap.Insert( "width", "condensed" );
3024   placeholderFontstyleMap.Insert( "slant", "italic" );
3025   placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
3026   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
3027
3028   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
3029   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
3030   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
3031
3032   // Reset font style.
3033   placeholderFontstyleMap.Clear();
3034   placeholderFontstyleMap.Insert( "weight", "normal" );
3035   placeholderFontstyleMap.Insert( "slant", "oblique" );
3036   placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
3037   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
3038
3039   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
3040   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
3041   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
3042
3043   placeholderFontstyleMap.Clear();
3044   placeholderFontstyleMap.Insert( "slant", "roman" );
3045   placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
3046   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
3047
3048   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
3049
3050   placeholderFontstyleMap.Clear();
3051   placeholderMapSet[ Text::PlaceHolder::Property::FONT_STYLE ] = placeholderFontstyleMap;
3052
3053   field.SetProperty( TextField::Property::PLACEHOLDER, placeholderMapSet );
3054   placeholderMapGet = field.GetProperty<Property::Map>( TextField::Property::PLACEHOLDER );
3055   DALI_TEST_EQUALS( placeholderMapGet.Count(), placeholderMapSet.Count(), TEST_LOCATION );
3056   DALI_TEST_EQUALS( DaliTestCheckMaps( placeholderMapGet, placeholderMapSet ), true, TEST_LOCATION );
3057