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