Unnecessary TextChanged callbacks are being called.
[platform/core/uifw/dali-toolkit.git] / automated-tests / src / dali-toolkit / utc-Dali-TextEditor.cpp
1 /*
2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  *
16  */
17
18 #include <iostream>
19 #include <stdlib.h>
20 #include <unistd.h>
21 #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   application.SendNotification();
968   application.Render();
969   DALI_TEST_CHECK( gTextChangedCallBackCalled );
970   DALI_TEST_CHECK( textChangedSignal );
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   application.SendNotification();
977   application.Render();
978   DALI_TEST_CHECK( gTextChangedCallBackCalled );
979
980   // Remove all text
981   editor.SetProperty( TextField::Property::TEXT, "" );
982   application.SendNotification();
983   application.Render();
984
985   // Pressing backspace key: TextChangedCallback should not be called when there is no text in texteditor.
986   gTextChangedCallBackCalled = false;
987   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
988   application.SendNotification();
989   application.Render();
990   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
991
992   // Pressing delete key: TextChangedCallback should not be called when there is no text in texteditor.
993   gTextChangedCallBackCalled = false;
994   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "Delete", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
995   application.SendNotification();
996   application.Render();
997   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
998
999   END_TEST;
1000 }
1001
1002 int utcDaliTextEditorTextChangedWithInputMethodContext(void)
1003 {
1004   ToolkitTestApplication application;
1005   tet_infoline(" utcDaliTextEditorTextChangedWithInputMethodContext");
1006   TextEditor editor = TextEditor::New();
1007   DALI_TEST_CHECK( editor );
1008
1009
1010   application.GetScene().Add( editor );
1011
1012   // connect to the text changed signal.
1013   ConnectionTracker* testTracker = new ConnectionTracker();
1014   editor.TextChangedSignal().Connect(&TestTextChangedCallback);
1015   bool textChangedSignal = false;
1016   editor.ConnectSignal( testTracker, "textChanged",   CallbackFunctor(&textChangedSignal) );
1017
1018
1019   // get InputMethodContext
1020   std::string text;
1021   InputMethodContext::EventData imfEvent;
1022   InputMethodContext inputMethodContext = DevelTextEditor::GetInputMethodContext( editor );
1023
1024   editor.SetKeyInputFocus();
1025   editor.SetProperty( DevelTextEditor::Property::ENABLE_EDITING, true );
1026
1027   // input text
1028   gTextChangedCallBackCalled = false;
1029   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "ㅎ", 0, 1 );
1030   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1031   application.SendNotification();
1032   application.Render();
1033   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1034   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("ㅎ"), TEST_LOCATION );
1035
1036   gTextChangedCallBackCalled = false;
1037   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "호", 0, 1 );
1038   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1039   application.SendNotification();
1040   application.Render();
1041   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1042   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("호"), TEST_LOCATION );
1043
1044   gTextChangedCallBackCalled = false;
1045   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "혿", 0, 1 );
1046   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1047   application.SendNotification();
1048   application.Render();
1049   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1050   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("혿"), TEST_LOCATION );
1051
1052   gTextChangedCallBackCalled = false;
1053   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "", 0, 1 );
1054   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1055   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1056
1057   imfEvent = InputMethodContext::EventData( InputMethodContext::COMMIT, "호", 0, 1 );
1058   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1059   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1060
1061   imfEvent = InputMethodContext::EventData( InputMethodContext::PRE_EDIT, "두", 1, 2 );
1062   inputMethodContext.EventReceivedSignal().Emit(inputMethodContext, imfEvent);
1063   DALI_TEST_CHECK( !gTextChangedCallBackCalled );
1064
1065   application.SendNotification();
1066   application.Render();
1067   DALI_TEST_CHECK( gTextChangedCallBackCalled );
1068   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("호두"), TEST_LOCATION );
1069
1070   END_TEST;
1071 }
1072
1073
1074 int utcDaliTextEditorInputStyleChanged01(void)
1075 {
1076   // The text-editor emits signals when the input style changes. These changes of style are
1077   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1078   // can't be emitted during the size negotiation as the callbacks may update the UI.
1079   // The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
1080   // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
1081   ToolkitTestApplication application;
1082   tet_infoline(" utcDaliTextEditorInputStyleChanged01");
1083
1084   // Load some fonts.
1085
1086   char* pathNamePtr = get_current_dir_name();
1087   const std::string pathName( pathNamePtr );
1088   free( pathNamePtr );
1089
1090   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1091   fontClient.SetDpi( 93u, 93u );
1092
1093   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif.ttf", DEFAULT_FONT_SIZE );
1094   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif-Bold.ttf", DEFAULT_FONT_SIZE );
1095
1096   TextEditor editor = TextEditor::New();
1097   DALI_TEST_CHECK( editor );
1098
1099
1100   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1101   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1102   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1103
1104   editor.SetProperty( TextEditor::Property::ENABLE_MARKUP, true );
1105   editor.SetProperty( TextEditor::Property::TEXT, "<font family='DejaVuSerif' size='18'>He<color value='green'>llo</color> <font weight='bold'>world</font> demo</font>" );
1106
1107   // connect to the text changed signal.
1108   ConnectionTracker* testTracker = new ConnectionTracker();
1109   editor.InputStyleChangedSignal().Connect( &TestInputStyleChangedCallback );
1110   bool inputStyleChangedSignal = false;
1111   editor.ConnectSignal( testTracker, "inputStyleChanged",   CallbackFunctor(&inputStyleChangedSignal) );
1112
1113   application.GetScene().Add( editor );
1114
1115   // Render and notify
1116   application.SendNotification();
1117   application.Render();
1118
1119   // Executes the idle callbacks added by the text control on the change of input style.
1120   application.RunIdles();
1121
1122   gInputStyleChangedCallbackCalled = false;
1123   gInputStyleMask = TextEditor::InputStyle::NONE;
1124   inputStyleChangedSignal = false;
1125
1126   // Create a tap event to touch the text editor.
1127   TestGenerateTap( application, 18.0f, 25.0f );
1128
1129   // Render and notify
1130   application.SendNotification();
1131   application.Render();
1132
1133   // Executes the idle callbacks added by the text control on the change of input style.
1134   application.RunIdles();
1135
1136   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1137   if( gInputStyleChangedCallbackCalled )
1138   {
1139     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextEditor::InputStyle::FONT_FAMILY | TextEditor::InputStyle::POINT_SIZE ), TEST_LOCATION );
1140
1141     const std::string fontFamily = editor.GetProperty( TextEditor::Property::INPUT_FONT_FAMILY ).Get<std::string>();
1142     DALI_TEST_EQUALS( fontFamily, "DejaVuSerif", TEST_LOCATION );
1143
1144     const float pointSize = editor.GetProperty( TextEditor::Property::INPUT_POINT_SIZE ).Get<float>();
1145     DALI_TEST_EQUALS( pointSize, 18.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1146   }
1147   DALI_TEST_CHECK( inputStyleChangedSignal );
1148
1149   gInputStyleChangedCallbackCalled = false;
1150   gInputStyleMask = TextEditor::InputStyle::NONE;
1151   inputStyleChangedSignal = false;
1152
1153   // Create a tap event to touch the text editor.
1154   TestGenerateTap( application, 30.0f, 25.0f );
1155
1156   // Render and notify
1157   application.SendNotification();
1158   application.Render();
1159
1160   // Executes the idle callbacks added by the text control on the change of input style.
1161   application.RunIdles();
1162
1163   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1164   DALI_TEST_CHECK( !inputStyleChangedSignal );
1165
1166   gInputStyleChangedCallbackCalled = false;
1167   gInputStyleMask = TextEditor::InputStyle::NONE;
1168   inputStyleChangedSignal = false;
1169
1170   // Create a tap event to touch the text editor.
1171   TestGenerateTap( application, 43.0f, 25.0f );
1172
1173   // Render and notify
1174   application.SendNotification();
1175   application.Render();
1176
1177   // Executes the idle callbacks added by the text control on the change of input style.
1178   application.RunIdles();
1179
1180   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1181   if( gInputStyleChangedCallbackCalled )
1182   {
1183     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextEditor::InputStyle::COLOR ), TEST_LOCATION );
1184
1185     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1186     DALI_TEST_EQUALS( color, Color::GREEN, TEST_LOCATION );
1187   }
1188   DALI_TEST_CHECK( inputStyleChangedSignal );
1189
1190   gInputStyleChangedCallbackCalled = false;
1191   gInputStyleMask = TextEditor::InputStyle::NONE;
1192   inputStyleChangedSignal = false;
1193
1194   // Create a tap event to touch the text editor.
1195   TestGenerateTap( application, 88.0f, 25.0f );
1196
1197   // Render and notify
1198   application.SendNotification();
1199   application.Render();
1200
1201   // Executes the idle callbacks added by the text control on the change of input style.
1202   application.RunIdles();
1203
1204   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1205   if( gInputStyleChangedCallbackCalled )
1206   {
1207     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextEditor::InputStyle::COLOR | TextEditor::InputStyle::FONT_STYLE ), TEST_LOCATION );
1208
1209     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1210     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1211
1212     Property::Map fontStyleMapSet;
1213     Property::Map fontStyleMapGet;
1214
1215     fontStyleMapSet.Insert( "weight", "bold" );
1216
1217     fontStyleMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::INPUT_FONT_STYLE );
1218     DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1219     DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1220   }
1221   DALI_TEST_CHECK( inputStyleChangedSignal );
1222
1223   gInputStyleChangedCallbackCalled = false;
1224   gInputStyleMask = TextEditor::InputStyle::NONE;
1225   inputStyleChangedSignal = false;
1226
1227   // Create a tap event to touch the text editor.
1228   TestGenerateTap( application, 115.0f, 25.0f );
1229
1230   // Render and notify
1231   application.SendNotification();
1232   application.Render();
1233
1234   // Executes the idle callbacks added by the text control on the change of input style.
1235   application.RunIdles();
1236
1237   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1238   DALI_TEST_CHECK( !inputStyleChangedSignal );
1239
1240   gInputStyleChangedCallbackCalled = false;
1241   gInputStyleMask = TextEditor::InputStyle::NONE;
1242   inputStyleChangedSignal = false;
1243
1244   // Create a tap event to touch the text editor.
1245   TestGenerateTap( application, 164.0f, 25.0f );
1246
1247   // Render and notify
1248   application.SendNotification();
1249   application.Render();
1250
1251   // Executes the idle callbacks added by the text control on the change of input style.
1252   application.RunIdles();
1253
1254   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1255   if( gInputStyleChangedCallbackCalled )
1256   {
1257     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ), static_cast<unsigned int>( TextEditor::InputStyle::FONT_STYLE ), TEST_LOCATION );
1258
1259     Property::Map fontStyleMapSet;
1260     Property::Map fontStyleMapGet;
1261
1262     fontStyleMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::INPUT_FONT_STYLE );
1263     DALI_TEST_EQUALS( fontStyleMapGet.Count(), fontStyleMapSet.Count(), TEST_LOCATION );
1264     DALI_TEST_EQUALS( DaliTestCheckMaps( fontStyleMapGet, fontStyleMapSet ), true, TEST_LOCATION );
1265   }
1266   DALI_TEST_CHECK( inputStyleChangedSignal );
1267
1268   gInputStyleChangedCallbackCalled = false;
1269   gInputStyleMask = TextEditor::InputStyle::NONE;
1270   inputStyleChangedSignal = false;
1271
1272   // Create a tap event to touch the text editor.
1273   TestGenerateTap( application, 191.0f, 25.0f );
1274
1275   // Render and notify
1276   application.SendNotification();
1277   application.Render();
1278
1279   // Executes the idle callbacks added by the text control on the change of input style.
1280   application.RunIdles();
1281
1282   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1283   DALI_TEST_CHECK( !inputStyleChangedSignal );
1284
1285   END_TEST;
1286 }
1287
1288 int utcDaliTextEditorInputStyleChanged02(void)
1289 {
1290   // The text-editor emits signals when the input style changes. These changes of style are
1291   // detected during the relayout process (size negotiation), i.e after the cursor has been moved. Signals
1292   // can't be emitted during the size negotiation as the callbacks may update the UI.
1293   // The text-editor adds an idle callback to the adaptor to emit the signals after the size negotiation.
1294   // The ToolkitTestApplication creates an implementation of the adaptor stub and a queue of idle callbacks.
1295   ToolkitTestApplication application;
1296   tet_infoline(" utcDaliTextEditorInputStyleChanged02");
1297
1298   // Load some fonts.
1299
1300   char* pathNamePtr = get_current_dir_name();
1301   const std::string pathName( pathNamePtr );
1302   free( pathNamePtr );
1303
1304   TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1305   fontClient.SetDpi( 93u, 93u );
1306
1307   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif.ttf", DEFAULT_FONT_SIZE );
1308   fontClient.GetFontId( pathName + DEFAULT_FONT_DIR + "/dejavu/DejaVuSerif-Bold.ttf", DEFAULT_FONT_SIZE );
1309
1310   TextEditor editor = TextEditor::New();
1311   DALI_TEST_CHECK( editor );
1312
1313
1314   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1315   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1316   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1317
1318   editor.SetProperty( TextEditor::Property::ENABLE_MARKUP, true );
1319   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>" );
1320
1321   // connect to the text changed signal.
1322   ConnectionTracker* testTracker = new ConnectionTracker();
1323   editor.InputStyleChangedSignal().Connect( &TestInputStyleChangedCallback );
1324   bool inputStyleChangedSignal = false;
1325   editor.ConnectSignal( testTracker, "inputStyleChanged",   CallbackFunctor(&inputStyleChangedSignal) );
1326
1327   application.GetScene().Add( editor );
1328
1329   // Render and notify
1330   application.SendNotification();
1331   application.Render();
1332
1333   // Executes the idle callbacks added by the text control on the change of input style.
1334   application.RunIdles();
1335
1336   gInputStyleChangedCallbackCalled = false;
1337   gInputStyleMask = TextEditor::InputStyle::NONE;
1338   inputStyleChangedSignal = false;
1339
1340   // Create a tap event to touch the text editor.
1341   TestGenerateTap( application, 53.0f, 25.0f, 100 );
1342   TestGenerateTap( application, 53.0f, 25.0f, 200 );
1343
1344   // Render and notify
1345   application.SendNotification();
1346   application.Render();
1347
1348   // Executes the idle callbacks added by the text control on the change of input style.
1349   application.RunIdles();
1350
1351   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1352   if( gInputStyleChangedCallbackCalled )
1353   {
1354     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1355                       static_cast<unsigned int>( TextEditor::InputStyle::FONT_FAMILY |
1356                                                  TextEditor::InputStyle::POINT_SIZE  |
1357                                                  TextEditor::InputStyle::COLOR ),
1358                       TEST_LOCATION );
1359
1360     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1361     DALI_TEST_EQUALS( color, Color::GREEN, TEST_LOCATION );
1362
1363     const std::string fontFamily = editor.GetProperty( TextEditor::Property::INPUT_FONT_FAMILY ).Get<std::string>();
1364     DALI_TEST_EQUALS( fontFamily, "DejaVuSerif", TEST_LOCATION );
1365
1366     const float pointSize = editor.GetProperty( TextEditor::Property::INPUT_POINT_SIZE ).Get<float>();
1367     DALI_TEST_EQUALS( pointSize, 18.f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
1368   }
1369   DALI_TEST_CHECK( inputStyleChangedSignal );
1370
1371   gInputStyleChangedCallbackCalled = false;
1372   gInputStyleMask = TextEditor::InputStyle::NONE;
1373   inputStyleChangedSignal = false;
1374
1375   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1376
1377   // Render and notify
1378   application.SendNotification();
1379   application.Render();
1380
1381   // Executes the idle callbacks added by the text control on the change of input style.
1382   application.RunIdles();
1383
1384   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1385   if( gInputStyleChangedCallbackCalled )
1386   {
1387     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1388                       static_cast<unsigned int>( TextEditor::InputStyle::COLOR ),
1389                       TEST_LOCATION );
1390
1391     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1392     DALI_TEST_EQUALS( color, Color::BLUE, TEST_LOCATION );
1393   }
1394   DALI_TEST_CHECK( inputStyleChangedSignal );
1395
1396   gInputStyleChangedCallbackCalled = false;
1397   gInputStyleMask = TextEditor::InputStyle::NONE;
1398   inputStyleChangedSignal = false;
1399
1400   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1401
1402   // Render and notify
1403   application.SendNotification();
1404   application.Render();
1405
1406   // Executes the idle callbacks added by the text control on the change of input style.
1407   application.RunIdles();
1408
1409   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1410   DALI_TEST_CHECK( !inputStyleChangedSignal );
1411
1412   gInputStyleChangedCallbackCalled = false;
1413   gInputStyleMask = TextEditor::InputStyle::NONE;
1414   inputStyleChangedSignal = false;
1415
1416   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1417
1418   // Render and notify
1419   application.SendNotification();
1420   application.Render();
1421
1422   // Executes the idle callbacks added by the text control on the change of input style.
1423   application.RunIdles();
1424
1425   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1426   if( gInputStyleChangedCallbackCalled )
1427   {
1428     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1429                       static_cast<unsigned int>( TextEditor::InputStyle::COLOR ),
1430                       TEST_LOCATION );
1431
1432     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1433     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1434   }
1435   DALI_TEST_CHECK( inputStyleChangedSignal );
1436
1437   gInputStyleChangedCallbackCalled = false;
1438   gInputStyleMask = TextEditor::InputStyle::NONE;
1439   inputStyleChangedSignal = false;
1440
1441   editor.SetProperty( TextEditor::Property::INPUT_COLOR, Color::YELLOW );
1442
1443   Property::Map fontStyleMapSet;
1444   fontStyleMapSet.Insert( "weight", "thin" );
1445   fontStyleMapSet.Insert( "width", "condensed" );
1446   fontStyleMapSet.Insert( "slant", "italic" );
1447
1448   editor.SetProperty( TextEditor::Property::INPUT_FONT_STYLE, fontStyleMapSet );
1449   editor.SetProperty( TextEditor::Property::INPUT_POINT_SIZE, 20.f );
1450   editor.SetProperty( TextEditor::Property::INPUT_LINE_SPACING, 5.f );
1451
1452   editor.SetProperty( TextEditor::Property::INPUT_UNDERLINE, "underline" );
1453   editor.SetProperty( TextEditor::Property::INPUT_SHADOW, "shadow" );
1454   editor.SetProperty( TextEditor::Property::INPUT_EMBOSS, "emboss" );
1455   editor.SetProperty( TextEditor::Property::INPUT_OUTLINE, "outline" );
1456
1457   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1458
1459   // Render and notify
1460   application.SendNotification();
1461   application.Render();
1462
1463   // Executes the idle callbacks added by the text control on the change of input style.
1464   application.RunIdles();
1465
1466   DALI_TEST_CHECK( !gInputStyleChangedCallbackCalled );
1467   DALI_TEST_CHECK( !inputStyleChangedSignal );
1468
1469   // Create a tap event to touch the text editor.
1470   TestGenerateTap( application, 63.0f, 25.0f, 900 );
1471
1472   // Render and notify
1473   application.SendNotification();
1474   application.Render();
1475
1476   // Executes the idle callbacks added by the text control on the change of input style.
1477   application.RunIdles();
1478
1479   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1480   if( gInputStyleChangedCallbackCalled )
1481   {
1482     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1483                       static_cast<unsigned int>( TextEditor::InputStyle::COLOR |
1484                                                  TextEditor::InputStyle::POINT_SIZE |
1485                                                  TextEditor::InputStyle::FONT_STYLE |
1486                                                  TextEditor::InputStyle::LINE_SPACING |
1487                                                  TextEditor::InputStyle::UNDERLINE |
1488                                                  TextEditor::InputStyle::SHADOW |
1489                                                  TextEditor::InputStyle::EMBOSS |
1490                                                  TextEditor::InputStyle::OUTLINE ),
1491                       TEST_LOCATION );
1492
1493     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1494     DALI_TEST_EQUALS( color, Color::BLACK, TEST_LOCATION );
1495   }
1496   DALI_TEST_CHECK( inputStyleChangedSignal );
1497
1498   gInputStyleChangedCallbackCalled = false;
1499   gInputStyleMask = TextEditor::InputStyle::NONE;
1500   inputStyleChangedSignal = false;
1501
1502   editor.SetProperty( TextEditor::Property::FONT_FAMILY, "DejaVuSerif" );
1503
1504   fontStyleMapSet.Clear();
1505   fontStyleMapSet.Insert( "weight", "black" );
1506   fontStyleMapSet.Insert( "width", "expanded" );
1507   fontStyleMapSet.Insert( "slant", "oblique" );
1508
1509   editor.SetProperty( TextEditor::Property::FONT_STYLE, fontStyleMapSet );
1510
1511   // Create a tap event to touch the text editor.
1512   TestGenerateTap( application, 30.0f, 25.0f, 1500 );
1513
1514   // Render and notify
1515   application.SendNotification();
1516   application.Render();
1517
1518   // Executes the idle callbacks added by the text control on the change of input style.
1519   application.RunIdles();
1520
1521   DALI_TEST_CHECK( gInputStyleChangedCallbackCalled );
1522   if( gInputStyleChangedCallbackCalled )
1523   {
1524     DALI_TEST_EQUALS( static_cast<unsigned int>( gInputStyleMask ),
1525                       static_cast<unsigned int>( TextEditor::InputStyle::COLOR |
1526                                                  TextEditor::InputStyle::POINT_SIZE |
1527                                                  TextEditor::InputStyle::FONT_STYLE ),
1528                       TEST_LOCATION );
1529
1530     const Vector4 color = editor.GetProperty( TextEditor::Property::INPUT_COLOR ).Get<Vector4>();
1531     DALI_TEST_EQUALS( color, Color::YELLOW, TEST_LOCATION );
1532   }
1533   DALI_TEST_CHECK( inputStyleChangedSignal );
1534
1535   END_TEST;
1536 }
1537
1538 int utcDaliTextEditorEvent01(void)
1539 {
1540   ToolkitTestApplication application;
1541   tet_infoline(" utcDaliTextEditorEvent01");
1542
1543   // Creates a tap event. After creating a tap event the text editor should
1544   // have the focus and add text with key events should be possible.
1545
1546   TextEditor editor = TextEditor::New();
1547   DALI_TEST_CHECK( editor );
1548
1549   application.GetScene().Add( editor );
1550
1551   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1552   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1553   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1554
1555   // Avoid a crash when core load gl resources.
1556   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1557
1558   // Render and notify
1559   application.SendNotification();
1560   application.Render();
1561
1562   // Add a key event but as the text editor has not the focus it should do nothing.
1563   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1564
1565   // Render and notify
1566   application.SendNotification();
1567   application.Render();
1568
1569   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string(""), TEST_LOCATION );
1570
1571   // Create a tap event to touch the text editor.
1572   TestGenerateTap( application, 150.0f, 25.0f );
1573
1574   // Render and notify
1575   application.SendNotification();
1576   application.Render();
1577
1578   // Now the text editor has the focus, so it can handle the key events.
1579   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1580   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1581
1582   // Render and notify
1583   application.SendNotification();
1584   application.Render();
1585
1586   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("aa"), TEST_LOCATION );
1587
1588   // Create a second text editor and send key events to it.
1589   TextEditor editor2 = TextEditor::New();
1590
1591   editor2.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1592   editor2.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1593   editor2.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 100.f ) );
1594   editor2.SetProperty( Actor::Property::POSITION, Vector2( 100.f, 100.f ));
1595
1596   application.GetScene().Add( editor2 );
1597
1598   // Render and notify
1599   application.SendNotification();
1600   application.Render();
1601
1602   // Create a tap event on the second text editor.
1603   TestGenerateTap( application, 150.0f, 125.0f );
1604
1605   // Render and notify
1606   application.SendNotification();
1607   application.Render();
1608
1609   // The second text editor has the focus. It should handle the key events.
1610   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1611   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1612
1613   // Render and notify
1614   application.SendNotification();
1615   application.Render();
1616
1617   // Check the text has been added to the second text editor.
1618   DALI_TEST_EQUALS( editor2.GetProperty<std::string>( TextEditor::Property::TEXT ), std::string("aa"), TEST_LOCATION );
1619
1620   END_TEST;
1621 }
1622
1623 int utcDaliTextEditorEvent02(void)
1624 {
1625   ToolkitTestApplication application;
1626   tet_infoline(" utcDaliTextEditorEvent02");
1627
1628   // Checks if the right number of actors are created.
1629
1630   TextEditor editor = TextEditor::New();
1631   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
1632   DALI_TEST_CHECK( editor );
1633
1634   application.GetScene().Add( editor );
1635
1636   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
1637   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1638   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1639
1640   // Avoid a crash when core load gl resources.
1641   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1642
1643   // Render and notify
1644   application.SendNotification();
1645   application.Render();
1646
1647   // Check there are the expected number of children (the stencil).
1648   DALI_TEST_EQUALS( editor.GetChildCount(), 1u, TEST_LOCATION );
1649
1650   Actor stencil = editor.GetChildAt( 0u );
1651
1652   // Create a tap event to touch the text editor.
1653   TestGenerateTap( application, 150.0f, 25.0f, 100 );
1654
1655   // Render and notify
1656   application.SendNotification();
1657   application.Render();
1658
1659   Actor layer = editor.GetChildAt( 1u );
1660   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
1661   DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
1662
1663   // Now the text editor has the focus, so it can handle the key events.
1664   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1665   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1666
1667   // Render and notify
1668   application.SendNotification();
1669   application.Render();
1670
1671   // Checks the cursor and the renderer have been created.
1672   DALI_TEST_EQUALS( layer.GetChildCount(), 1u, TEST_LOCATION ); // The cursor.
1673   DALI_TEST_EQUALS( stencil.GetChildCount(), 1u, TEST_LOCATION ); // The renderer
1674
1675   Control cursor = Control::DownCast( layer.GetChildAt( 0u ) );
1676   DALI_TEST_CHECK( cursor );
1677
1678   // The stencil actor has a container with all the actors which contain the text renderers.
1679   Actor container = stencil.GetChildAt( 0u );
1680   for( unsigned int index = 0; index < container.GetChildCount(); ++index )
1681   {
1682     Renderer renderer = container.GetChildAt( index ).GetRendererAt( 0u );
1683     DALI_TEST_CHECK( renderer );
1684   }
1685
1686   // Move the cursor and check the position changes.
1687   Vector3 position1 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1688
1689   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1690   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1691
1692   // Render and notify
1693   application.SendNotification();
1694   application.Render();
1695
1696   Vector3 position2 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1697
1698   DALI_TEST_CHECK( position2.x < position1.x );
1699
1700   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1701   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1702
1703   // Render and notify
1704   application.SendNotification();
1705   application.Render();
1706
1707   Vector3 position3 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1708
1709   DALI_TEST_EQUALS( position1, position3, TEST_LOCATION ); // Should be in the same position1.
1710
1711   // Send some taps and check the cursor positions.
1712
1713   // Try to tap at the beginning.
1714   TestGenerateTap( application, 1.0f, 25.0f, 700 );
1715
1716   // Render and notify
1717   application.SendNotification();
1718   application.Render();
1719
1720   // Cursor position should be the same than position1.
1721   Vector3 position4 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1722
1723   DALI_TEST_EQUALS( position2, position4, TEST_LOCATION ); // Should be in the same position2.
1724
1725   // Tap away from the start position.
1726   TestGenerateTap( application, 16.0f, 25.0f, 1400 );
1727
1728   // Render and notify
1729   application.SendNotification();
1730   application.Render();
1731
1732   Vector3 position5 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1733
1734   DALI_TEST_CHECK( position5.x > position4.x );
1735
1736   // Remove all the text.
1737   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1738   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1739   editor.SetProperty( TextEditor::Property::TEXT, "" );
1740
1741   // Render and notify
1742   application.SendNotification();
1743   application.Render();
1744
1745   // Cursor position should be the same than position2.
1746   Vector3 position6 = cursor.GetCurrentProperty< Vector3 >( Actor::Property::POSITION );
1747
1748   DALI_TEST_EQUALS( position2, position6, TEST_LOCATION );// Should be in the same position2.
1749
1750   // Should not be a renderer.
1751   DALI_TEST_EQUALS( stencil.GetChildCount(), 0u, TEST_LOCATION );
1752
1753   END_TEST;
1754 }
1755
1756 int utcDaliTextEditorEvent03(void)
1757 {
1758   ToolkitTestApplication application;
1759   tet_infoline(" utcDaliTextEditorEvent03");
1760
1761   // Checks if the highlight actor is created.
1762
1763   TextEditor editor = TextEditor::New();
1764   DALI_TEST_CHECK( editor );
1765
1766   application.GetScene().Add( editor );
1767
1768   editor.SetProperty( TextEditor::Property::TEXT, "This is a long text for the size of the text-editor." );
1769   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
1770   editor.SetProperty( Actor::Property::SIZE, Vector2( 30.f, 50.f ) );
1771   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1772   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1773
1774   // Avoid a crash when core load gl resources.
1775   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1776
1777   // Render and notify
1778   application.SendNotification();
1779   application.Render();
1780
1781   // Send some taps and check text controller with clipboard window
1782   Dali::Clipboard clipboard = Clipboard::Get();
1783   clipboard.ShowClipboard();
1784   TestGenerateTap( application, 3.0f, 25.0f, 100 );
1785   clipboard.HideClipboard();
1786
1787   // Render and notify
1788   application.SendNotification();
1789   application.Render();
1790
1791   // Tap first to get the focus.
1792   TestGenerateTap( application, 3.0f, 25.0f, 1000 );
1793
1794   // Render and notify
1795   application.SendNotification();
1796   application.Render();
1797
1798   // Double tap to select a word.
1799   TestGenerateTap( application, 3.0f, 25.0f, 1100 );
1800
1801   // Render and notify
1802   application.SendNotification();
1803   application.Render();
1804
1805   // The stencil actor should have two actors: the renderer and the highlight actor.
1806   Actor stencil = editor.GetChildAt( 0u );
1807
1808   // Highlight needs to be drawn before text, so should come first in child order
1809   Renderer highlight = stencil.GetChildAt( 0u ).GetRendererAt( 0u );
1810   DALI_TEST_CHECK( highlight );
1811
1812   // The stencil actor has a container with all the actors which contain the text renderers.
1813   Actor container = stencil.GetChildAt( 1u );
1814   for( unsigned int index = 0; index < container.GetChildCount(); ++index )
1815   {
1816     Renderer renderer = container.GetChildAt( index ).GetRendererAt( 0u );
1817     DALI_TEST_CHECK( renderer );
1818   }
1819
1820   // Double tap out of bounds
1821   TestGenerateTap( application, 29.0f, 25.0f, 1700 );
1822   TestGenerateTap( application, 29.0f, 25.0f, 1800 );
1823
1824   // Render and notify
1825   application.SendNotification();
1826   application.Render();
1827
1828   // The stencil actor should have one actors: the renderer actor.
1829   stencil = editor.GetChildAt( 0u );
1830
1831   // The stencil actor has a container with all the actors which contain the text renderers.
1832   container = stencil.GetChildAt( 0u );
1833   for( unsigned int index = 0; index < container.GetChildCount(); ++index )
1834   {
1835     Renderer renderer = container.GetChildAt( index ).GetRendererAt( 0u );
1836     DALI_TEST_CHECK( renderer );
1837   }
1838
1839   // Long Press
1840   TestGenerateLongPress(application, 1.0f, 25.0f);
1841
1842   // Render and notify
1843   application.SendNotification();
1844   application.Render();
1845
1846   // Pan Press
1847   TestGenerateMiniPan(application);
1848
1849   // Render and notify
1850   application.SendNotification();
1851   application.Render();
1852
1853   END_TEST;
1854 }
1855
1856 int utcDaliTextEditorEvent04(void)
1857 {
1858   ToolkitTestApplication application;
1859   tet_infoline(" utcDaliTextEditorEvent04");
1860
1861   // Checks if the highlight actor is created.
1862
1863   TextEditor editor = TextEditor::New();
1864   DALI_TEST_CHECK( editor );
1865
1866   application.GetScene().Add( editor );
1867
1868   editor.SetProperty( TextEditor::Property::TEXT, "Hello\nworl" );
1869   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
1870   editor.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 50.f ) );
1871   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1872   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1873
1874   // Avoid a crash when core load gl resources.
1875   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1876
1877   // Render and notify
1878   application.SendNotification();
1879   application.Render();
1880
1881   // Tap on the text editor
1882   TestGenerateTap( application, 3.0f, 25.0f );
1883
1884   // Render and notify
1885   application.SendNotification();
1886   application.Render();
1887
1888   // Move at the end of the text.
1889   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1890   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1891
1892   // Render and notify
1893   application.SendNotification();
1894   application.Render();
1895
1896   for( unsigned int index = 0u; index < 10u; ++index )
1897   {
1898     application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1899     application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1900
1901     // Render and notify
1902     application.SendNotification();
1903     application.Render();
1904   }
1905
1906   // Add a character
1907   application.ProcessEvent( GenerateKey( "d", "", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1908
1909   // Render and notify
1910   application.SendNotification();
1911   application.Render();
1912
1913   DALI_TEST_EQUALS( "Hello\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
1914
1915   // Add some key events
1916   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1917   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_UP, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1918
1919   // Render and notify
1920   application.SendNotification();
1921   application.Render();
1922
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     application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1927
1928     // Render and notify
1929     application.SendNotification();
1930     application.Render();
1931   }
1932
1933   // Add a character
1934   application.ProcessEvent( GenerateKey( " ", "", " ", KEY_WHITE_SPACE_CODE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1935
1936   // Render and notify
1937   application.SendNotification();
1938   application.Render();
1939
1940   DALI_TEST_EQUALS( " Hello\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
1941
1942   END_TEST;
1943 }
1944
1945 int utcDaliTextEditorEvent05(void)
1946 {
1947   ToolkitTestApplication application;
1948   tet_infoline(" utcDaliTextEditorEvent05");
1949
1950   // Checks if the highlight actor is created.
1951
1952   TextEditor editor = TextEditor::New();
1953   DALI_TEST_CHECK( editor );
1954
1955   application.GetScene().Add( editor );
1956
1957   editor.SetProperty( TextEditor::Property::TEXT, "Hello\nworl" );
1958   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
1959   editor.SetProperty( Actor::Property::SIZE, Vector2( 50.f, 50.f ) );
1960   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
1961   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
1962   editor.SetProperty( TextEditor::Property::SMOOTH_SCROLL, true );
1963   editor.SetProperty( TextEditor::Property::SMOOTH_SCROLL_DURATION, 0.2f );
1964   editor.SetProperty( TextEditor::Property::ENABLE_SCROLL_BAR, true );
1965   editor.SetProperty( TextEditor::Property::SCROLL_BAR_SHOW_DURATION, 0.3f );
1966   editor.SetProperty( TextEditor::Property::SCROLL_BAR_FADE_DURATION, 0.2f );
1967
1968   // Avoid a crash when core load gl resources.
1969   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
1970
1971   // Render and notify
1972   application.SendNotification();
1973   application.Render();
1974
1975   // Tap on the text editor
1976   TestGenerateTap( application, 3.0f, 25.0f );
1977
1978   // Render and notify
1979   application.SendNotification();
1980   application.Render();
1981
1982   // Move at the end of the text.
1983   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1984   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1985
1986   // Render and notify
1987   application.SendNotification();
1988   application.Render();
1989
1990   for( unsigned int index = 0u; index < 10u; ++index )
1991   {
1992     // Add a character
1993     application.ProcessEvent( GenerateKey( "d", "", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
1994
1995     // Render and notify
1996     application.SendNotification();
1997     application.Render();
1998   }
1999   // Modify duration after scroll is enabled
2000   editor.SetProperty( TextEditor::Property::SMOOTH_SCROLL_DURATION, 0.1f );
2001
2002   // Continuous scroll left to increase coverage
2003   for( unsigned int index = 0u; index < 10u; ++index )
2004   {
2005     application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2006
2007     // Render and notify
2008     application.SendNotification();
2009     application.Render();
2010   }
2011   DALI_TEST_EQUALS( editor.GetProperty<float>( TextEditor::Property::SMOOTH_SCROLL_DURATION ), 0.1f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2012   DALI_TEST_EQUALS( editor.GetProperty<bool>( TextEditor::Property::SMOOTH_SCROLL ), true, TEST_LOCATION );
2013   DALI_TEST_EQUALS( editor.GetProperty<bool>( TextEditor::Property::ENABLE_SCROLL_BAR ), true, TEST_LOCATION );
2014   DALI_TEST_EQUALS( editor.GetProperty<float>( TextEditor::Property::SCROLL_BAR_SHOW_DURATION ), 0.3f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2015   DALI_TEST_EQUALS( editor.GetProperty<float>( TextEditor::Property::SCROLL_BAR_FADE_DURATION ), 0.2f, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2016
2017   // Press Escape to increase coverage
2018   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_ESCAPE, 0, 0, Integration::KeyEvent::UP, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2019   application.SendNotification();
2020   application.Render();
2021
2022   DALI_TEST_CHECK( !editor.HasKeyInputFocus() );
2023
2024   END_TEST;
2025 }
2026
2027 int utcDaliTextEditorEvent06(void)
2028 {
2029   ToolkitTestApplication application;
2030   tet_infoline(" utcDaliTextEditorEvent06");
2031
2032   // Checks if the highlight actor is created.
2033
2034   TextEditor editor = TextEditor::New();
2035   DALI_TEST_CHECK( editor );
2036
2037   application.GetScene().Add( editor );
2038
2039   editor.SetProperty( TextEditor::Property::TEXT, "Hello\nworld\nHello world" );
2040   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
2041   editor.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 50.f ) );
2042   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2043   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2044
2045   // Avoid a crash when core load gl resources.
2046   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2047
2048   // Render and notify
2049   application.SendNotification();
2050   application.Render();
2051
2052   // Tap on the text editor
2053   TestGenerateTap( application, 3.0f, 25.0f );
2054
2055   // Render and notify
2056   application.SendNotification();
2057   application.Render();
2058
2059   // Move to seconds line of the text.
2060   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2061
2062   // Render and notify
2063   application.SendNotification();
2064   application.Render();
2065
2066   float layoutHeight = editor.GetHeightForWidth( 100.f );
2067
2068
2069   // Add  another script characters ( glyph height is defferent )
2070   application.ProcessEvent( GenerateKey( "d", "", "ㅁ", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "ㅁ", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2071   application.ProcessEvent( GenerateKey( "d", "", "ኢ", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "ኢ", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2072
2073   // Delete characters
2074   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2075   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_BACKSPACE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2076
2077   DALI_TEST_EQUALS( layoutHeight, editor.GetHeightForWidth( 100.f ), TEST_LOCATION );
2078
2079   // Render and notify
2080   application.SendNotification();
2081   application.Render();
2082
2083   DALI_TEST_EQUALS( "Hello\nworld\nHello world", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2084
2085   // For coverage
2086   application.ProcessEvent( GenerateKey( "", "", "", 0, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2087   application.SendNotification();
2088   application.Render();
2089
2090   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2091   application.SendNotification();
2092   application.Render();
2093
2094   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_VOLUME_UP, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2095   application.SendNotification();
2096   application.Render();
2097
2098   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_VOLUME_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2099   application.SendNotification();
2100   application.Render();
2101
2102   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_DELETE, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2103   application.SendNotification();
2104   application.Render();
2105
2106   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2107   application.SendNotification();
2108   application.Render();
2109
2110   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2111   application.SendNotification();
2112   application.Render();
2113
2114   END_TEST;
2115 }
2116
2117 int utcDaliTextEditorEvent07(void)
2118 {
2119   ToolkitTestApplication application;
2120   tet_infoline(" utcDaliTextEditorEvent07");
2121
2122   // Checks if the highlight actor is created.
2123
2124   TextEditor editor = TextEditor::New();
2125   DALI_TEST_CHECK( editor );
2126
2127   application.GetScene().Add( editor );
2128
2129   editor.SetProperty( TextEditor::Property::TEXT, "Hello\nworld\nHello world" );
2130   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
2131   editor.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 50.f ) );
2132   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2133   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2134
2135   // Avoid a crash when core load gl resources.
2136   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2137
2138   // Render and notify
2139   application.SendNotification();
2140   application.Render();
2141
2142   // Tap on the text editor
2143   TestGenerateTap( application, 3.0f, 25.0f );
2144
2145   // Render and notify
2146   application.SendNotification();
2147   application.Render();
2148
2149   // Move to second line of the text.
2150   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2151
2152   // Render and notify
2153   application.SendNotification();
2154   application.Render();
2155
2156   // Select some text in the right of the current cursor position
2157   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2158   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2159   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2160   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2161
2162   // Render and notify
2163   application.SendNotification();
2164   application.Render();
2165
2166   // Cut the selected text
2167   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2168   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 ) );
2169
2170   // Render and notify
2171   application.SendNotification();
2172   application.Render();
2173
2174   DALI_TEST_EQUALS( "Hello\nld\nHello world", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2175
2176   // Select some text in the left of the current cursor position
2177   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2178   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2179   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN,  "",DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2180   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2181
2182   // Render and notify
2183   application.SendNotification();
2184   application.Render();
2185
2186   // Copy the selected text
2187   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2188   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 ) );
2189
2190   // Render and notify
2191   application.SendNotification();
2192   application.Render();
2193
2194   // Move the cursor to the third line
2195   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2196   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_DOWN, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2197
2198   // Render and notify
2199   application.SendNotification();
2200   application.Render();
2201
2202   // Paste the selected text at the current cursor position
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( "v", "", "v", KEY_V_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "v", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2205
2206   // Render and notify
2207   application.SendNotification();
2208   application.Render();
2209
2210   DALI_TEST_EQUALS( "Hello\nld\nHello lo\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2211
2212
2213   // Disable Shift Selection
2214   editor.SetProperty( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION, false );
2215
2216   // Test to select some text in the right of the current cursor position
2217   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2218   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2219   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2220   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2221
2222   // Render and notify
2223   application.SendNotification();
2224   application.Render();
2225
2226   // Cut the selected text
2227   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2228   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 ) );
2229
2230   // Render and notify
2231   application.SendNotification();
2232   application.Render();
2233
2234   // The text isn't selected and not changed because of 'SetProperty( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION, false )'
2235   DALI_TEST_EQUALS( "Hello\nld\nHello lo\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2236
2237   // Test to select some text in the left of the current cursor position
2238   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2239   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2240   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2241   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2242
2243   // Render and notify
2244   application.SendNotification();
2245   application.Render();
2246
2247   // Copy the selected text
2248   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2249   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 ) );
2250
2251   // Render and notify
2252   application.SendNotification();
2253   application.Render();
2254
2255   // The text is not selected and not changed because of 'SetProperty( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION, false )'
2256   DALI_TEST_EQUALS( "Hello\nld\nHello lo\nworld", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2257
2258   // Select all Text
2259   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 ) );
2260
2261   // Render and notify
2262   application.SendNotification();
2263   application.Render();
2264
2265   // replace text with "c"
2266   application.ProcessEvent( GenerateKey( "c", "", "c", KEY_C_CODE, 0, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2267
2268   // Render and notify
2269   application.SendNotification();
2270   application.Render();
2271
2272   //text is "c"
2273   DALI_TEST_EQUALS( "c", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2274
2275   // select all text
2276   DevelTextEditor::SelectWholeText(editor);
2277
2278   // Render and notify
2279   application.SendNotification();
2280   application.Render();
2281
2282   // Copy the selected text using logical keys
2283   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2284   application.ProcessEvent( GenerateKey( "ؤ", "c", "ؤ", KEY_C_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2285
2286   // Render and notify
2287   application.SendNotification();
2288   application.Render();
2289
2290   // select none
2291   DevelTextEditor::SelectNone(editor);
2292
2293   // Render and notify
2294   application.SendNotification();
2295   application.Render();
2296
2297   // Paste the selected using logical keys
2298   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2299   application.ProcessEvent( GenerateKey( "ر", "v", "ر", KEY_V_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "v", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2300
2301   //text is "cc"
2302   DALI_TEST_EQUALS( "cc", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2303
2304   // select all using logical keys
2305   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2306   application.ProcessEvent( GenerateKey( "ش", "a", "ش", KEY_A_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2307
2308   // Render and notify
2309   application.SendNotification();
2310   application.Render();
2311
2312   // cut text using logical keys
2313   application.ProcessEvent( GenerateKey( "", "", "", Dali::DevelKey::DALI_KEY_CONTROL_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2314   application.ProcessEvent( GenerateKey( "ء", "x", "ء", KEY_X_CODE, KEY_CONTROL_MODIFIER, 0, Integration::KeyEvent::DOWN, "x", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2315
2316   // Render and notify
2317   application.SendNotification();
2318   application.Render();
2319
2320   //text is ""
2321   DALI_TEST_EQUALS( "", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2322
2323   END_TEST;
2324 }
2325
2326 int utcDaliTextEditorEvent08(void)
2327 {
2328   ToolkitTestApplication application;
2329   tet_infoline(" utcDaliTextEditorEvent08");
2330
2331   // Checks if the highlight actor is released correctly.
2332
2333   TextEditor editor = TextEditor::New();
2334   DALI_TEST_CHECK( editor );
2335
2336   application.GetScene().Add( editor );
2337
2338   editor.SetProperty( TextEditor::Property::TEXT, "DALi" );
2339   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
2340   editor.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 50.f ) );
2341   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2342   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2343
2344   // Avoid a crash when core load gl resources.
2345   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2346
2347   // Render and notify
2348   application.SendNotification();
2349   application.Render();
2350
2351   // Tap on the text editor
2352   TestGenerateTap( application, 3.0f, 25.0f );
2353
2354   // Render and notify
2355   application.SendNotification();
2356   application.Render();
2357
2358   // When the left selection handle and the right selection handle are at the same position, the highlight box should be deactivated.
2359   // Test to select some text in the left of the current cursor position
2360   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2361   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 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
2365   // Render and notify
2366   application.SendNotification();
2367   application.Render();
2368
2369   // Test to the left selection handle position and the right selection handle position
2370   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2371   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2372   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2373   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2374
2375   // Render and notify
2376   application.SendNotification();
2377   application.Render();
2378
2379   // Test to select full text in the left of the current cursor position
2380   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2381   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2382   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2383   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2384   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2385   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2386
2387   // Render and notify
2388   application.SendNotification();
2389   application.Render();
2390
2391   // Test to release the current full text selection
2392   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2393   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2394
2395   // Render and notify
2396   application.SendNotification();
2397   application.Render();
2398
2399   // Test to move the current cursor position correctly
2400   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2401
2402   // Render and notify
2403   application.SendNotification();
2404   application.Render();
2405
2406   // Add a character
2407   application.ProcessEvent( GenerateKey( "d", "", "d", KEY_D_CODE, 0, 0, Integration::KeyEvent::DOWN, "d", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2408
2409   // Render and notify
2410   application.SendNotification();
2411   application.Render();
2412
2413   DALI_TEST_EQUALS( "DdALi", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2414
2415   // Test to select some text in the right of the current cursor position
2416   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2417   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2418   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2419
2420   // Render and notify
2421   application.SendNotification();
2422   application.Render();
2423
2424   // Test the cursor position with right arrow key
2425   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2426
2427   // Render and notify
2428   application.SendNotification();
2429   application.Render();
2430
2431   // Add a character
2432   application.ProcessEvent( GenerateKey( "c", "", "c", KEY_C_CODE, 0, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2433
2434   // Render and notify
2435   application.SendNotification();
2436   application.Render();
2437
2438   DALI_TEST_EQUALS( "DdALci", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2439
2440   // Test to select some text in the left of the current cursor position
2441   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2442   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2443   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2444   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2445   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2446
2447   // Render and notify
2448   application.SendNotification();
2449   application.Render();
2450
2451   // Test the cursor position with left arrow key
2452   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2453
2454   // Render and notify
2455   application.SendNotification();
2456   application.Render();
2457
2458   // Add a character
2459   application.ProcessEvent( GenerateKey( "c", "", "c", KEY_C_CODE, 0, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2460
2461   // Render and notify
2462   application.SendNotification();
2463   application.Render();
2464
2465   DALI_TEST_EQUALS( "DcdALci", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2466
2467   // Test to select some text in the right of the current cursor position
2468   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2469   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2470   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2471   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2472
2473   // Render and notify
2474   application.SendNotification();
2475   application.Render();
2476
2477   // Test the cursor position with left arrow key
2478   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2479
2480   // Render and notify
2481   application.SendNotification();
2482   application.Render();
2483
2484   // Add a character
2485   application.ProcessEvent( GenerateKey( "x", "", "x", KEY_X_CODE, 0, 0, Integration::KeyEvent::DOWN, "x", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2486
2487   // Render and notify
2488   application.SendNotification();
2489   application.Render();
2490
2491   DALI_TEST_EQUALS( "DcxdALci", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2492
2493   // Test to select some text in the left of the current cursor position
2494   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_SHIFT_LEFT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2495   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2496   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2497   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_LEFT, KEY_SHIFT_MODIFIER, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2498
2499   // Render and notify
2500   application.SendNotification();
2501   application.Render();
2502
2503   // Test the cursor position with right arrow key
2504   application.ProcessEvent( GenerateKey( "", "", "", DALI_KEY_CURSOR_RIGHT, 0, 0, Integration::KeyEvent::DOWN, "", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2505
2506   // Render and notify
2507   application.SendNotification();
2508   application.Render();
2509
2510   // Add a character
2511   application.ProcessEvent( GenerateKey( "c", "", "c", KEY_C_CODE, 0, 0, Integration::KeyEvent::DOWN, "c", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
2512
2513   // Render and notify
2514   application.SendNotification();
2515   application.Render();
2516
2517   DALI_TEST_EQUALS( "DcxcdALci", editor.GetProperty<std::string>( TextEditor::Property::TEXT ), TEST_LOCATION );
2518
2519   END_TEST;
2520 }
2521
2522 int utcDaliTextEditorHandles(void)
2523 {
2524   ToolkitTestApplication application;
2525   tet_infoline(" utcDaliTextEditorHandles");
2526
2527   TextEditor editor = TextEditor::New();
2528   DALI_TEST_CHECK( editor );
2529
2530   application.GetScene().Add( editor );
2531
2532   editor.SetProperty( TextEditor::Property::TEXT, "This is a long text for the size of the text-editor." );
2533   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
2534   editor.SetProperty( TextEditor::Property::GRAB_HANDLE_IMAGE, HANDLE_IMAGE_FILE_NAME );
2535   editor.SetProperty( TextEditor::Property::SMOOTH_SCROLL, true );
2536
2537   editor.SetProperty( TextEditor::Property::SELECTION_HANDLE_IMAGE_LEFT, Property::Map{ {"filename", HANDLE_LEFT_SELECTION_FILE_NAME } } );
2538   editor.SetProperty( TextEditor::Property::SELECTION_HANDLE_IMAGE_RIGHT, Property::Map{ {"filename", HANDLE_LEFT_SELECTION_FILE_NAME } } );
2539   editor.SetProperty( TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_LEFT, Property::Map{ {"filename", HANDLE_RIGHT_SELECTION_FILE_NAME } } );
2540   editor.SetProperty( TextEditor::Property::SELECTION_HANDLE_PRESSED_IMAGE_RIGHT, Property::Map{ {"filename", HANDLE_RIGHT_SELECTION_FILE_NAME } } );
2541
2542   editor.SetProperty( Actor::Property::SIZE, Vector2( 30.f, 500.f ) );
2543   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2544   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2545
2546   // Avoid a crash when core load gl resources.
2547   application.GetGlAbstraction().SetCheckFramebufferStatusResult( GL_FRAMEBUFFER_COMPLETE );
2548
2549   // Render and notify
2550   application.SendNotification();
2551   application.Render();
2552
2553   // Tap first to get the focus.
2554   TestGenerateTap( application, 3.0f, 25.0f, 100 );
2555
2556   // Render and notify
2557   application.SendNotification();
2558   application.Render();
2559
2560   // Tap to create the grab handle.
2561   TestGenerateTap( application, 3.0f, 25.0f, 700 );
2562
2563   // Render and notify
2564   application.SendNotification();
2565   application.Render();
2566
2567   // Get the active layer where the text's decoration is added.
2568   Actor activeLayer = editor.GetChildAt( 1u );
2569
2570   // Get the handle's actor.
2571   Actor handle = activeLayer.GetChildAt( 1u );
2572   handle.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 100.f ) );
2573
2574   // Render and notify
2575   application.SendNotification();
2576   application.Render();
2577
2578   // Touch the grab handle to set it as pressed.
2579   Vector2 touchPos( 10.0f, 50.0f );
2580   Dali::Integration::TouchEvent event;
2581   event = Dali::Integration::TouchEvent();
2582   event.AddPoint( GetPointDownInside( touchPos ) );
2583   application.ProcessEvent( event );
2584
2585   // Render and notify
2586   application.SendNotification();
2587   application.Render();
2588
2589   // Pan the grab handle
2590   uint32_t time = 100;
2591   TestStartPan( application, Vector2(10.0f, 50.0f), Vector2(10.0f, 50.0f), time );
2592   TestMovePan( application, Vector2(10.0f, 30.0f), time );
2593   TestEndPan( application, Vector2(10.0f, 50.0f), time);
2594   application.SendNotification();
2595   application.Render();
2596
2597
2598   // Release the grab handle.
2599   event = Dali::Integration::TouchEvent();
2600   event.AddPoint( GetPointUpInside( touchPos ) );
2601   application.ProcessEvent( event );
2602
2603   // Render and notify
2604   application.SendNotification();
2605   application.Render();
2606
2607   // Tap first to get the focus.
2608   TestGenerateTap( application, 3.0f, 25.0f, 1400 );
2609
2610   // Render and notify
2611   application.SendNotification();
2612   application.Render();
2613
2614   // Double tap to select a word and create the selection handles.
2615   TestGenerateTap( application, 3.0f, 25.0f, 1500 );
2616
2617   // Render and notify
2618   application.SendNotification();
2619   application.Render();
2620
2621   touchPos = Vector2( 10.0f, 50.0f );
2622
2623   // Touch the left selection handle to set it as pressed.
2624   event = Dali::Integration::TouchEvent();
2625   event.AddPoint( GetPointDownInside( touchPos ) );
2626   application.ProcessEvent( event );
2627
2628   // Render and notify
2629   application.SendNotification();
2630   application.Render();
2631
2632   // Release the left selection handle.
2633   event = Dali::Integration::TouchEvent();
2634   event.AddPoint( GetPointUpInside( touchPos ) );
2635   application.ProcessEvent( event );
2636
2637   // Render and notify
2638   application.SendNotification();
2639   application.Render();
2640
2641   END_TEST;
2642 }
2643
2644 int utcDaliTextEditorUnderPropertyStringP(void)
2645 {
2646   ToolkitTestApplication application;
2647   tet_infoline(" utcDaliTextEditorUnderPropertyStringP");
2648   TextEditor editor = TextEditor::New();
2649   DALI_TEST_CHECK( editor );
2650
2651   std::string underlineSettings1( "{\"enable\":\"true\",\"color\":\"red\",\"height\":\"1\"}" );
2652
2653   application.GetScene().Add( editor );
2654
2655   editor.SetProperty( TextEditor::Property::UNDERLINE, underlineSettings1 );
2656   DALI_TEST_EQUALS( editor.GetProperty<std::string>( TextEditor::Property::UNDERLINE ), underlineSettings1, TEST_LOCATION );
2657
2658   tet_infoline("Set underline settings with a map");
2659   // Check the input underline property
2660   Property::Map underlineMapSet;
2661   Property::Map underlineMapGet;
2662   underlineMapSet.Insert( "enable", true );
2663   underlineMapSet.Insert( "color", Color::BLUE );
2664   underlineMapSet.Insert( "height", 2 );
2665
2666   editor.SetProperty( TextEditor::Property::UNDERLINE, underlineMapSet );
2667   underlineMapGet = editor.GetProperty<Property::Map>( TextEditor::Property::UNDERLINE );
2668   DALI_TEST_EQUALS( underlineMapGet.Count(), underlineMapSet.Count(), TEST_LOCATION );
2669   DALI_TEST_EQUALS( DaliTestCheckMaps( underlineMapSet, underlineMapGet ), true,  TEST_LOCATION );
2670
2671   tet_infoline("Set underline settings with a string");
2672   editor.SetProperty( TextEditor::Property::UNDERLINE, underlineSettings1 );
2673   Property::Value value = editor.GetProperty( TextEditor::Property::UNDERLINE );
2674   std::string result;
2675   value.Get(result);
2676   DALI_TEST_EQUALS( result , underlineSettings1, TEST_LOCATION  );
2677
2678   tet_infoline("Trying to set invalid underline settings, should not update and stay at previous settings");
2679   std::string underlineSettingsVoid( "{\"enable\":\"true\",\"coooolor\":\"blue\",\"heeeight\":\"4\"}" );
2680   editor.SetProperty( TextEditor::Property::UNDERLINE, underlineSettingsVoid );
2681   value = editor.GetProperty( TextEditor::Property::UNDERLINE );
2682   value.Get(result);
2683   DALI_TEST_EQUALS( result , underlineSettings1, TEST_LOCATION  );
2684
2685   END_TEST;
2686 }
2687
2688 int utcDaliTextEditorShadowPropertyStringP(void)
2689 {
2690   ToolkitTestApplication application;
2691   tet_infoline(" utcDaliTextEditorUnderPropertyStringP Setting Shadow propeties by string");
2692
2693   TextEditor editor = TextEditor::New();
2694
2695   std::string shadowSettings( "{\"color\":\"green\",\"offset\":\"2 2\",\"blurRadius\":\"0\"}" );
2696
2697   application.GetScene().Add( editor );
2698
2699   editor.SetProperty( TextEditor::Property::SHADOW, "{\"color\":\"green\",\"offset\":\"2 2\",\"blurRadius\":\"0\"}" );
2700
2701   Property::Value value = editor.GetProperty<std::string>( TextEditor::Property::SHADOW );
2702   std::string result;
2703   value.Get(result);
2704
2705   DALI_TEST_EQUALS( result, shadowSettings, TEST_LOCATION );
2706
2707   END_TEST;
2708 }
2709
2710 int utcDaliTextEditorFontStylePropertyStringP(void)
2711 {
2712   ToolkitTestApplication application;
2713   tet_infoline(" utcDaliTextEditorFontStylePropertyStringP Setting FontStyle propeties by string");
2714
2715   TextEditor editor = TextEditor::New();
2716
2717   std::string fontStyleSettings( "{\"weight\":\"bold\",\"width\":\"condensed\",\"slant\":\"italic\"}" );
2718
2719   application.GetScene().Add( editor );
2720
2721   editor.SetProperty( TextEditor::Property::FONT_STYLE, "{\"weight\":\"bold\",\"width\":\"condensed\",\"slant\":\"italic\"}" );
2722
2723   Property::Value value = editor.GetProperty<std::string>( TextEditor::Property::FONT_STYLE );
2724   std::string result;
2725   value.Get(result);
2726
2727   DALI_TEST_EQUALS( result, fontStyleSettings, TEST_LOCATION );
2728
2729   END_TEST;
2730 }
2731
2732 int utcDaliTextEditorGetPropertyLinecountP(void)
2733 {
2734   ToolkitTestApplication application;
2735
2736   tet_infoline(" utcDaliTextEditorGetPropertyLinecount getting line count property");
2737
2738   int lineCount =0 ;
2739
2740   TextEditor editor = TextEditor::New();
2741   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10) ;
2742   editor.SetProperty( TextEditor::Property::TEXT,
2743                        "TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST TEST ");
2744
2745   application.GetScene().Add( editor );
2746
2747   editor.SetProperty( Actor::Property::SIZE, Vector2( 100.f, 100.f ) );
2748   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2749   DALI_TEST_EQUALS( lineCount, 14, TEST_LOCATION );
2750
2751   editor.SetProperty( Actor::Property::SIZE, Vector2( 50.f, 100.f ) );
2752   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2753   DALI_TEST_EQUALS( lineCount, 28, TEST_LOCATION );
2754
2755   END_TEST;
2756 }
2757
2758 int utcDaliTextEditorScrollStateChangedSignalTest(void)
2759 {
2760
2761   ToolkitTestApplication application;
2762   tet_infoline(" UtcDaliTextEditorScrollStateChangedSignalTest");
2763
2764   TextEditor editor = TextEditor::New();
2765   DALI_TEST_CHECK( editor );
2766
2767   application.GetScene().Add( editor );
2768
2769   editor.SetProperty( TextEditor::Property::POINT_SIZE, 10.f );
2770   editor.SetProperty( Actor::Property::SIZE, Vector2( 50.f, 50.f ) );
2771   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2772   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2773   editor.SetProperty( TextEditor::Property::ENABLE_SCROLL_BAR, true );
2774   editor.SetProperty( Actor::Property::KEYBOARD_FOCUSABLE,true);
2775
2776   bool startedCalled = false;
2777   bool finishedCalled = false;
2778
2779   ScrollStateChangeCallback callback( startedCalled, finishedCalled );
2780   editor.ScrollStateChangedSignal().Connect( &callback, &ScrollStateChangeCallback::Callback );
2781
2782   KeyboardFocusManager::Get().SetCurrentFocusActor( editor );
2783
2784   // Render and notify
2785   application.SendNotification();
2786   application.Render();
2787
2788   editor.SetProperty( TextEditor::Property::TEXT, "Long enough message for TextEditor!");
2789   application.SendNotification();
2790   application.Render(6000);
2791
2792   application.SendNotification();
2793   DALI_TEST_EQUALS( startedCalled, true, TEST_LOCATION );
2794   DALI_TEST_EQUALS( finishedCalled, true, TEST_LOCATION );
2795
2796   END_TEST;
2797 }
2798
2799 int UtcDaliToolkitTextEditorTextWrapMode(void)
2800 {
2801   ToolkitTestApplication application;
2802   tet_infoline(" UtcDaliToolkitTextEditorTextWarpMode");
2803
2804   int lineCount =0 ;
2805
2806   TextEditor editor = TextEditor::New();
2807   editor.SetProperty( Actor::Property::SIZE, Vector2( 150.0f, 300.f ) );
2808   editor.SetProperty( TextEditor::Property::TEXT, "Hello world Hello world" );
2809
2810   application.GetScene().Add( editor );
2811
2812   editor.SetProperty( TextEditor::Property::LINE_WRAP_MODE, "WORD" );
2813   DALI_TEST_EQUALS( editor.GetProperty< int >( TextEditor::Property::LINE_WRAP_MODE ), static_cast< int >( Text::LineWrap::WORD ), TEST_LOCATION );
2814
2815   application.SendNotification();
2816   application.Render();
2817
2818   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2819   DALI_TEST_EQUALS( lineCount, 4, TEST_LOCATION );
2820
2821   editor.SetProperty( TextEditor::Property::LINE_WRAP_MODE, "CHARACTER" );
2822   DALI_TEST_EQUALS( editor.GetProperty< int >( TextEditor::Property::LINE_WRAP_MODE ), static_cast< int >( Text::LineWrap::CHARACTER ), TEST_LOCATION );
2823
2824   application.SendNotification();
2825   application.Render();
2826
2827   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2828   DALI_TEST_EQUALS( lineCount, 3, TEST_LOCATION );
2829
2830   editor.SetProperty( TextEditor::Property::LINE_WRAP_MODE, Text::LineWrap::WORD );
2831   DALI_TEST_EQUALS( editor.GetProperty< int >( TextEditor::Property::LINE_WRAP_MODE ), static_cast< int >( Text::LineWrap::WORD ), TEST_LOCATION );
2832
2833   application.SendNotification();
2834   application.Render();
2835
2836   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2837   DALI_TEST_EQUALS( lineCount, 4, TEST_LOCATION );
2838
2839   editor.SetProperty( TextEditor::Property::LINE_WRAP_MODE, Text::LineWrap::CHARACTER );
2840   DALI_TEST_EQUALS( editor.GetProperty< int >( TextEditor::Property::LINE_WRAP_MODE ), static_cast< int >( Text::LineWrap::CHARACTER ), TEST_LOCATION );
2841
2842   application.SendNotification();
2843   application.Render();
2844
2845   lineCount =  editor.GetProperty<int>( TextEditor::Property::LINE_COUNT );
2846   DALI_TEST_EQUALS( lineCount, 3, TEST_LOCATION );
2847
2848   END_TEST;
2849 }
2850
2851 int UtcDaliTextEditorSetPaddingProperty(void)
2852 {
2853   ToolkitTestApplication application;
2854   tet_infoline("UtcDaliTextEditorSetPaddingProperty\n");
2855
2856   TextEditor editor = TextEditor::New();
2857   DALI_TEST_CHECK( editor );
2858   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2859   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2860   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2861   application.GetScene().Add( editor );
2862
2863   application.SendNotification();
2864   application.Render();
2865
2866   Vector3 originalSize = editor.GetNaturalSize();
2867
2868   editor.SetProperty( Toolkit::Control::Property::PADDING, Extents( 10, 10, 10, 10 ) );
2869
2870   application.SendNotification();
2871   application.Render();
2872
2873   DALI_TEST_EQUALS( editor.GetProperty<Extents>( Toolkit::Control::Property::PADDING ), Extents( 10, 10, 10, 10 ), TEST_LOCATION );
2874
2875   Vector3 paddingAddedSize = editor.GetNaturalSize();
2876
2877   DALI_TEST_EQUALS( originalSize.width + 10 + 10 , paddingAddedSize.width, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2878
2879   DALI_TEST_EQUALS( originalSize.height + 10 + 10 , paddingAddedSize.height, Math::MACHINE_EPSILON_1000, TEST_LOCATION );
2880
2881   END_TEST;
2882 }
2883
2884 int UtcDaliTextEditorEnableShiftSelectionProperty(void)
2885 {
2886   ToolkitTestApplication application;
2887   tet_infoline("UtcDaliTextEditorEnableShiftSelectionProperty");
2888
2889   TextEditor editor = TextEditor::New();
2890   DALI_TEST_CHECK( editor );
2891   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2892   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2893   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2894   application.GetScene().Add( editor );
2895
2896   application.SendNotification();
2897   application.Render();
2898
2899   // The default value of ENABLE_SHIFT_SELECTION is 'true'.
2900   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION ), true, TEST_LOCATION );
2901
2902   // Check the enable shift selection property
2903   editor.SetProperty( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION, false );
2904   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::ENABLE_SHIFT_SELECTION ), false, TEST_LOCATION );
2905
2906   application.SendNotification();
2907   application.Render();
2908
2909   END_TEST;
2910 }
2911
2912 int UtcDaliTextEditorEnableGrabHandleProperty(void)
2913 {
2914   ToolkitTestApplication application;
2915   tet_infoline("UtcDaliTextEditorEnableGrabHandleProperty");
2916
2917   TextEditor editor = TextEditor::New();
2918   DALI_TEST_CHECK( editor );
2919   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2920   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2921   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2922   application.GetScene().Add( editor );
2923
2924   application.SendNotification();
2925   application.Render();
2926
2927   // The default value of ENABLE_GRAB_HANDLE is 'true'.
2928   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::ENABLE_GRAB_HANDLE ), true, TEST_LOCATION );
2929
2930   // Check the enable grab handle property
2931   editor.SetProperty( DevelTextEditor::Property::ENABLE_GRAB_HANDLE, false );
2932   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::ENABLE_GRAB_HANDLE ), false, TEST_LOCATION );
2933
2934   application.SendNotification();
2935   application.Render();
2936
2937   END_TEST;
2938 }
2939
2940 int UtcDaliTextEditorMatchSystemLanguageDirectionProperty(void)
2941 {
2942   ToolkitTestApplication application;
2943   tet_infoline("UtcDaliTextEditorMatchSystemLanguageDirectionProperty");
2944
2945   TextEditor editor = TextEditor::New();
2946   DALI_TEST_CHECK( editor );
2947   editor.SetProperty( Actor::Property::SIZE, Vector2( 300.f, 50.f ) );
2948   editor.SetProperty( Actor::Property::PARENT_ORIGIN, ParentOrigin::TOP_LEFT );
2949   editor.SetProperty( Actor::Property::ANCHOR_POINT, AnchorPoint::TOP_LEFT );
2950   application.GetScene().Add( editor );
2951
2952   application.SendNotification();
2953   application.Render();
2954
2955   // The default value of MATCH_SYSTEM_LANGUAGE_DIRECTION is 'false'.
2956   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION ), false, TEST_LOCATION );
2957
2958   // Check the enable match system language direction property
2959   editor.SetProperty( DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION, true );
2960   DALI_TEST_EQUALS( editor.GetProperty<bool>( DevelTextEditor::Property::MATCH_SYSTEM_LANGUAGE_DIRECTION ), true, TEST_LOCATION );
2961
2962   application.SendNotification();
2963   application.Render();
2964
2965   END_TEST;
2966 }
2967
2968 int UtcDaliTextEditorGetInputMethodContext(void)
2969 {
2970   ToolkitTestApplication application;
2971   tet_infoline("UtcDaliTextEditorGetInputMethodContext");
2972
2973   TextEditor editor = TextEditor::New();
2974   DALI_TEST_CHECK( DevelTextEditor::GetInputMethodContext( editor ) );
2975
2976   END_TEST;
2977 }
2978
2979 int utcDaliTextEditorMaxCharactersReached(void)
2980 {
2981   ToolkitTestApplication application;
2982   tet_infoline("utcDaliTextEditorMaxCharactersReached");
2983
2984   TextEditor editor = TextEditor::New();
2985   DALI_TEST_CHECK( editor );
2986
2987   application.GetScene().Add( editor );
2988
2989   const int maxNumberOfCharacters = 1;
2990   editor.SetProperty( DevelTextEditor::Property::MAX_LENGTH, maxNumberOfCharacters );
2991   DALI_TEST_EQUALS( editor.GetProperty<int>( DevelTextEditor::Property::MAX_LENGTH ), maxNumberOfCharacters, TEST_LOCATION );
2992
2993   editor.SetKeyInputFocus();
2994
2995   // connect to the text changed signal.
2996   ConnectionTracker* testTracker = new ConnectionTracker();
2997   DevelTextEditor::MaxLengthReachedSignal( editor ).Connect(&TestMaxLengthReachedCallback);
2998   bool maxLengthReachedSignal = false;
2999   editor.ConnectSignal( testTracker, "maxLengthReached", CallbackFunctor(&maxLengthReachedSignal) );
3000
3001   gMaxCharactersCallBackCalled = false;
3002
3003   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
3004   application.ProcessEvent( GenerateKey( "a", "", "a", KEY_A_CODE, 0, 0, Integration::KeyEvent::DOWN, "a", DEFAULT_DEVICE_NAME, Device::Class::NONE, Device::Subclass::NONE ) );
3005