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