36314c9a4f791192ddd39b3c0806f29828301dca
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller.cpp
1 /*
2  * Copyright (c) 2019 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 // CLASS HEADER
19 #include <dali-toolkit/internal/text/text-controller.h>
20
21 // EXTERNAL INCLUDES
22 #include <limits>
23 #include <memory.h>
24 #include <dali/public-api/adaptor-framework/key.h>
25 #include <dali/integration-api/debug.h>
26 #include <dali/devel-api/adaptor-framework/clipboard-event-notifier.h>
27 #include <dali/devel-api/text-abstraction/font-client.h>
28 #include <dali/devel-api/adaptor-framework/key-devel.h>
29
30 // INTERNAL INCLUDES
31 #include <dali-toolkit/public-api/controls/text-controls/placeholder-properties.h>
32 #include <dali-toolkit/internal/text/bidirectional-support.h>
33 #include <dali-toolkit/internal/text/character-set-conversion.h>
34 #include <dali-toolkit/internal/text/layouts/layout-parameters.h>
35 #include <dali-toolkit/internal/text/markup-processor.h>
36 #include <dali-toolkit/internal/text/multi-language-support.h>
37 #include <dali-toolkit/internal/text/text-controller-impl.h>
38 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
39 #include <dali-toolkit/internal/text/text-font-style.h>
40
41 namespace
42 {
43
44 #if defined(DEBUG_ENABLED)
45   Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
46 #endif
47
48 const float MAX_FLOAT = std::numeric_limits<float>::max();
49
50 const std::string EMPTY_STRING("");
51
52 const std::string KEY_C_NAME = "c";
53 const std::string KEY_V_NAME = "v";
54 const std::string KEY_X_NAME = "x";
55
56 const char * const PLACEHOLDER_TEXT = "text";
57 const char * const PLACEHOLDER_TEXT_FOCUSED = "textFocused";
58 const char * const PLACEHOLDER_COLOR = "color";
59 const char * const PLACEHOLDER_FONT_FAMILY = "fontFamily";
60 const char * const PLACEHOLDER_FONT_STYLE = "fontStyle";
61 const char * const PLACEHOLDER_POINT_SIZE = "pointSize";
62 const char * const PLACEHOLDER_PIXEL_SIZE = "pixelSize";
63 const char * const PLACEHOLDER_ELLIPSIS = "ellipsis";
64 const unsigned int MAX_TEXT_LENGTH = 1024u * 32u;
65
66 float ConvertToEven( float value )
67 {
68   int intValue(static_cast<int>( value ));
69   return static_cast<float>( intValue + ( intValue & 1 ) );
70 }
71
72 } // namespace
73
74 namespace Dali
75 {
76
77 namespace Toolkit
78 {
79
80 namespace Text
81 {
82
83 /**
84  * @brief Adds a new font description run for the selected text.
85  *
86  * The new font parameters are added after the call to this method.
87  *
88  * @param[in] eventData The event data pointer.
89  * @param[in] logicalModel The logical model where to add the new font description run.
90  * @param[out] startOfSelectedText Index to the first selected character.
91  * @param[out] lengthOfSelectedText Number of selected characters.
92  */
93 FontDescriptionRun& UpdateSelectionFontStyleRun( EventData* eventData,
94                                                  LogicalModelPtr logicalModel,
95                                                  CharacterIndex& startOfSelectedText,
96                                                  Length& lengthOfSelectedText )
97 {
98   const bool handlesCrossed = eventData->mLeftSelectionPosition > eventData->mRightSelectionPosition;
99
100   // Get start and end position of selection
101   startOfSelectedText = handlesCrossed ? eventData->mRightSelectionPosition : eventData->mLeftSelectionPosition;
102   lengthOfSelectedText = ( handlesCrossed ? eventData->mLeftSelectionPosition : eventData->mRightSelectionPosition ) - startOfSelectedText;
103
104   // Add the font run.
105   const VectorBase::SizeType numberOfRuns = logicalModel->mFontDescriptionRuns.Count();
106   logicalModel->mFontDescriptionRuns.Resize( numberOfRuns + 1u );
107
108   FontDescriptionRun& fontDescriptionRun = *( logicalModel->mFontDescriptionRuns.Begin() + numberOfRuns );
109
110   fontDescriptionRun.characterRun.characterIndex = startOfSelectedText;
111   fontDescriptionRun.characterRun.numberOfCharacters = lengthOfSelectedText;
112
113   // Recalculate the selection highlight as the metrics may have changed.
114   eventData->mUpdateLeftSelectionPosition = true;
115   eventData->mUpdateRightSelectionPosition = true;
116   eventData->mUpdateHighlightBox = true;
117
118   return fontDescriptionRun;
119 }
120
121 // public : Constructor.
122
123 ControllerPtr Controller::New()
124 {
125   return ControllerPtr( new Controller() );
126 }
127
128 ControllerPtr Controller::New( ControlInterface* controlInterface )
129 {
130   return ControllerPtr( new Controller( controlInterface ) );
131 }
132
133 ControllerPtr Controller::New( ControlInterface* controlInterface,
134                                EditableControlInterface* editableControlInterface )
135 {
136   return ControllerPtr( new Controller( controlInterface,
137                                         editableControlInterface ) );
138 }
139
140 // public : Configure the text controller.
141
142 void Controller::EnableTextInput( DecoratorPtr decorator, InputMethodContext& inputMethodContext )
143 {
144   if( !decorator )
145   {
146     delete mImpl->mEventData;
147     mImpl->mEventData = NULL;
148
149     // Nothing else to do.
150     return;
151   }
152
153   if( NULL == mImpl->mEventData )
154   {
155     mImpl->mEventData = new EventData( decorator, inputMethodContext );
156   }
157 }
158
159 void Controller::SetGlyphType( TextAbstraction::GlyphType glyphType )
160 {
161   // Metrics for bitmap & vector based glyphs are different
162   mImpl->mMetrics->SetGlyphType( glyphType );
163
164   // Clear the font-specific data
165   ClearFontData();
166
167   mImpl->RequestRelayout();
168 }
169
170 void Controller::SetMarkupProcessorEnabled( bool enable )
171 {
172   if( enable != mImpl->mMarkupProcessorEnabled )
173   {
174     //If Text was already set, call the SetText again for enabling or disabling markup
175     mImpl->mMarkupProcessorEnabled = enable;
176     std::string text;
177     GetText( text );
178     SetText( text );
179   }
180 }
181
182 bool Controller::IsMarkupProcessorEnabled() const
183 {
184   return mImpl->mMarkupProcessorEnabled;
185 }
186
187 void Controller::SetAutoScrollEnabled( bool enable )
188 {
189   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled[%s] SingleBox[%s]-> [%p]\n", (enable)?"true":"false", ( mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX)?"true":"false", this );
190
191   if( mImpl->mLayoutEngine.GetLayout() == Layout::Engine::SINGLE_LINE_BOX )
192   {
193     if( enable )
194     {
195       DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled for SINGLE_LINE_BOX\n" );
196       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
197                                                                LAYOUT                    |
198                                                                ALIGN                     |
199                                                                UPDATE_LAYOUT_SIZE        |
200                                                                UPDATE_DIRECTION          |
201                                                                REORDER );
202
203     }
204     else
205     {
206       DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetAutoScrollEnabled Disabling autoscroll\n");
207       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
208                                                                LAYOUT                    |
209                                                                ALIGN                     |
210                                                                UPDATE_LAYOUT_SIZE        |
211                                                                REORDER );
212     }
213
214     mImpl->mIsAutoScrollEnabled = enable;
215     mImpl->RequestRelayout();
216   }
217   else
218   {
219     DALI_LOG_WARNING( "Attempted AutoScrolling on a non SINGLE_LINE_BOX, request ignored\n" );
220     mImpl->mIsAutoScrollEnabled = false;
221   }
222 }
223
224 bool Controller::IsAutoScrollEnabled() const
225 {
226   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::IsAutoScrollEnabled[%s]\n", mImpl->mIsAutoScrollEnabled?"true":"false" );
227
228   return mImpl->mIsAutoScrollEnabled;
229 }
230
231 CharacterDirection Controller::GetAutoScrollDirection() const
232 {
233   return mImpl->mIsTextDirectionRTL;
234 }
235
236 float Controller::GetAutoScrollLineAlignment() const
237 {
238   float offset = 0.f;
239
240   if( mImpl->mModel->mVisualModel &&
241       ( 0u != mImpl->mModel->mVisualModel->mLines.Count() ) )
242   {
243     offset = ( *mImpl->mModel->mVisualModel->mLines.Begin() ).alignmentOffset;
244   }
245
246   return offset;
247 }
248
249 void Controller::SetHorizontalScrollEnabled( bool enable )
250 {
251   if( ( NULL != mImpl->mEventData ) &&
252       mImpl->mEventData->mDecorator )
253   {
254     mImpl->mEventData->mDecorator->SetHorizontalScrollEnabled( enable );
255   }
256 }
257 bool Controller::IsHorizontalScrollEnabled() const
258 {
259   if( ( NULL != mImpl->mEventData ) &&
260       mImpl->mEventData->mDecorator )
261   {
262     return mImpl->mEventData->mDecorator->IsHorizontalScrollEnabled();
263   }
264
265   return false;
266 }
267
268 void Controller::SetVerticalScrollEnabled( bool enable )
269 {
270   if( ( NULL != mImpl->mEventData ) &&
271       mImpl->mEventData->mDecorator )
272   {
273     if( mImpl->mEventData->mDecorator )
274     {
275       mImpl->mEventData->mDecorator->SetVerticalScrollEnabled( enable );
276     }
277   }
278 }
279
280 bool Controller::IsVerticalScrollEnabled() const
281 {
282   if( ( NULL != mImpl->mEventData ) &&
283       mImpl->mEventData->mDecorator )
284   {
285     return mImpl->mEventData->mDecorator->IsVerticalScrollEnabled();
286   }
287
288   return false;
289 }
290
291 void Controller::SetSmoothHandlePanEnabled( bool enable )
292 {
293   if( ( NULL != mImpl->mEventData ) &&
294       mImpl->mEventData->mDecorator )
295   {
296     mImpl->mEventData->mDecorator->SetSmoothHandlePanEnabled( enable );
297   }
298 }
299
300 bool Controller::IsSmoothHandlePanEnabled() const
301 {
302   if( ( NULL != mImpl->mEventData ) &&
303       mImpl->mEventData->mDecorator )
304   {
305     return mImpl->mEventData->mDecorator->IsSmoothHandlePanEnabled();
306   }
307
308   return false;
309 }
310
311 void Controller::SetMaximumNumberOfCharacters( Length maxCharacters )
312 {
313   mImpl->mMaximumNumberOfCharacters = std::min( maxCharacters, MAX_TEXT_LENGTH );
314 }
315
316 int Controller::GetMaximumNumberOfCharacters()
317 {
318   return mImpl->mMaximumNumberOfCharacters;
319 }
320
321 void Controller::SetEnableCursorBlink( bool enable )
322 {
323   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "TextInput disabled" );
324
325   if( NULL != mImpl->mEventData )
326   {
327     mImpl->mEventData->mCursorBlinkEnabled = enable;
328
329     if( !enable &&
330         mImpl->mEventData->mDecorator )
331     {
332       mImpl->mEventData->mDecorator->StopCursorBlink();
333     }
334   }
335 }
336
337 bool Controller::GetEnableCursorBlink() const
338 {
339   if( NULL != mImpl->mEventData )
340   {
341     return mImpl->mEventData->mCursorBlinkEnabled;
342   }
343
344   return false;
345 }
346
347 void Controller::SetMultiLineEnabled( bool enable )
348 {
349   const Layout::Engine::Type layout = enable ? Layout::Engine::MULTI_LINE_BOX : Layout::Engine::SINGLE_LINE_BOX;
350
351   if( layout != mImpl->mLayoutEngine.GetLayout() )
352   {
353     // Set the layout type.
354     mImpl->mLayoutEngine.SetLayout( layout );
355
356     // Set the flags to redo the layout operations
357     const OperationsMask layoutOperations =  static_cast<OperationsMask>( LAYOUT             |
358                                                                           UPDATE_LAYOUT_SIZE |
359                                                                           ALIGN              |
360                                                                           REORDER );
361
362     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
363     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | layoutOperations );
364
365     // Need to recalculate natural size
366     mImpl->mRecalculateNaturalSize = true;
367
368     mImpl->RequestRelayout();
369   }
370 }
371
372 bool Controller::IsMultiLineEnabled() const
373 {
374   return Layout::Engine::MULTI_LINE_BOX == mImpl->mLayoutEngine.GetLayout();
375 }
376
377 void Controller::SetHorizontalAlignment( Text::HorizontalAlignment::Type alignment )
378 {
379   if( alignment != mImpl->mModel->mHorizontalAlignment )
380   {
381     // Set the alignment.
382     mImpl->mModel->mHorizontalAlignment = alignment;
383
384     // Set the flag to redo the alignment operation.
385     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
386
387     mImpl->RequestRelayout();
388   }
389 }
390
391 Text::HorizontalAlignment::Type Controller::GetHorizontalAlignment() const
392 {
393   return mImpl->mModel->mHorizontalAlignment;
394 }
395
396 void Controller::SetVerticalAlignment( VerticalAlignment::Type alignment )
397 {
398   if( alignment != mImpl->mModel->mVerticalAlignment )
399   {
400     // Set the alignment.
401     mImpl->mModel->mVerticalAlignment = alignment;
402
403     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | ALIGN );
404
405     mImpl->RequestRelayout();
406   }
407 }
408
409 VerticalAlignment::Type Controller::GetVerticalAlignment() const
410 {
411   return mImpl->mModel->mVerticalAlignment;
412 }
413
414 bool Controller::IsIgnoreSpacesAfterText() const
415 {
416   return mImpl->mModel->mIgnoreSpacesAfterText;
417 }
418
419 void Controller::SetIgnoreSpacesAfterText( bool ignore )
420 {
421   mImpl->mModel->mIgnoreSpacesAfterText = ignore;
422 }
423
424 bool Controller::IsMatchSystemLanguageDirection() const
425 {
426   return mImpl->mModel->mMatchSystemLanguageDirection;
427 }
428
429 void Controller::SetMatchSystemLanguageDirection( bool match )
430 {
431   mImpl->mModel->mMatchSystemLanguageDirection = match;
432 }
433
434 void Controller::SetLayoutDirection( Dali::LayoutDirection::Type layoutDirection )
435 {
436   mImpl->mLayoutDirection = layoutDirection;
437 }
438
439 bool Controller::IsShowingRealText() const
440 {
441   return mImpl->IsShowingRealText();
442 }
443
444
445 void Controller::SetLineWrapMode( Text::LineWrap::Mode lineWrapMode )
446 {
447   if( lineWrapMode != mImpl->mModel->mLineWrapMode )
448   {
449     // Set the text wrap mode.
450     mImpl->mModel->mLineWrapMode = lineWrapMode;
451
452
453     // Update Text layout for applying wrap mode
454     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
455                                                              ALIGN                     |
456                                                              LAYOUT                    |
457                                                              UPDATE_LAYOUT_SIZE        |
458                                                              REORDER                   );
459     mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
460     mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
461     mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
462
463     // Request relayout
464     mImpl->RequestRelayout();
465   }
466 }
467
468 Text::LineWrap::Mode Controller::GetLineWrapMode() const
469 {
470   return mImpl->mModel->mLineWrapMode;
471 }
472
473 void Controller::SetTextElideEnabled( bool enabled )
474 {
475   mImpl->mModel->mElideEnabled = enabled;
476 }
477
478 bool Controller::IsTextElideEnabled() const
479 {
480   return mImpl->mModel->mElideEnabled;
481 }
482
483 void Controller::SetPlaceholderTextElideEnabled( bool enabled )
484 {
485   mImpl->mEventData->mIsPlaceholderElideEnabled = enabled;
486   mImpl->mEventData->mPlaceholderEllipsisFlag = true;
487
488   // Update placeholder if there is no text
489   if( mImpl->IsShowingPlaceholderText() ||
490       ( 0u == mImpl->mModel->mLogicalModel->mText.Count() ) )
491   {
492     ShowPlaceholderText();
493   }
494 }
495
496 bool Controller::IsPlaceholderTextElideEnabled() const
497 {
498   return mImpl->mEventData->mIsPlaceholderElideEnabled;
499 }
500
501 void Controller::SetSelectionEnabled( bool enabled )
502 {
503   mImpl->mEventData->mSelectionEnabled = enabled;
504 }
505
506 bool Controller::IsSelectionEnabled() const
507 {
508   return mImpl->mEventData->mSelectionEnabled;
509 }
510
511 void Controller::SetShiftSelectionEnabled( bool enabled )
512 {
513   mImpl->mEventData->mShiftSelectionFlag = enabled;
514 }
515
516 bool Controller::IsShiftSelectionEnabled() const
517 {
518   return mImpl->mEventData->mShiftSelectionFlag;
519 }
520
521 void Controller::SetGrabHandleEnabled( bool enabled )
522 {
523   mImpl->mEventData->mGrabHandleEnabled = enabled;
524 }
525
526 bool Controller::IsGrabHandleEnabled() const
527 {
528   return mImpl->mEventData->mGrabHandleEnabled;
529 }
530
531 void Controller::SetGrabHandlePopupEnabled(bool enabled)
532 {
533   mImpl->mEventData->mGrabHandlePopupEnabled = enabled;
534 }
535
536 bool Controller::IsGrabHandlePopupEnabled() const
537 {
538   return mImpl->mEventData->mGrabHandlePopupEnabled;
539 }
540
541 // public : Update
542
543 void Controller::SetText( const std::string& text )
544 {
545   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText\n" );
546
547   // Reset keyboard as text changed
548   mImpl->ResetInputMethodContext();
549
550   // Remove the previously set text and style.
551   ResetText();
552
553   // Remove the style.
554   ClearStyleData();
555
556   CharacterIndex lastCursorIndex = 0u;
557
558   if( NULL != mImpl->mEventData )
559   {
560     // If popup shown then hide it by switching to Editing state
561     if( ( EventData::SELECTING == mImpl->mEventData->mState )          ||
562         ( EventData::EDITING_WITH_POPUP == mImpl->mEventData->mState ) ||
563         ( EventData::EDITING_WITH_GRAB_HANDLE == mImpl->mEventData->mState ) ||
564         ( EventData::EDITING_WITH_PASTE_POPUP == mImpl->mEventData->mState ) )
565     {
566       mImpl->ChangeState( EventData::EDITING );
567     }
568   }
569
570   if( !text.empty() )
571   {
572     mImpl->mModel->mVisualModel->SetTextColor( mImpl->mTextColor );
573
574     MarkupProcessData markupProcessData( mImpl->mModel->mLogicalModel->mColorRuns,
575                                          mImpl->mModel->mLogicalModel->mFontDescriptionRuns,
576                                          mImpl->mModel->mLogicalModel->mEmbeddedItems );
577
578     Length textSize = 0u;
579     const uint8_t* utf8 = NULL;
580     if( mImpl->mMarkupProcessorEnabled )
581     {
582       ProcessMarkupString( text, markupProcessData );
583       textSize = markupProcessData.markupProcessedText.size();
584
585       // This is a bit horrible but std::string returns a (signed) char*
586       utf8 = reinterpret_cast<const uint8_t*>( markupProcessData.markupProcessedText.c_str() );
587     }
588     else
589     {
590       textSize = text.size();
591
592       // This is a bit horrible but std::string returns a (signed) char*
593       utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
594     }
595
596     // Limit the text size. If the text size is too large, crash or deadlock will occur.
597     if( textSize > MAX_TEXT_LENGTH )
598     {
599       DALI_LOG_WARNING( "The text size is too large(%d), limit the length to 32,768u\n", textSize );
600       textSize = MAX_TEXT_LENGTH;
601     }
602
603     //  Convert text into UTF-32
604     Vector<Character>& utf32Characters = mImpl->mModel->mLogicalModel->mText;
605     utf32Characters.Resize( textSize );
606
607     // Transform a text array encoded in utf8 into an array encoded in utf32.
608     // It returns the actual number of characters.
609     Length characterCount = Utf8ToUtf32( utf8, textSize, utf32Characters.Begin() );
610     utf32Characters.Resize( characterCount );
611
612     DALI_ASSERT_DEBUG( textSize >= characterCount && "Invalid UTF32 conversion length" );
613     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SetText %p UTF8 size %d, UTF32 size %d\n", this, textSize, mImpl->mModel->mLogicalModel->mText.Count() );
614
615     // The characters to be added.
616     mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
617
618     // To reset the cursor position
619     lastCursorIndex = characterCount;
620
621     // Update the rest of the model during size negotiation
622     mImpl->QueueModifyEvent( ModifyEvent::TEXT_REPLACED );
623
624     // The natural size needs to be re-calculated.
625     mImpl->mRecalculateNaturalSize = true;
626
627     // The text direction needs to be updated.
628     mImpl->mUpdateTextDirection = true;
629
630     // Apply modifications to the model
631     mImpl->mOperationsPending = ALL_OPERATIONS;
632   }
633   else
634   {
635     ShowPlaceholderText();
636   }
637
638   // Resets the cursor position.
639   ResetCursorPosition( lastCursorIndex );
640
641   // Scrolls the text to make the cursor visible.
642   ResetScrollPosition();
643
644   mImpl->RequestRelayout();
645
646   if( NULL != mImpl->mEventData )
647   {
648     // Cancel previously queued events
649     mImpl->mEventData->mEventQueue.clear();
650   }
651
652   // Do this last since it provides callbacks into application code.
653   if( NULL != mImpl->mEditableControlInterface )
654   {
655     mImpl->mEditableControlInterface->TextChanged();
656   }
657 }
658
659 void Controller::GetText( std::string& text ) const
660 {
661   if( !mImpl->IsShowingPlaceholderText() )
662   {
663     // Retrieves the text string.
664     mImpl->GetText( 0u, text );
665   }
666   else
667   {
668     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::GetText %p empty (but showing placeholder)\n", this );
669   }
670 }
671
672 void Controller::SetPlaceholderText( PlaceholderType type, const std::string& text )
673 {
674   if( NULL != mImpl->mEventData )
675   {
676     if( PLACEHOLDER_TYPE_INACTIVE == type )
677     {
678       mImpl->mEventData->mPlaceholderTextInactive = text;
679     }
680     else
681     {
682       mImpl->mEventData->mPlaceholderTextActive = text;
683     }
684
685     // Update placeholder if there is no text
686     if( mImpl->IsShowingPlaceholderText() ||
687         ( 0u == mImpl->mModel->mLogicalModel->mText.Count() ) )
688     {
689       ShowPlaceholderText();
690     }
691   }
692 }
693
694 void Controller::GetPlaceholderText( PlaceholderType type, std::string& text ) const
695 {
696   if( NULL != mImpl->mEventData )
697   {
698     if( PLACEHOLDER_TYPE_INACTIVE == type )
699     {
700       text = mImpl->mEventData->mPlaceholderTextInactive;
701     }
702     else
703     {
704       text = mImpl->mEventData->mPlaceholderTextActive;
705     }
706   }
707 }
708
709 void Controller::UpdateAfterFontChange( const std::string& newDefaultFont )
710 {
711   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::UpdateAfterFontChange\n");
712
713   if( !mImpl->mFontDefaults->familyDefined ) // If user defined font then should not update when system font changes
714   {
715     DALI_LOG_INFO( gLogFilter, Debug::Concise, "Controller::UpdateAfterFontChange newDefaultFont(%s)\n", newDefaultFont.c_str() );
716     mImpl->mFontDefaults->mFontDescription.family = newDefaultFont;
717
718     ClearFontData();
719
720     mImpl->RequestRelayout();
721   }
722 }
723
724 // public : Default style & Input style
725
726 void Controller::SetDefaultFontFamily( const std::string& defaultFontFamily )
727 {
728   if( NULL == mImpl->mFontDefaults )
729   {
730     mImpl->mFontDefaults = new FontDefaults();
731   }
732
733   mImpl->mFontDefaults->mFontDescription.family = defaultFontFamily;
734   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetDefaultFontFamily %s\n", defaultFontFamily.c_str());
735   mImpl->mFontDefaults->familyDefined = !defaultFontFamily.empty();
736
737   // Clear the font-specific data
738   ClearFontData();
739
740   mImpl->RequestRelayout();
741 }
742
743 const std::string& Controller::GetDefaultFontFamily() const
744 {
745   if( NULL != mImpl->mFontDefaults )
746   {
747     return mImpl->mFontDefaults->mFontDescription.family;
748   }
749
750   return EMPTY_STRING;
751 }
752
753 void Controller::SetPlaceholderFontFamily( const std::string& placeholderTextFontFamily )
754 {
755   if( NULL != mImpl->mEventData )
756   {
757     if( NULL == mImpl->mEventData->mPlaceholderFont )
758     {
759       mImpl->mEventData->mPlaceholderFont = new FontDefaults();
760     }
761
762     mImpl->mEventData->mPlaceholderFont->mFontDescription.family = placeholderTextFontFamily;
763     DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::SetPlaceholderFontFamily %s\n", placeholderTextFontFamily.c_str());
764     mImpl->mEventData->mPlaceholderFont->familyDefined = !placeholderTextFontFamily.empty();
765
766     mImpl->RequestRelayout();
767   }
768 }
769
770 const std::string& Controller::GetPlaceholderFontFamily() const
771 {
772   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
773   {
774     return mImpl->mEventData->mPlaceholderFont->mFontDescription.family;
775   }
776
777   return EMPTY_STRING;
778 }
779
780 void Controller::SetDefaultFontWeight( FontWeight weight )
781 {
782   if( NULL == mImpl->mFontDefaults )
783   {
784     mImpl->mFontDefaults = new FontDefaults();
785   }
786
787   mImpl->mFontDefaults->mFontDescription.weight = weight;
788   mImpl->mFontDefaults->weightDefined = true;
789
790   // Clear the font-specific data
791   ClearFontData();
792
793   mImpl->RequestRelayout();
794 }
795
796 bool Controller::IsDefaultFontWeightDefined() const
797 {
798   if( NULL != mImpl->mFontDefaults )
799   {
800     return mImpl->mFontDefaults->weightDefined;
801   }
802
803   return false;
804 }
805
806 FontWeight Controller::GetDefaultFontWeight() const
807 {
808   if( NULL != mImpl->mFontDefaults )
809   {
810     return mImpl->mFontDefaults->mFontDescription.weight;
811   }
812
813   return TextAbstraction::FontWeight::NORMAL;
814 }
815
816 void Controller::SetPlaceholderTextFontWeight( FontWeight weight )
817 {
818   if( NULL != mImpl->mEventData )
819   {
820     if( NULL == mImpl->mEventData->mPlaceholderFont )
821     {
822       mImpl->mEventData->mPlaceholderFont = new FontDefaults();
823     }
824
825     mImpl->mEventData->mPlaceholderFont->mFontDescription.weight = weight;
826     mImpl->mEventData->mPlaceholderFont->weightDefined = true;
827
828     mImpl->RequestRelayout();
829   }
830 }
831
832 bool Controller::IsPlaceholderTextFontWeightDefined() const
833 {
834   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
835   {
836     return mImpl->mEventData->mPlaceholderFont->weightDefined;
837   }
838   return false;
839 }
840
841 FontWeight Controller::GetPlaceholderTextFontWeight() const
842 {
843   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
844   {
845     return mImpl->mEventData->mPlaceholderFont->mFontDescription.weight;
846   }
847
848   return TextAbstraction::FontWeight::NORMAL;
849 }
850
851 void Controller::SetDefaultFontWidth( FontWidth width )
852 {
853   if( NULL == mImpl->mFontDefaults )
854   {
855     mImpl->mFontDefaults = new FontDefaults();
856   }
857
858   mImpl->mFontDefaults->mFontDescription.width = width;
859   mImpl->mFontDefaults->widthDefined = true;
860
861   // Clear the font-specific data
862   ClearFontData();
863
864   mImpl->RequestRelayout();
865 }
866
867 bool Controller::IsDefaultFontWidthDefined() const
868 {
869   if( NULL != mImpl->mFontDefaults )
870   {
871     return mImpl->mFontDefaults->widthDefined;
872   }
873
874   return false;
875 }
876
877 FontWidth Controller::GetDefaultFontWidth() const
878 {
879   if( NULL != mImpl->mFontDefaults )
880   {
881     return mImpl->mFontDefaults->mFontDescription.width;
882   }
883
884   return TextAbstraction::FontWidth::NORMAL;
885 }
886
887 void Controller::SetPlaceholderTextFontWidth( FontWidth width )
888 {
889   if( NULL != mImpl->mEventData )
890   {
891     if( NULL == mImpl->mEventData->mPlaceholderFont )
892     {
893       mImpl->mEventData->mPlaceholderFont = new FontDefaults();
894     }
895
896     mImpl->mEventData->mPlaceholderFont->mFontDescription.width = width;
897     mImpl->mEventData->mPlaceholderFont->widthDefined = true;
898
899     mImpl->RequestRelayout();
900   }
901 }
902
903 bool Controller::IsPlaceholderTextFontWidthDefined() const
904 {
905   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
906   {
907     return mImpl->mEventData->mPlaceholderFont->widthDefined;
908   }
909   return false;
910 }
911
912 FontWidth Controller::GetPlaceholderTextFontWidth() const
913 {
914   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
915   {
916     return mImpl->mEventData->mPlaceholderFont->mFontDescription.width;
917   }
918
919   return TextAbstraction::FontWidth::NORMAL;
920 }
921
922 void Controller::SetDefaultFontSlant( FontSlant slant )
923 {
924   if( NULL == mImpl->mFontDefaults )
925   {
926     mImpl->mFontDefaults = new FontDefaults();
927   }
928
929   mImpl->mFontDefaults->mFontDescription.slant = slant;
930   mImpl->mFontDefaults->slantDefined = true;
931
932   // Clear the font-specific data
933   ClearFontData();
934
935   mImpl->RequestRelayout();
936 }
937
938 bool Controller::IsDefaultFontSlantDefined() const
939 {
940   if( NULL != mImpl->mFontDefaults )
941   {
942     return mImpl->mFontDefaults->slantDefined;
943   }
944   return false;
945 }
946
947 FontSlant Controller::GetDefaultFontSlant() const
948 {
949   if( NULL != mImpl->mFontDefaults )
950   {
951     return mImpl->mFontDefaults->mFontDescription.slant;
952   }
953
954   return TextAbstraction::FontSlant::NORMAL;
955 }
956
957 void Controller::SetPlaceholderTextFontSlant( FontSlant slant )
958 {
959   if( NULL != mImpl->mEventData )
960   {
961     if( NULL == mImpl->mEventData->mPlaceholderFont )
962     {
963       mImpl->mEventData->mPlaceholderFont = new FontDefaults();
964     }
965
966     mImpl->mEventData->mPlaceholderFont->mFontDescription.slant = slant;
967     mImpl->mEventData->mPlaceholderFont->slantDefined = true;
968
969     mImpl->RequestRelayout();
970   }
971 }
972
973 bool Controller::IsPlaceholderTextFontSlantDefined() const
974 {
975   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
976   {
977     return mImpl->mEventData->mPlaceholderFont->slantDefined;
978   }
979   return false;
980 }
981
982 FontSlant Controller::GetPlaceholderTextFontSlant() const
983 {
984   if( ( NULL != mImpl->mEventData ) && ( NULL != mImpl->mEventData->mPlaceholderFont ) )
985   {
986     return mImpl->mEventData->mPlaceholderFont->mFontDescription.slant;
987   }
988
989   return TextAbstraction::FontSlant::NORMAL;
990 }
991
992 void Controller::SetDefaultFontSize( float fontSize, FontSizeType type )
993 {
994   if( NULL == mImpl->mFontDefaults )
995   {
996     mImpl->mFontDefaults = new FontDefaults();
997   }
998
999   switch( type )
1000   {
1001     case POINT_SIZE:
1002     {
1003       mImpl->mFontDefaults->mDefaultPointSize = fontSize;
1004       mImpl->mFontDefaults->sizeDefined = true;
1005       break;
1006     }
1007     case PIXEL_SIZE:
1008     {
1009       // Point size = Pixel size * 72.f / DPI
1010       unsigned int horizontalDpi = 0u;
1011       unsigned int verticalDpi = 0u;
1012       TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1013       fontClient.GetDpi( horizontalDpi, verticalDpi );
1014
1015       mImpl->mFontDefaults->mDefaultPointSize = ( fontSize * 72.f ) / static_cast< float >( horizontalDpi );
1016       mImpl->mFontDefaults->sizeDefined = true;
1017       break;
1018     }
1019   }
1020
1021   // Clear the font-specific data
1022   ClearFontData();
1023
1024   mImpl->RequestRelayout();
1025 }
1026
1027 float Controller::GetDefaultFontSize( FontSizeType type ) const
1028 {
1029   float value = 0.0f;
1030   if( NULL != mImpl->mFontDefaults )
1031   {
1032     switch( type )
1033     {
1034       case POINT_SIZE:
1035       {
1036         value = mImpl->mFontDefaults->mDefaultPointSize;
1037         break;
1038       }
1039       case PIXEL_SIZE:
1040       {
1041         // Pixel size = Point size * DPI / 72.f
1042         unsigned int horizontalDpi = 0u;
1043         unsigned int verticalDpi = 0u;
1044         TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1045         fontClient.GetDpi( horizontalDpi, verticalDpi );
1046
1047         value = mImpl->mFontDefaults->mDefaultPointSize * static_cast< float >( horizontalDpi ) / 72.f;
1048         break;
1049       }
1050     }
1051     return value;
1052   }
1053
1054   return value;
1055 }
1056
1057 void Controller::SetPlaceholderTextFontSize( float fontSize, FontSizeType type )
1058 {
1059   if( NULL != mImpl->mEventData )
1060   {
1061     if( NULL == mImpl->mEventData->mPlaceholderFont )
1062     {
1063       mImpl->mEventData->mPlaceholderFont = new FontDefaults();
1064     }
1065
1066     switch( type )
1067     {
1068       case POINT_SIZE:
1069       {
1070         mImpl->mEventData->mPlaceholderFont->mDefaultPointSize = fontSize;
1071         mImpl->mEventData->mPlaceholderFont->sizeDefined = true;
1072         mImpl->mEventData->mIsPlaceholderPixelSize = false; // Font size flag
1073         break;
1074       }
1075       case PIXEL_SIZE:
1076       {
1077         // Point size = Pixel size * 72.f / DPI
1078         unsigned int horizontalDpi = 0u;
1079         unsigned int verticalDpi = 0u;
1080         TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1081         fontClient.GetDpi( horizontalDpi, verticalDpi );
1082
1083         mImpl->mEventData->mPlaceholderFont->mDefaultPointSize = ( fontSize * 72.f ) / static_cast< float >( horizontalDpi );
1084         mImpl->mEventData->mPlaceholderFont->sizeDefined = true;
1085         mImpl->mEventData->mIsPlaceholderPixelSize = true; // Font size flag
1086         break;
1087       }
1088     }
1089
1090     mImpl->RequestRelayout();
1091   }
1092 }
1093
1094 float Controller::GetPlaceholderTextFontSize( FontSizeType type ) const
1095 {
1096   float value = 0.0f;
1097   if( NULL != mImpl->mEventData )
1098   {
1099     switch( type )
1100     {
1101       case POINT_SIZE:
1102       {
1103         if( NULL != mImpl->mEventData->mPlaceholderFont )
1104         {
1105           value = mImpl->mEventData->mPlaceholderFont->mDefaultPointSize;
1106         }
1107         else
1108         {
1109           // If the placeholder text font size is not set, then return the default font size.
1110           value = GetDefaultFontSize( POINT_SIZE );
1111         }
1112         break;
1113       }
1114       case PIXEL_SIZE:
1115       {
1116         if( NULL != mImpl->mEventData->mPlaceholderFont )
1117         {
1118           // Pixel size = Point size * DPI / 72.f
1119           unsigned int horizontalDpi = 0u;
1120           unsigned int verticalDpi = 0u;
1121           TextAbstraction::FontClient fontClient = TextAbstraction::FontClient::Get();
1122           fontClient.GetDpi( horizontalDpi, verticalDpi );
1123
1124           value = mImpl->mEventData->mPlaceholderFont->mDefaultPointSize * static_cast< float >( horizontalDpi ) / 72.f;
1125         }
1126         else
1127         {
1128           // If the placeholder text font size is not set, then return the default font size.
1129           value = GetDefaultFontSize( PIXEL_SIZE );
1130         }
1131         break;
1132       }
1133     }
1134     return value;
1135   }
1136
1137   return value;
1138 }
1139
1140 void Controller::SetDefaultColor( const Vector4& color )
1141 {
1142   mImpl->mTextColor = color;
1143
1144   if( !mImpl->IsShowingPlaceholderText() )
1145   {
1146     mImpl->mModel->mVisualModel->SetTextColor( color );
1147
1148     mImpl->RequestRelayout();
1149   }
1150 }
1151
1152 const Vector4& Controller::GetDefaultColor() const
1153 {
1154   return mImpl->mTextColor;
1155 }
1156
1157 void Controller::SetPlaceholderTextColor( const Vector4& textColor )
1158 {
1159   if( NULL != mImpl->mEventData )
1160   {
1161     mImpl->mEventData->mPlaceholderTextColor = textColor;
1162   }
1163
1164   if( mImpl->IsShowingPlaceholderText() )
1165   {
1166     mImpl->mModel->mVisualModel->SetTextColor( textColor );
1167     mImpl->RequestRelayout();
1168   }
1169 }
1170
1171 const Vector4& Controller::GetPlaceholderTextColor() const
1172 {
1173   if( NULL != mImpl->mEventData )
1174   {
1175     return mImpl->mEventData->mPlaceholderTextColor;
1176   }
1177
1178   return Color::BLACK;
1179 }
1180
1181 void Controller::SetShadowOffset( const Vector2& shadowOffset )
1182 {
1183   mImpl->mModel->mVisualModel->SetShadowOffset( shadowOffset );
1184
1185   mImpl->RequestRelayout();
1186 }
1187
1188 const Vector2& Controller::GetShadowOffset() const
1189 {
1190   return mImpl->mModel->mVisualModel->GetShadowOffset();
1191 }
1192
1193 void Controller::SetShadowColor( const Vector4& shadowColor )
1194 {
1195   mImpl->mModel->mVisualModel->SetShadowColor( shadowColor );
1196
1197   mImpl->RequestRelayout();
1198 }
1199
1200 const Vector4& Controller::GetShadowColor() const
1201 {
1202   return mImpl->mModel->mVisualModel->GetShadowColor();
1203 }
1204
1205 void Controller::SetShadowBlurRadius( const float& shadowBlurRadius )
1206 {
1207   if ( fabsf( GetShadowBlurRadius() - shadowBlurRadius ) > Math::MACHINE_EPSILON_1 )
1208   {
1209     mImpl->mModel->mVisualModel->SetShadowBlurRadius( shadowBlurRadius );
1210
1211     mImpl->RequestRelayout();
1212   }
1213 }
1214
1215 const float& Controller::GetShadowBlurRadius() const
1216 {
1217   return mImpl->mModel->mVisualModel->GetShadowBlurRadius();
1218 }
1219
1220 void Controller::SetUnderlineColor( const Vector4& color )
1221 {
1222   mImpl->mModel->mVisualModel->SetUnderlineColor( color );
1223
1224   mImpl->RequestRelayout();
1225 }
1226
1227 const Vector4& Controller::GetUnderlineColor() const
1228 {
1229   return mImpl->mModel->mVisualModel->GetUnderlineColor();
1230 }
1231
1232 void Controller::SetUnderlineEnabled( bool enabled )
1233 {
1234   mImpl->mModel->mVisualModel->SetUnderlineEnabled( enabled );
1235
1236   mImpl->RequestRelayout();
1237 }
1238
1239 bool Controller::IsUnderlineEnabled() const
1240 {
1241   return mImpl->mModel->mVisualModel->IsUnderlineEnabled();
1242 }
1243
1244 void Controller::SetUnderlineHeight( float height )
1245 {
1246   mImpl->mModel->mVisualModel->SetUnderlineHeight( height );
1247
1248   mImpl->RequestRelayout();
1249 }
1250
1251 float Controller::GetUnderlineHeight() const
1252 {
1253   return mImpl->mModel->mVisualModel->GetUnderlineHeight();
1254 }
1255
1256 void Controller::SetOutlineColor( const Vector4& color )
1257 {
1258   mImpl->mModel->mVisualModel->SetOutlineColor( color );
1259
1260   mImpl->RequestRelayout();
1261 }
1262
1263 const Vector4& Controller::GetOutlineColor() const
1264 {
1265   return mImpl->mModel->mVisualModel->GetOutlineColor();
1266 }
1267
1268 void Controller::SetOutlineWidth( uint16_t width )
1269 {
1270   mImpl->mModel->mVisualModel->SetOutlineWidth( width );
1271
1272   mImpl->RequestRelayout();
1273 }
1274
1275 uint16_t Controller::GetOutlineWidth() const
1276 {
1277   return mImpl->mModel->mVisualModel->GetOutlineWidth();
1278 }
1279
1280 void Controller::SetBackgroundColor( const Vector4& color )
1281 {
1282   mImpl->mModel->mVisualModel->SetBackgroundColor( color );
1283
1284   mImpl->RequestRelayout();
1285 }
1286
1287 const Vector4& Controller::GetBackgroundColor() const
1288 {
1289   return mImpl->mModel->mVisualModel->GetBackgroundColor();
1290 }
1291
1292 void Controller::SetBackgroundEnabled( bool enabled )
1293 {
1294   mImpl->mModel->mVisualModel->SetBackgroundEnabled( enabled );
1295
1296   mImpl->RequestRelayout();
1297 }
1298
1299 bool Controller::IsBackgroundEnabled() const
1300 {
1301   return mImpl->mModel->mVisualModel->IsBackgroundEnabled();
1302 }
1303
1304 void Controller::SetDefaultEmbossProperties( const std::string& embossProperties )
1305 {
1306   if( NULL == mImpl->mEmbossDefaults )
1307   {
1308     mImpl->mEmbossDefaults = new EmbossDefaults();
1309   }
1310
1311   mImpl->mEmbossDefaults->properties = embossProperties;
1312 }
1313
1314 const std::string& Controller::GetDefaultEmbossProperties() const
1315 {
1316   if( NULL != mImpl->mEmbossDefaults )
1317   {
1318     return mImpl->mEmbossDefaults->properties;
1319   }
1320
1321   return EMPTY_STRING;
1322 }
1323
1324 void Controller::SetDefaultOutlineProperties( const std::string& outlineProperties )
1325 {
1326   if( NULL == mImpl->mOutlineDefaults )
1327   {
1328     mImpl->mOutlineDefaults = new OutlineDefaults();
1329   }
1330
1331   mImpl->mOutlineDefaults->properties = outlineProperties;
1332 }
1333
1334 const std::string& Controller::GetDefaultOutlineProperties() const
1335 {
1336   if( NULL != mImpl->mOutlineDefaults )
1337   {
1338     return mImpl->mOutlineDefaults->properties;
1339   }
1340
1341   return EMPTY_STRING;
1342 }
1343
1344 bool Controller::SetDefaultLineSpacing( float lineSpacing )
1345 {
1346   if( std::abs(lineSpacing - mImpl->mLayoutEngine.GetDefaultLineSpacing()) > Math::MACHINE_EPSILON_1000 )
1347   {
1348     mImpl->mLayoutEngine.SetDefaultLineSpacing(lineSpacing);
1349     mImpl->mRecalculateNaturalSize = true;
1350     return true;
1351   }
1352   return false;
1353 }
1354
1355 float Controller::GetDefaultLineSpacing() const
1356 {
1357   return mImpl->mLayoutEngine.GetDefaultLineSpacing();
1358 }
1359
1360 void Controller::SetInputColor( const Vector4& color )
1361 {
1362   if( NULL != mImpl->mEventData )
1363   {
1364     mImpl->mEventData->mInputStyle.textColor = color;
1365     mImpl->mEventData->mInputStyle.isDefaultColor = false;
1366
1367     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1368     {
1369       const bool handlesCrossed = mImpl->mEventData->mLeftSelectionPosition > mImpl->mEventData->mRightSelectionPosition;
1370
1371       // Get start and end position of selection
1372       const CharacterIndex startOfSelectedText = handlesCrossed ? mImpl->mEventData->mRightSelectionPosition : mImpl->mEventData->mLeftSelectionPosition;
1373       const Length lengthOfSelectedText = ( handlesCrossed ? mImpl->mEventData->mLeftSelectionPosition : mImpl->mEventData->mRightSelectionPosition ) - startOfSelectedText;
1374
1375       // Add the color run.
1376       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mColorRuns.Count();
1377       mImpl->mModel->mLogicalModel->mColorRuns.Resize( numberOfRuns + 1u );
1378
1379       ColorRun& colorRun = *( mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns );
1380       colorRun.color = color;
1381       colorRun.characterRun.characterIndex = startOfSelectedText;
1382       colorRun.characterRun.numberOfCharacters = lengthOfSelectedText;
1383
1384       // Request to relayout.
1385       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | COLOR );
1386       mImpl->RequestRelayout();
1387
1388       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1389       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1390       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1391     }
1392   }
1393 }
1394
1395 const Vector4& Controller::GetInputColor() const
1396 {
1397   if( NULL != mImpl->mEventData )
1398   {
1399     return mImpl->mEventData->mInputStyle.textColor;
1400   }
1401
1402   // Return the default text's color if there is no EventData.
1403   return mImpl->mTextColor;
1404
1405 }
1406
1407 void Controller::SetInputFontFamily( const std::string& fontFamily )
1408 {
1409   if( NULL != mImpl->mEventData )
1410   {
1411     mImpl->mEventData->mInputStyle.familyName = fontFamily;
1412     mImpl->mEventData->mInputStyle.isFamilyDefined = true;
1413
1414     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1415     {
1416       CharacterIndex startOfSelectedText = 0u;
1417       Length lengthOfSelectedText = 0u;
1418       FontDescriptionRun& fontDescriptionRun = UpdateSelectionFontStyleRun( mImpl->mEventData,
1419                                                                             mImpl->mModel->mLogicalModel,
1420                                                                             startOfSelectedText,
1421                                                                             lengthOfSelectedText );
1422
1423       fontDescriptionRun.familyLength = fontFamily.size();
1424       fontDescriptionRun.familyName = new char[fontDescriptionRun.familyLength];
1425       memcpy( fontDescriptionRun.familyName, fontFamily.c_str(), fontDescriptionRun.familyLength );
1426       fontDescriptionRun.familyDefined = true;
1427
1428       // The memory allocated for the font family name is freed when the font description is removed from the logical model.
1429
1430       // Request to relayout.
1431       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
1432                                                                VALIDATE_FONTS            |
1433                                                                SHAPE_TEXT                |
1434                                                                GET_GLYPH_METRICS         |
1435                                                                LAYOUT                    |
1436                                                                UPDATE_LAYOUT_SIZE        |
1437                                                                REORDER                   |
1438                                                                ALIGN );
1439       mImpl->mRecalculateNaturalSize = true;
1440       mImpl->RequestRelayout();
1441
1442       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1443       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1444       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1445
1446       // As the font changes, recalculate the handle positions is needed.
1447       mImpl->mEventData->mUpdateLeftSelectionPosition = true;
1448       mImpl->mEventData->mUpdateRightSelectionPosition = true;
1449       mImpl->mEventData->mUpdateHighlightBox = true;
1450       mImpl->mEventData->mScrollAfterUpdatePosition = true;
1451     }
1452   }
1453 }
1454
1455 const std::string& Controller::GetInputFontFamily() const
1456 {
1457   if( NULL != mImpl->mEventData )
1458   {
1459     return mImpl->mEventData->mInputStyle.familyName;
1460   }
1461
1462   // Return the default font's family if there is no EventData.
1463   return GetDefaultFontFamily();
1464 }
1465
1466 void Controller::SetInputFontWeight( FontWeight weight )
1467 {
1468   if( NULL != mImpl->mEventData )
1469   {
1470     mImpl->mEventData->mInputStyle.weight = weight;
1471     mImpl->mEventData->mInputStyle.isWeightDefined = true;
1472
1473     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1474     {
1475       CharacterIndex startOfSelectedText = 0u;
1476       Length lengthOfSelectedText = 0u;
1477       FontDescriptionRun& fontDescriptionRun = UpdateSelectionFontStyleRun( mImpl->mEventData,
1478                                                                             mImpl->mModel->mLogicalModel,
1479                                                                             startOfSelectedText,
1480                                                                             lengthOfSelectedText );
1481
1482       fontDescriptionRun.weight = weight;
1483       fontDescriptionRun.weightDefined = true;
1484
1485       // Request to relayout.
1486       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
1487                                                                VALIDATE_FONTS            |
1488                                                                SHAPE_TEXT                |
1489                                                                GET_GLYPH_METRICS         |
1490                                                                LAYOUT                    |
1491                                                                UPDATE_LAYOUT_SIZE        |
1492                                                                REORDER                   |
1493                                                                ALIGN );
1494       mImpl->mRecalculateNaturalSize = true;
1495       mImpl->RequestRelayout();
1496
1497       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1498       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1499       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1500
1501       // As the font might change, recalculate the handle positions is needed.
1502       mImpl->mEventData->mUpdateLeftSelectionPosition = true;
1503       mImpl->mEventData->mUpdateRightSelectionPosition = true;
1504       mImpl->mEventData->mUpdateHighlightBox = true;
1505       mImpl->mEventData->mScrollAfterUpdatePosition = true;
1506     }
1507   }
1508 }
1509
1510 bool Controller::IsInputFontWeightDefined() const
1511 {
1512   bool defined = false;
1513
1514   if( NULL != mImpl->mEventData )
1515   {
1516     defined = mImpl->mEventData->mInputStyle.isWeightDefined;
1517   }
1518
1519   return defined;
1520 }
1521
1522 FontWeight Controller::GetInputFontWeight() const
1523 {
1524   if( NULL != mImpl->mEventData )
1525   {
1526     return mImpl->mEventData->mInputStyle.weight;
1527   }
1528
1529   return GetDefaultFontWeight();
1530 }
1531
1532 void Controller::SetInputFontWidth( FontWidth width )
1533 {
1534   if( NULL != mImpl->mEventData )
1535   {
1536     mImpl->mEventData->mInputStyle.width = width;
1537     mImpl->mEventData->mInputStyle.isWidthDefined = true;
1538
1539     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1540     {
1541       CharacterIndex startOfSelectedText = 0u;
1542       Length lengthOfSelectedText = 0u;
1543       FontDescriptionRun& fontDescriptionRun = UpdateSelectionFontStyleRun( mImpl->mEventData,
1544                                                                             mImpl->mModel->mLogicalModel,
1545                                                                             startOfSelectedText,
1546                                                                             lengthOfSelectedText );
1547
1548       fontDescriptionRun.width = width;
1549       fontDescriptionRun.widthDefined = true;
1550
1551       // Request to relayout.
1552       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
1553                                                                VALIDATE_FONTS            |
1554                                                                SHAPE_TEXT                |
1555                                                                GET_GLYPH_METRICS         |
1556                                                                LAYOUT                    |
1557                                                                UPDATE_LAYOUT_SIZE        |
1558                                                                REORDER                   |
1559                                                                ALIGN );
1560       mImpl->mRecalculateNaturalSize = true;
1561       mImpl->RequestRelayout();
1562
1563       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1564       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1565       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1566
1567       // As the font might change, recalculate the handle positions is needed.
1568       mImpl->mEventData->mUpdateLeftSelectionPosition = true;
1569       mImpl->mEventData->mUpdateRightSelectionPosition = true;
1570       mImpl->mEventData->mUpdateHighlightBox = true;
1571       mImpl->mEventData->mScrollAfterUpdatePosition = true;
1572     }
1573   }
1574 }
1575
1576 bool Controller::IsInputFontWidthDefined() const
1577 {
1578   bool defined = false;
1579
1580   if( NULL != mImpl->mEventData )
1581   {
1582     defined = mImpl->mEventData->mInputStyle.isWidthDefined;
1583   }
1584
1585   return defined;
1586 }
1587
1588 FontWidth Controller::GetInputFontWidth() const
1589 {
1590   if( NULL != mImpl->mEventData )
1591   {
1592     return mImpl->mEventData->mInputStyle.width;
1593   }
1594
1595   return GetDefaultFontWidth();
1596 }
1597
1598 void Controller::SetInputFontSlant( FontSlant slant )
1599 {
1600   if( NULL != mImpl->mEventData )
1601   {
1602     mImpl->mEventData->mInputStyle.slant = slant;
1603     mImpl->mEventData->mInputStyle.isSlantDefined = true;
1604
1605     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1606     {
1607       CharacterIndex startOfSelectedText = 0u;
1608       Length lengthOfSelectedText = 0u;
1609       FontDescriptionRun& fontDescriptionRun = UpdateSelectionFontStyleRun( mImpl->mEventData,
1610                                                                             mImpl->mModel->mLogicalModel,
1611                                                                             startOfSelectedText,
1612                                                                             lengthOfSelectedText );
1613
1614       fontDescriptionRun.slant = slant;
1615       fontDescriptionRun.slantDefined = true;
1616
1617       // Request to relayout.
1618       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
1619                                                                VALIDATE_FONTS            |
1620                                                                SHAPE_TEXT                |
1621                                                                GET_GLYPH_METRICS         |
1622                                                                LAYOUT                    |
1623                                                                UPDATE_LAYOUT_SIZE        |
1624                                                                REORDER                   |
1625                                                                ALIGN );
1626       mImpl->mRecalculateNaturalSize = true;
1627       mImpl->RequestRelayout();
1628
1629       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1630       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1631       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1632
1633       // As the font might change, recalculate the handle positions is needed.
1634       mImpl->mEventData->mUpdateLeftSelectionPosition = true;
1635       mImpl->mEventData->mUpdateRightSelectionPosition = true;
1636       mImpl->mEventData->mUpdateHighlightBox = true;
1637       mImpl->mEventData->mScrollAfterUpdatePosition = true;
1638     }
1639   }
1640 }
1641
1642 bool Controller::IsInputFontSlantDefined() const
1643 {
1644   bool defined = false;
1645
1646   if( NULL != mImpl->mEventData )
1647   {
1648     defined = mImpl->mEventData->mInputStyle.isSlantDefined;
1649   }
1650
1651   return defined;
1652 }
1653
1654 FontSlant Controller::GetInputFontSlant() const
1655 {
1656   if( NULL != mImpl->mEventData )
1657   {
1658     return mImpl->mEventData->mInputStyle.slant;
1659   }
1660
1661   return GetDefaultFontSlant();
1662 }
1663
1664 void Controller::SetInputFontPointSize( float size )
1665 {
1666   if( NULL != mImpl->mEventData )
1667   {
1668     mImpl->mEventData->mInputStyle.size = size;
1669     mImpl->mEventData->mInputStyle.isSizeDefined = true;
1670
1671     if( EventData::SELECTING == mImpl->mEventData->mState || EventData::EDITING == mImpl->mEventData->mState || EventData::INACTIVE == mImpl->mEventData->mState )
1672     {
1673       CharacterIndex startOfSelectedText = 0u;
1674       Length lengthOfSelectedText = 0u;
1675       FontDescriptionRun& fontDescriptionRun = UpdateSelectionFontStyleRun( mImpl->mEventData,
1676                                                                             mImpl->mModel->mLogicalModel,
1677                                                                             startOfSelectedText,
1678                                                                             lengthOfSelectedText );
1679
1680       fontDescriptionRun.size = static_cast<PointSize26Dot6>( size * 64.f );
1681       fontDescriptionRun.sizeDefined = true;
1682
1683       // Request to relayout.
1684       mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
1685                                                                VALIDATE_FONTS            |
1686                                                                SHAPE_TEXT                |
1687                                                                GET_GLYPH_METRICS         |
1688                                                                LAYOUT                    |
1689                                                                UPDATE_LAYOUT_SIZE        |
1690                                                                REORDER                   |
1691                                                                ALIGN );
1692       mImpl->mRecalculateNaturalSize = true;
1693       mImpl->RequestRelayout();
1694
1695       mImpl->mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
1696       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
1697       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = lengthOfSelectedText;
1698
1699       // As the font might change, recalculate the handle positions is needed.
1700       mImpl->mEventData->mUpdateLeftSelectionPosition = true;
1701       mImpl->mEventData->mUpdateRightSelectionPosition = true;
1702       mImpl->mEventData->mUpdateHighlightBox = true;
1703       mImpl->mEventData->mScrollAfterUpdatePosition = true;
1704     }
1705   }
1706 }
1707
1708 float Controller::GetInputFontPointSize() const
1709 {
1710   if( NULL != mImpl->mEventData )
1711   {
1712     return mImpl->mEventData->mInputStyle.size;
1713   }
1714
1715   // Return the default font's point size if there is no EventData.
1716   return GetDefaultFontSize( Text::Controller::POINT_SIZE );
1717 }
1718
1719 void Controller::SetInputLineSpacing( float lineSpacing )
1720 {
1721   if( NULL != mImpl->mEventData )
1722   {
1723     mImpl->mEventData->mInputStyle.lineSpacing = lineSpacing;
1724     mImpl->mEventData->mInputStyle.isLineSpacingDefined = true;
1725   }
1726 }
1727
1728 float Controller::GetInputLineSpacing() const
1729 {
1730   if( NULL != mImpl->mEventData )
1731   {
1732     return mImpl->mEventData->mInputStyle.lineSpacing;
1733   }
1734
1735   return 0.f;
1736 }
1737
1738 void Controller::SetInputShadowProperties( const std::string& shadowProperties )
1739 {
1740   if( NULL != mImpl->mEventData )
1741   {
1742     mImpl->mEventData->mInputStyle.shadowProperties = shadowProperties;
1743   }
1744 }
1745
1746 const std::string& Controller::GetInputShadowProperties() const
1747 {
1748   if( NULL != mImpl->mEventData )
1749   {
1750     return mImpl->mEventData->mInputStyle.shadowProperties;
1751   }
1752
1753   return EMPTY_STRING;
1754 }
1755
1756 void Controller::SetInputUnderlineProperties( const std::string& underlineProperties )
1757 {
1758   if( NULL != mImpl->mEventData )
1759   {
1760     mImpl->mEventData->mInputStyle.underlineProperties = underlineProperties;
1761   }
1762 }
1763
1764 const std::string& Controller::GetInputUnderlineProperties() const
1765 {
1766   if( NULL != mImpl->mEventData )
1767   {
1768     return mImpl->mEventData->mInputStyle.underlineProperties;
1769   }
1770
1771   return EMPTY_STRING;
1772 }
1773
1774 void Controller::SetInputEmbossProperties( const std::string& embossProperties )
1775 {
1776   if( NULL != mImpl->mEventData )
1777   {
1778     mImpl->mEventData->mInputStyle.embossProperties = embossProperties;
1779   }
1780 }
1781
1782 const std::string& Controller::GetInputEmbossProperties() const
1783 {
1784   if( NULL != mImpl->mEventData )
1785   {
1786     return mImpl->mEventData->mInputStyle.embossProperties;
1787   }
1788
1789   return GetDefaultEmbossProperties();
1790 }
1791
1792 void Controller::SetInputOutlineProperties( const std::string& outlineProperties )
1793 {
1794   if( NULL != mImpl->mEventData )
1795   {
1796     mImpl->mEventData->mInputStyle.outlineProperties = outlineProperties;
1797   }
1798 }
1799
1800 const std::string& Controller::GetInputOutlineProperties() const
1801 {
1802   if( NULL != mImpl->mEventData )
1803   {
1804     return mImpl->mEventData->mInputStyle.outlineProperties;
1805   }
1806
1807   return GetDefaultOutlineProperties();
1808 }
1809
1810 void Controller::SetInputModePassword( bool passwordInput )
1811 {
1812   if( NULL != mImpl->mEventData )
1813   {
1814     mImpl->mEventData->mPasswordInput = passwordInput;
1815   }
1816 }
1817
1818 bool Controller::IsInputModePassword()
1819 {
1820   if( NULL != mImpl->mEventData )
1821   {
1822     return mImpl->mEventData->mPasswordInput;
1823   }
1824   return false;
1825 }
1826
1827 void Controller::SetNoTextDoubleTapAction( NoTextTap::Action action )
1828 {
1829   if( NULL != mImpl->mEventData )
1830   {
1831     mImpl->mEventData->mDoubleTapAction = action;
1832   }
1833 }
1834
1835 Controller::NoTextTap::Action Controller::GetNoTextDoubleTapAction() const
1836 {
1837   NoTextTap::Action action = NoTextTap::NO_ACTION;
1838
1839   if( NULL != mImpl->mEventData )
1840   {
1841     action = mImpl->mEventData->mDoubleTapAction;
1842   }
1843
1844   return action;
1845 }
1846
1847 void Controller::SetNoTextLongPressAction( NoTextTap::Action action )
1848 {
1849   if( NULL != mImpl->mEventData )
1850   {
1851     mImpl->mEventData->mLongPressAction = action;
1852   }
1853 }
1854
1855 Controller::NoTextTap::Action Controller::GetNoTextLongPressAction() const
1856 {
1857   NoTextTap::Action action = NoTextTap::NO_ACTION;
1858
1859   if( NULL != mImpl->mEventData )
1860   {
1861     action = mImpl->mEventData->mLongPressAction;
1862   }
1863
1864   return action;
1865 }
1866
1867 bool Controller::IsUnderlineSetByString()
1868 {
1869   return mImpl->mUnderlineSetByString;
1870 }
1871
1872 void Controller::UnderlineSetByString( bool setByString )
1873 {
1874   mImpl->mUnderlineSetByString = setByString;
1875 }
1876
1877 bool Controller::IsShadowSetByString()
1878 {
1879   return mImpl->mShadowSetByString;
1880 }
1881
1882 void Controller::ShadowSetByString( bool setByString )
1883 {
1884   mImpl->mShadowSetByString = setByString;
1885 }
1886
1887 bool Controller::IsOutlineSetByString()
1888 {
1889   return mImpl->mOutlineSetByString;
1890 }
1891
1892 void Controller::OutlineSetByString( bool setByString )
1893 {
1894   mImpl->mOutlineSetByString = setByString;
1895 }
1896
1897 bool Controller::IsFontStyleSetByString()
1898 {
1899   return mImpl->mFontStyleSetByString;
1900 }
1901
1902 void Controller::FontStyleSetByString( bool setByString )
1903 {
1904   mImpl->mFontStyleSetByString = setByString;
1905 }
1906
1907 // public : Queries & retrieves.
1908
1909 Layout::Engine& Controller::GetLayoutEngine()
1910 {
1911   return mImpl->mLayoutEngine;
1912 }
1913
1914 View& Controller::GetView()
1915 {
1916   return mImpl->mView;
1917 }
1918
1919 Vector3 Controller::GetNaturalSize()
1920 {
1921   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetNaturalSize\n" );
1922   Vector3 naturalSize;
1923
1924   // Make sure the model is up-to-date before layouting
1925   ProcessModifyEvents();
1926
1927   if( mImpl->mRecalculateNaturalSize )
1928   {
1929     // Operations that can be done only once until the text changes.
1930     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
1931                                                                            GET_SCRIPTS       |
1932                                                                            VALIDATE_FONTS    |
1933                                                                            GET_LINE_BREAKS   |
1934                                                                            GET_WORD_BREAKS   |
1935                                                                            BIDI_INFO         |
1936                                                                            SHAPE_TEXT        |
1937                                                                            GET_GLYPH_METRICS );
1938
1939     // Set the update info to relayout the whole text.
1940     mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
1941     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
1942
1943     // Make sure the model is up-to-date before layouting
1944     mImpl->UpdateModel( onlyOnceOperations );
1945
1946     // Layout the text for the new width.
1947     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | LAYOUT | REORDER );
1948
1949     // Store the actual control's size to restore later.
1950     const Size actualControlSize = mImpl->mModel->mVisualModel->mControlSize;
1951
1952     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
1953                 static_cast<OperationsMask>( onlyOnceOperations |
1954                                              LAYOUT | REORDER ),
1955                 naturalSize.GetVectorXY() );
1956
1957     // Do not do again the only once operations.
1958     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
1959
1960     // Do the size related operations again.
1961     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
1962                                                                         ALIGN  |
1963                                                                         REORDER );
1964     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
1965
1966     // Stores the natural size to avoid recalculate it again
1967     // unless the text/style changes.
1968     mImpl->mModel->mVisualModel->SetNaturalSize( naturalSize.GetVectorXY() );
1969
1970     mImpl->mRecalculateNaturalSize = false;
1971
1972     // Clear the update info. This info will be set the next time the text is updated.
1973     mImpl->mTextUpdateInfo.Clear();
1974     mImpl->mTextUpdateInfo.mClearAll = true;
1975
1976     // Restore the actual control's size.
1977     mImpl->mModel->mVisualModel->mControlSize = actualControlSize;
1978
1979     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize calculated %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
1980   }
1981   else
1982   {
1983     naturalSize = mImpl->mModel->mVisualModel->GetNaturalSize();
1984
1985     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetNaturalSize cached %f,%f,%f\n", naturalSize.x, naturalSize.y, naturalSize.z );
1986   }
1987
1988   naturalSize.x = ConvertToEven( naturalSize.x );
1989   naturalSize.y = ConvertToEven( naturalSize.y );
1990
1991   return naturalSize;
1992 }
1993
1994 float Controller::GetHeightForWidth( float width )
1995 {
1996   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::GetHeightForWidth %p width %f\n", this, width );
1997   // Make sure the model is up-to-date before layouting
1998   ProcessModifyEvents();
1999
2000   Size layoutSize;
2001   if( fabsf( width - mImpl->mModel->mVisualModel->mControlSize.width ) > Math::MACHINE_EPSILON_1000 ||
2002                                                          mImpl->mTextUpdateInfo.mFullRelayoutNeeded ||
2003                                                          mImpl->mTextUpdateInfo.mClearAll            )
2004   {
2005     // Operations that can be done only once until the text changes.
2006     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
2007                                                                            GET_SCRIPTS       |
2008                                                                            VALIDATE_FONTS    |
2009                                                                            GET_LINE_BREAKS   |
2010                                                                            GET_WORD_BREAKS   |
2011                                                                            BIDI_INFO         |
2012                                                                            SHAPE_TEXT        |
2013                                                                            GET_GLYPH_METRICS );
2014
2015     // Set the update info to relayout the whole text.
2016     mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
2017     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
2018
2019     // Make sure the model is up-to-date before layouting
2020     mImpl->UpdateModel( onlyOnceOperations );
2021
2022
2023     // Layout the text for the new width.
2024     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | LAYOUT );
2025
2026     // Store the actual control's width.
2027     const float actualControlWidth = mImpl->mModel->mVisualModel->mControlSize.width;
2028
2029     DoRelayout( Size( width, MAX_FLOAT ),
2030                 static_cast<OperationsMask>( onlyOnceOperations |
2031                                              LAYOUT ),
2032                 layoutSize );
2033
2034     // Do not do again the only once operations.
2035     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
2036
2037     // Do the size related operations again.
2038     const OperationsMask sizeOperations =  static_cast<OperationsMask>( LAYOUT |
2039                                                                         ALIGN  |
2040                                                                         REORDER );
2041
2042     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending | sizeOperations );
2043
2044     // Clear the update info. This info will be set the next time the text is updated.
2045     mImpl->mTextUpdateInfo.Clear();
2046     mImpl->mTextUpdateInfo.mClearAll = true;
2047
2048     // Restore the actual control's width.
2049     mImpl->mModel->mVisualModel->mControlSize.width = actualControlWidth;
2050
2051     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth calculated %f\n", layoutSize.height );
2052   }
2053   else
2054   {
2055     layoutSize = mImpl->mModel->mVisualModel->GetLayoutSize();
2056     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::GetHeightForWidth cached %f\n", layoutSize.height );
2057   }
2058
2059   return layoutSize.height;
2060 }
2061
2062 int Controller::GetLineCount( float width )
2063 {
2064   GetHeightForWidth( width );
2065   int numberofLines = mImpl->mModel->GetNumberOfLines();
2066   return numberofLines;
2067 }
2068
2069 const ModelInterface* const Controller::GetTextModel() const
2070 {
2071   return mImpl->mModel.Get();
2072 }
2073
2074 float Controller::GetScrollAmountByUserInput()
2075 {
2076   float scrollAmount = 0.0f;
2077
2078   if (NULL != mImpl->mEventData && mImpl->mEventData->mCheckScrollAmount)
2079   {
2080     scrollAmount = mImpl->mModel->mScrollPosition.y -  mImpl->mModel->mScrollPositionLast.y;
2081     mImpl->mEventData->mCheckScrollAmount = false;
2082   }
2083   return scrollAmount;
2084 }
2085
2086 bool Controller::GetTextScrollInfo( float& scrollPosition, float& controlHeight, float& layoutHeight )
2087 {
2088   const Vector2& layout = mImpl->mModel->mVisualModel->GetLayoutSize();
2089   bool isScrolled;
2090
2091   controlHeight = mImpl->mModel->mVisualModel->mControlSize.height;
2092   layoutHeight = layout.height;
2093   scrollPosition = mImpl->mModel->mScrollPosition.y;
2094   isScrolled = !Equals( mImpl->mModel->mScrollPosition.y, mImpl->mModel->mScrollPositionLast.y, Math::MACHINE_EPSILON_1 );
2095   return isScrolled;
2096 }
2097
2098 void Controller::SetHiddenInputOption(const Property::Map& options )
2099 {
2100   if( NULL == mImpl->mHiddenInput )
2101   {
2102     mImpl->mHiddenInput = new HiddenText( this );
2103   }
2104   mImpl->mHiddenInput->SetProperties(options);
2105 }
2106
2107 void Controller::GetHiddenInputOption(Property::Map& options )
2108 {
2109   if( NULL != mImpl->mHiddenInput )
2110   {
2111     mImpl->mHiddenInput->GetProperties(options);
2112   }
2113 }
2114
2115 void Controller::SetPlaceholderProperty( const Property::Map& map )
2116 {
2117   const Property::Map::SizeType count = map.Count();
2118
2119   for( Property::Map::SizeType position = 0; position < count; ++position )
2120   {
2121     KeyValuePair keyValue = map.GetKeyValue( position );
2122     Property::Key& key = keyValue.first;
2123     Property::Value& value = keyValue.second;
2124
2125     if( key == Toolkit::Text::PlaceHolder::Property::TEXT  || key == PLACEHOLDER_TEXT )
2126     {
2127       std::string text = "";
2128       value.Get( text );
2129       SetPlaceholderText( Controller::PLACEHOLDER_TYPE_INACTIVE, text );
2130     }
2131     else if( key == Toolkit::Text::PlaceHolder::Property::TEXT_FOCUSED || key == PLACEHOLDER_TEXT_FOCUSED )
2132     {
2133       std::string text = "";
2134       value.Get( text );
2135       SetPlaceholderText( Controller::PLACEHOLDER_TYPE_ACTIVE, text );
2136     }
2137     else if( key == Toolkit::Text::PlaceHolder::Property::COLOR || key == PLACEHOLDER_COLOR )
2138     {
2139       Vector4 textColor;
2140       value.Get( textColor );
2141       if( GetPlaceholderTextColor() != textColor )
2142       {
2143         SetPlaceholderTextColor( textColor );
2144       }
2145     }
2146     else if( key == Toolkit::Text::PlaceHolder::Property::FONT_FAMILY || key == PLACEHOLDER_FONT_FAMILY )
2147     {
2148       std::string fontFamily = "";
2149       value.Get( fontFamily );
2150       SetPlaceholderFontFamily( fontFamily );
2151     }
2152     else if( key == Toolkit::Text::PlaceHolder::Property::FONT_STYLE || key == PLACEHOLDER_FONT_STYLE )
2153     {
2154       SetFontStyleProperty( this, value, Text::FontStyle::PLACEHOLDER );
2155     }
2156     else if( key == Toolkit::Text::PlaceHolder::Property::POINT_SIZE || key == PLACEHOLDER_POINT_SIZE )
2157     {
2158       float pointSize;
2159       value.Get( pointSize );
2160       if( !Equals( GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE ), pointSize ) )
2161       {
2162         SetPlaceholderTextFontSize( pointSize, Text::Controller::POINT_SIZE );
2163       }
2164     }
2165     else if( key == Toolkit::Text::PlaceHolder::Property::PIXEL_SIZE || key == PLACEHOLDER_PIXEL_SIZE )
2166     {
2167       float pixelSize;
2168       value.Get( pixelSize );
2169       if( !Equals( GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE ), pixelSize ) )
2170       {
2171         SetPlaceholderTextFontSize( pixelSize, Text::Controller::PIXEL_SIZE );
2172       }
2173     }
2174     else if( key == Toolkit::Text::PlaceHolder::Property::ELLIPSIS || key == PLACEHOLDER_ELLIPSIS )
2175     {
2176       bool ellipsis;
2177       value.Get( ellipsis );
2178       SetPlaceholderTextElideEnabled( ellipsis );
2179     }
2180   }
2181 }
2182
2183 void Controller::GetPlaceholderProperty( Property::Map& map )
2184 {
2185   if( NULL != mImpl->mEventData )
2186   {
2187     if( !mImpl->mEventData->mPlaceholderTextActive.empty() )
2188     {
2189       map[ Text::PlaceHolder::Property::TEXT_FOCUSED ] = mImpl->mEventData->mPlaceholderTextActive;
2190     }
2191     if( !mImpl->mEventData->mPlaceholderTextInactive.empty() )
2192     {
2193       map[ Text::PlaceHolder::Property::TEXT ] = mImpl->mEventData->mPlaceholderTextInactive;
2194     }
2195
2196     map[ Text::PlaceHolder::Property::COLOR ] = mImpl->mEventData->mPlaceholderTextColor;
2197     map[ Text::PlaceHolder::Property::FONT_FAMILY ] = GetPlaceholderFontFamily();
2198
2199     Property::Value fontStyleMapGet;
2200     GetFontStyleProperty( this, fontStyleMapGet, Text::FontStyle::PLACEHOLDER );
2201     map[ Text::PlaceHolder::Property::FONT_STYLE ] = fontStyleMapGet;
2202
2203     // Choose font size : POINT_SIZE or PIXEL_SIZE
2204     if( !mImpl->mEventData->mIsPlaceholderPixelSize )
2205     {
2206       map[ Text::PlaceHolder::Property::POINT_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::POINT_SIZE );
2207     }
2208     else
2209     {
2210       map[ Text::PlaceHolder::Property::PIXEL_SIZE ] = GetPlaceholderTextFontSize( Text::Controller::PIXEL_SIZE );
2211     }
2212
2213     if( mImpl->mEventData->mPlaceholderEllipsisFlag )
2214     {
2215       map[ Text::PlaceHolder::Property::ELLIPSIS ] = IsPlaceholderTextElideEnabled();
2216     }
2217   }
2218 }
2219
2220 Toolkit::DevelText::TextDirection::Type Controller::GetTextDirection()
2221 {
2222   // Make sure the model is up-to-date before layouting
2223   ProcessModifyEvents();
2224
2225   if ( mImpl->mUpdateTextDirection )
2226   {
2227     // Operations that can be done only once until the text changes.
2228     const OperationsMask onlyOnceOperations = static_cast<OperationsMask>( CONVERT_TO_UTF32  |
2229                                                                            GET_SCRIPTS       |
2230                                                                            VALIDATE_FONTS    |
2231                                                                            GET_LINE_BREAKS   |
2232                                                                            GET_WORD_BREAKS   |
2233                                                                            BIDI_INFO         |
2234                                                                            SHAPE_TEXT        |
2235                                                                            GET_GLYPH_METRICS );
2236
2237     // Set the update info to relayout the whole text.
2238     mImpl->mTextUpdateInfo.mParagraphCharacterIndex = 0u;
2239     mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters = mImpl->mModel->mLogicalModel->mText.Count();
2240
2241     // Make sure the model is up-to-date before layouting
2242     mImpl->UpdateModel( onlyOnceOperations );
2243
2244     Vector3 naturalSize;
2245     DoRelayout( Size( MAX_FLOAT, MAX_FLOAT ),
2246                 static_cast<OperationsMask>( onlyOnceOperations |
2247                                              LAYOUT | REORDER | UPDATE_DIRECTION ),
2248                 naturalSize.GetVectorXY() );
2249
2250     // Do not do again the only once operations.
2251     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending & ~onlyOnceOperations );
2252
2253     // Clear the update info. This info will be set the next time the text is updated.
2254     mImpl->mTextUpdateInfo.Clear();
2255
2256     mImpl->mUpdateTextDirection = false;
2257   }
2258
2259   return mImpl->mIsTextDirectionRTL ? Toolkit::DevelText::TextDirection::RIGHT_TO_LEFT : Toolkit::DevelText::TextDirection::LEFT_TO_RIGHT;
2260 }
2261
2262 Toolkit::DevelText::VerticalLineAlignment::Type Controller::GetVerticalLineAlignment() const
2263 {
2264   return mImpl->mModel->GetVerticalLineAlignment();
2265 }
2266
2267 void Controller::SetVerticalLineAlignment( Toolkit::DevelText::VerticalLineAlignment::Type alignment )
2268 {
2269   mImpl->mModel->mVerticalLineAlignment = alignment;
2270 }
2271
2272 // public : Relayout.
2273
2274 Controller::UpdateTextType Controller::Relayout( const Size& size, Dali::LayoutDirection::Type layoutDirection )
2275 {
2276   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::Relayout %p size %f,%f, autoScroll[%s]\n", this, size.width, size.height, mImpl->mIsAutoScrollEnabled ?"true":"false"  );
2277
2278   UpdateTextType updateTextType = NONE_UPDATED;
2279
2280   if( ( size.width < Math::MACHINE_EPSILON_1000 ) || ( size.height < Math::MACHINE_EPSILON_1000 ) )
2281   {
2282     if( 0u != mImpl->mModel->mVisualModel->mGlyphPositions.Count() )
2283     {
2284       mImpl->mModel->mVisualModel->mGlyphPositions.Clear();
2285       updateTextType = MODEL_UPDATED;
2286     }
2287
2288     // Clear the update info. This info will be set the next time the text is updated.
2289     mImpl->mTextUpdateInfo.Clear();
2290
2291     // Not worth to relayout if width or height is equal to zero.
2292     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout (skipped)\n" );
2293
2294     return updateTextType;
2295   }
2296
2297   // Whether a new size has been set.
2298   const bool newSize = ( size != mImpl->mModel->mVisualModel->mControlSize );
2299
2300   if( newSize )
2301   {
2302     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "new size (previous size %f,%f)\n", mImpl->mModel->mVisualModel->mControlSize.width, mImpl->mModel->mVisualModel->mControlSize.height );
2303
2304     if( ( 0 == mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd ) &&
2305         ( 0 == mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters ) &&
2306         ( ( mImpl->mModel->mVisualModel->mControlSize.width < Math::MACHINE_EPSILON_1000 ) || ( mImpl->mModel->mVisualModel->mControlSize.height < Math::MACHINE_EPSILON_1000 ) ) )
2307     {
2308       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mModel->mLogicalModel->mText.Count();
2309     }
2310
2311     // Layout operations that need to be done if the size changes.
2312     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
2313                                                              LAYOUT                    |
2314                                                              ALIGN                     |
2315                                                              UPDATE_LAYOUT_SIZE        |
2316                                                              REORDER );
2317     // Set the update info to relayout the whole text.
2318     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
2319     mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
2320
2321     // Store the size used to layout the text.
2322     mImpl->mModel->mVisualModel->mControlSize = size;
2323   }
2324
2325   // Whether there are modify events.
2326   if( 0u != mImpl->mModifyEvents.Count() )
2327   {
2328     // Style operations that need to be done if the text is modified.
2329     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
2330                                                              COLOR );
2331   }
2332
2333   // Set the update info to elide the text.
2334   if( mImpl->mModel->mElideEnabled ||
2335       ( ( NULL != mImpl->mEventData ) && mImpl->mEventData->mIsPlaceholderElideEnabled ) )
2336   {
2337     // Update Text layout for applying elided
2338     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
2339                                                              ALIGN                     |
2340                                                              LAYOUT                    |
2341                                                              UPDATE_LAYOUT_SIZE        |
2342                                                              REORDER );
2343     mImpl->mTextUpdateInfo.mFullRelayoutNeeded = true;
2344     mImpl->mTextUpdateInfo.mCharacterIndex = 0u;
2345   }
2346
2347   if( mImpl->mModel->mMatchSystemLanguageDirection  && mImpl->mLayoutDirection != layoutDirection )
2348   {
2349     // Clear the update info. This info will be set the next time the text is updated.
2350     mImpl->mTextUpdateInfo.mClearAll = true;
2351     // Apply modifications to the model
2352     // Shape the text again is needed because characters like '()[]{}' have to be mirrored and the glyphs generated again.
2353     mImpl->mOperationsPending = static_cast<OperationsMask>( mImpl->mOperationsPending |
2354                                                              GET_GLYPH_METRICS         |
2355                                                              SHAPE_TEXT                |
2356                                                              UPDATE_DIRECTION          |
2357                                                              LAYOUT                    |
2358                                                              BIDI_INFO                 |
2359                                                              REORDER );
2360     mImpl->mLayoutDirection = layoutDirection;
2361   }
2362
2363   // Make sure the model is up-to-date before layouting.
2364   ProcessModifyEvents();
2365   bool updated = mImpl->UpdateModel( mImpl->mOperationsPending );
2366
2367   // Layout the text.
2368   Size layoutSize;
2369   updated = DoRelayout( size,
2370                         mImpl->mOperationsPending,
2371                         layoutSize ) || updated;
2372
2373
2374   if( updated )
2375   {
2376     updateTextType = MODEL_UPDATED;
2377   }
2378
2379   // Do not re-do any operation until something changes.
2380   mImpl->mOperationsPending = NO_OPERATION;
2381   mImpl->mModel->mScrollPositionLast = mImpl->mModel->mScrollPosition;
2382
2383   // Whether the text control is editable
2384   const bool isEditable = NULL != mImpl->mEventData;
2385
2386   // Keep the current offset as it will be used to update the decorator's positions (if the size changes).
2387   Vector2 offset;
2388   if( newSize && isEditable )
2389   {
2390     offset = mImpl->mModel->mScrollPosition;
2391   }
2392
2393   if( !isEditable || !IsMultiLineEnabled() )
2394   {
2395     // After doing the text layout, the vertical offset to place the actor in the desired position can be calculated.
2396     CalculateVerticalOffset( size );
2397   }
2398
2399   if( isEditable )
2400   {
2401     if( newSize )
2402     {
2403       // If there is a new size, the scroll position needs to be clamped.
2404       mImpl->ClampHorizontalScroll( layoutSize );
2405
2406       // Update the decorator's positions is needed if there is a new size.
2407       mImpl->mEventData->mDecorator->UpdatePositions( mImpl->mModel->mScrollPosition - offset );
2408     }
2409
2410     // Move the cursor, grab handle etc.
2411     if( mImpl->ProcessInputEvents() )
2412     {
2413       updateTextType = static_cast<UpdateTextType>( updateTextType | DECORATOR_UPDATED );
2414     }
2415   }
2416
2417   // Clear the update info. This info will be set the next time the text is updated.
2418   mImpl->mTextUpdateInfo.Clear();
2419   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::Relayout\n" );
2420
2421   return updateTextType;
2422 }
2423
2424 void Controller::RequestRelayout()
2425 {
2426   mImpl->RequestRelayout();
2427 }
2428
2429 // public : Input style change signals.
2430
2431 bool Controller::IsInputStyleChangedSignalsQueueEmpty()
2432 {
2433   return ( NULL == mImpl->mEventData ) || ( 0u == mImpl->mEventData->mInputStyleChangedQueue.Count() );
2434 }
2435
2436 void Controller::ProcessInputStyleChangedSignals()
2437 {
2438   if( NULL == mImpl->mEventData )
2439   {
2440     // Nothing to do.
2441     return;
2442   }
2443
2444   for( Vector<InputStyle::Mask>::ConstIterator it = mImpl->mEventData->mInputStyleChangedQueue.Begin(),
2445          endIt = mImpl->mEventData->mInputStyleChangedQueue.End();
2446        it != endIt;
2447        ++it )
2448   {
2449     const InputStyle::Mask mask = *it;
2450
2451     if( NULL != mImpl->mEditableControlInterface )
2452     {
2453       // Emit the input style changed signal.
2454       mImpl->mEditableControlInterface->InputStyleChanged( mask );
2455     }
2456   }
2457
2458   mImpl->mEventData->mInputStyleChangedQueue.Clear();
2459 }
2460
2461 // public : Text-input Event Queuing.
2462
2463 void Controller::KeyboardFocusGainEvent()
2464 {
2465   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusGainEvent" );
2466
2467   if( NULL != mImpl->mEventData )
2468   {
2469     if( ( EventData::INACTIVE == mImpl->mEventData->mState ) ||
2470         ( EventData::INTERRUPTED == mImpl->mEventData->mState ) )
2471     {
2472       mImpl->ChangeState( EventData::EDITING );
2473       mImpl->mEventData->mUpdateCursorPosition = true; //If editing started without tap event, cursor update must be triggered.
2474       mImpl->mEventData->mUpdateInputStyle = true;
2475       mImpl->mEventData->mScrollAfterUpdatePosition = true;
2476     }
2477     mImpl->NotifyInputMethodContextMultiLineStatus();
2478     if( mImpl->IsShowingPlaceholderText() )
2479     {
2480       // Show alternative placeholder-text when editing
2481       ShowPlaceholderText();
2482     }
2483
2484     mImpl->RequestRelayout();
2485   }
2486 }
2487
2488 void Controller::KeyboardFocusLostEvent()
2489 {
2490   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyboardFocusLostEvent" );
2491
2492   if( NULL != mImpl->mEventData )
2493   {
2494     if( EventData::INTERRUPTED != mImpl->mEventData->mState )
2495     {
2496       mImpl->ChangeState( EventData::INACTIVE );
2497
2498       if( !mImpl->IsShowingRealText() )
2499       {
2500         // Revert to regular placeholder-text when not editing
2501         ShowPlaceholderText();
2502       }
2503     }
2504   }
2505   mImpl->RequestRelayout();
2506 }
2507
2508 bool Controller::KeyEvent( const Dali::KeyEvent& keyEvent )
2509 {
2510   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected KeyEvent" );
2511
2512   bool textChanged = false;
2513   bool relayoutNeeded = false;
2514
2515   if( ( NULL != mImpl->mEventData ) &&
2516       ( keyEvent.state == KeyEvent::Down ) )
2517   {
2518     int keyCode = keyEvent.keyCode;
2519     const std::string& keyString = keyEvent.keyPressed;
2520     const std::string keyName = keyEvent.keyPressedName;
2521
2522     const bool isNullKey = ( 0 == keyCode ) && ( keyString.empty() );
2523
2524     // Pre-process to separate modifying events from non-modifying input events.
2525     if( isNullKey )
2526     {
2527       // In some platforms arrive key events with no key code.
2528       // Do nothing.
2529       return false;
2530     }
2531     else if( Dali::DALI_KEY_ESCAPE == keyCode || Dali::DALI_KEY_BACK == keyCode  || Dali::DALI_KEY_SEARCH == keyCode )
2532     {
2533       // Do nothing
2534       return false;
2535     }
2536     else if( ( Dali::DALI_KEY_CURSOR_LEFT  == keyCode ) ||
2537              ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode ) ||
2538              ( Dali::DALI_KEY_CURSOR_UP    == keyCode ) ||
2539              ( Dali::DALI_KEY_CURSOR_DOWN  == keyCode ) )
2540     {
2541       // If don't have any text, do nothing.
2542       if( !mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters )
2543       {
2544         return false;
2545       }
2546
2547       uint32_t cursorPosition = mImpl->mEventData->mPrimaryCursorPosition;
2548       uint32_t numberOfCharacters = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
2549       uint32_t cursorLine = mImpl->mModel->mVisualModel->GetLineOfCharacter( cursorPosition );
2550       uint32_t numberOfLines = mImpl->mModel->GetNumberOfLines();
2551
2552       // Logic to determine whether this text control will lose focus or not.
2553       if( ( Dali::DALI_KEY_CURSOR_LEFT == keyCode && 0 == cursorPosition && !keyEvent.IsShiftModifier() ) ||
2554           ( Dali::DALI_KEY_CURSOR_RIGHT == keyCode && numberOfCharacters == cursorPosition && !keyEvent.IsShiftModifier() ) ||
2555           ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && cursorLine == numberOfLines -1 ) ||
2556           ( Dali::DALI_KEY_CURSOR_DOWN == keyCode && numberOfCharacters == cursorPosition && cursorLine -1 == numberOfLines -1 ) ||
2557           ( Dali::DALI_KEY_CURSOR_UP == keyCode && cursorLine == 0 ) ||
2558           ( Dali::DALI_KEY_CURSOR_UP == keyCode && numberOfCharacters == cursorPosition && cursorLine == 1 ) )
2559       {
2560         // Release the active highlight.
2561         if( mImpl->mEventData->mState == EventData::SELECTING )
2562         {
2563           mImpl->ChangeState( EventData::EDITING );
2564
2565           // Update selection position.
2566           mImpl->mEventData->mLeftSelectionPosition = mImpl->mEventData->mPrimaryCursorPosition;
2567           mImpl->mEventData->mRightSelectionPosition = mImpl->mEventData->mPrimaryCursorPosition;
2568           mImpl->mEventData->mUpdateCursorPosition = true;
2569           mImpl->RequestRelayout();
2570         }
2571         return false;
2572       }
2573
2574       mImpl->mEventData->mCheckScrollAmount = true;
2575       Event event( Event::CURSOR_KEY_EVENT );
2576       event.p1.mInt = keyCode;
2577       event.p2.mBool = keyEvent.IsShiftModifier();
2578       mImpl->mEventData->mEventQueue.push_back( event );
2579
2580       // Will request for relayout.
2581       relayoutNeeded = true;
2582     }
2583     else if ( Dali::DevelKey::DALI_KEY_CONTROL_LEFT == keyCode || Dali::DevelKey::DALI_KEY_CONTROL_RIGHT == keyCode )
2584     {
2585       // Left or Right Control key event is received before Ctrl-C/V/X key event is received
2586       // If not handle it here, any selected text will be deleted
2587
2588       // Do nothing
2589       return false;
2590     }
2591     else if ( keyEvent.IsCtrlModifier() )
2592     {
2593       bool consumed = false;
2594       if (keyName == KEY_C_NAME)
2595       {
2596         // Ctrl-C to copy the selected text
2597         TextPopupButtonTouched( Toolkit::TextSelectionPopup::COPY );
2598         consumed = true;
2599       }
2600       else if (keyName == KEY_V_NAME)
2601       {
2602         // Ctrl-V to paste the copied text
2603         TextPopupButtonTouched( Toolkit::TextSelectionPopup::PASTE );
2604         consumed = true;
2605       }
2606       else if (keyName == KEY_X_NAME)
2607       {
2608         // Ctrl-X to cut the selected text
2609         TextPopupButtonTouched( Toolkit::TextSelectionPopup::CUT );
2610         consumed = true;
2611       }
2612       return consumed;
2613     }
2614     else if( ( Dali::DALI_KEY_BACKSPACE == keyCode ) ||
2615              ( Dali::DevelKey::DALI_KEY_DELETE == keyCode ) )
2616     {
2617       textChanged = DeleteEvent( keyCode );
2618
2619       // Will request for relayout.
2620       relayoutNeeded = true;
2621     }
2622     else if( IsKey( keyEvent, Dali::DALI_KEY_POWER ) ||
2623              IsKey( keyEvent, Dali::DALI_KEY_MENU ) ||
2624              IsKey( keyEvent, Dali::DALI_KEY_HOME ) )
2625     {
2626       // Power key/Menu/Home key behaviour does not allow edit mode to resume.
2627       mImpl->ChangeState( EventData::INACTIVE );
2628
2629       // Will request for relayout.
2630       relayoutNeeded = true;
2631
2632       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
2633     }
2634     else if( ( Dali::DALI_KEY_SHIFT_LEFT == keyCode ) || ( Dali::DALI_KEY_SHIFT_RIGHT == keyCode ) )
2635     {
2636       // DALI_KEY_SHIFT_LEFT or DALI_KEY_SHIFT_RIGHT is the key code for Shift. It's sent (by the InputMethodContext?) when the predictive text is enabled
2637       // and a character is typed after the type of a upper case latin character.
2638
2639       // Do nothing.
2640       return false;
2641     }
2642     else if( ( Dali::DALI_KEY_VOLUME_UP == keyCode ) || ( Dali::DALI_KEY_VOLUME_DOWN == keyCode ) )
2643     {
2644       // This branch avoids calling the InsertText() method of the 'else' branch which can delete selected text.
2645       // Do nothing.
2646       return false;
2647     }
2648     else
2649     {
2650       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::KeyEvent %p keyString %s\n", this, keyString.c_str() );
2651
2652       if( !keyString.empty() )
2653       {
2654         // InputMethodContext is no longer handling key-events
2655         mImpl->ClearPreEditFlag();
2656
2657         InsertText( keyString, COMMIT );
2658
2659         textChanged = true;
2660
2661         // Will request for relayout.
2662         relayoutNeeded = true;
2663       }
2664
2665     }
2666
2667     if ( ( mImpl->mEventData->mState != EventData::INTERRUPTED ) &&
2668          ( mImpl->mEventData->mState != EventData::INACTIVE ) &&
2669          ( !isNullKey ) &&
2670          ( Dali::DALI_KEY_SHIFT_LEFT != keyCode ) &&
2671          ( Dali::DALI_KEY_SHIFT_RIGHT != keyCode ) &&
2672          ( Dali::DALI_KEY_VOLUME_UP != keyCode ) &&
2673          ( Dali::DALI_KEY_VOLUME_DOWN != keyCode ) )
2674     {
2675       // Should not change the state if the key is the shift send by the InputMethodContext.
2676       // Otherwise, when the state is SELECTING the text controller can't send the right
2677       // surrounding info to the InputMethodContext.
2678       mImpl->ChangeState( EventData::EDITING );
2679
2680       // Will request for relayout.
2681       relayoutNeeded = true;
2682     }
2683
2684     if( relayoutNeeded )
2685     {
2686       mImpl->RequestRelayout();
2687     }
2688   }
2689
2690   if( textChanged &&
2691       ( NULL != mImpl->mEditableControlInterface ) )
2692   {
2693     // Do this last since it provides callbacks into application code
2694     mImpl->mEditableControlInterface->TextChanged();
2695   }
2696
2697   return true;
2698 }
2699
2700 void Controller::TapEvent( unsigned int tapCount, float x, float y )
2701 {
2702   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected TapEvent" );
2703
2704   if( NULL != mImpl->mEventData )
2705   {
2706     DALI_LOG_INFO( gLogFilter, Debug::Concise, "TapEvent state:%d \n", mImpl->mEventData->mState );
2707     EventData::State state( mImpl->mEventData->mState );
2708     bool relayoutNeeded( false );   // to avoid unnecessary relayouts when tapping an empty text-field
2709
2710     if( mImpl->IsClipboardVisible() )
2711     {
2712       if( EventData::INACTIVE == state || EventData::EDITING == state)
2713       {
2714         mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
2715       }
2716       relayoutNeeded = true;
2717     }
2718     else if( 1u == tapCount )
2719     {
2720       if( EventData::EDITING_WITH_POPUP == state || EventData::EDITING_WITH_PASTE_POPUP == state )
2721       {
2722         mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );  // If Popup shown hide it here so can be shown again if required.
2723       }
2724
2725       if( mImpl->IsShowingRealText() && ( EventData::INACTIVE != state ) )
2726       {
2727         mImpl->ChangeState( EventData::EDITING_WITH_GRAB_HANDLE );
2728         relayoutNeeded = true;
2729       }
2730       else
2731       {
2732         if( mImpl->IsShowingPlaceholderText() && !mImpl->IsFocusedPlaceholderAvailable() )
2733         {
2734           // Hide placeholder text
2735           ResetText();
2736         }
2737
2738         if( EventData::INACTIVE == state )
2739         {
2740           mImpl->ChangeState( EventData::EDITING );
2741         }
2742         else if( !mImpl->IsClipboardEmpty() )
2743         {
2744           mImpl->ChangeState( EventData::EDITING_WITH_POPUP );
2745         }
2746         relayoutNeeded = true;
2747       }
2748     }
2749     else if( 2u == tapCount )
2750     {
2751       if( mImpl->mEventData->mSelectionEnabled &&
2752           mImpl->IsShowingRealText() )
2753       {
2754         relayoutNeeded = true;
2755         mImpl->mEventData->mIsLeftHandleSelected = true;
2756         mImpl->mEventData->mIsRightHandleSelected = true;
2757       }
2758     }
2759
2760     // Handles & cursors must be repositioned after Relayout() i.e. after the Model has been updated
2761     if( relayoutNeeded )
2762     {
2763       Event event( Event::TAP_EVENT );
2764       event.p1.mUint = tapCount;
2765       event.p2.mFloat = x;
2766       event.p3.mFloat = y;
2767       mImpl->mEventData->mEventQueue.push_back( event );
2768
2769       mImpl->RequestRelayout();
2770     }
2771   }
2772
2773   // Reset keyboard as tap event has occurred.
2774   mImpl->ResetInputMethodContext();
2775 }
2776
2777 void Controller::PanEvent( Gesture::State state, const Vector2& displacement )
2778 {
2779   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected PanEvent" );
2780
2781   if( NULL != mImpl->mEventData )
2782   {
2783     Event event( Event::PAN_EVENT );
2784     event.p1.mInt = state;
2785     event.p2.mFloat = displacement.x;
2786     event.p3.mFloat = displacement.y;
2787     mImpl->mEventData->mEventQueue.push_back( event );
2788
2789     mImpl->RequestRelayout();
2790   }
2791 }
2792
2793 void Controller::LongPressEvent( Gesture::State state, float x, float y  )
2794 {
2795   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected LongPressEvent" );
2796
2797   if( ( state == Gesture::Started ) &&
2798       ( NULL != mImpl->mEventData ) )
2799   {
2800     // The 1st long-press on inactive text-field is treated as tap
2801     if( EventData::INACTIVE == mImpl->mEventData->mState )
2802     {
2803       mImpl->ChangeState( EventData::EDITING );
2804
2805       Event event( Event::TAP_EVENT );
2806       event.p1.mUint = 1;
2807       event.p2.mFloat = x;
2808       event.p3.mFloat = y;
2809       mImpl->mEventData->mEventQueue.push_back( event );
2810
2811       mImpl->RequestRelayout();
2812     }
2813     else if( !mImpl->IsShowingRealText() )
2814     {
2815       Event event( Event::LONG_PRESS_EVENT );
2816       event.p1.mInt = state;
2817       event.p2.mFloat = x;
2818       event.p3.mFloat = y;
2819       mImpl->mEventData->mEventQueue.push_back( event );
2820       mImpl->RequestRelayout();
2821     }
2822     else if( !mImpl->IsClipboardVisible() )
2823     {
2824       // Reset the InputMethodContext to commit the pre-edit before selecting the text.
2825       mImpl->ResetInputMethodContext();
2826
2827       Event event( Event::LONG_PRESS_EVENT );
2828       event.p1.mInt = state;
2829       event.p2.mFloat = x;
2830       event.p3.mFloat = y;
2831       mImpl->mEventData->mEventQueue.push_back( event );
2832       mImpl->RequestRelayout();
2833
2834       mImpl->mEventData->mIsLeftHandleSelected = true;
2835       mImpl->mEventData->mIsRightHandleSelected = true;
2836     }
2837   }
2838 }
2839
2840 void Controller::SelectEvent( float x, float y, bool selectAll )
2841 {
2842   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::SelectEvent\n" );
2843
2844   if( NULL != mImpl->mEventData )
2845   {
2846     if( selectAll )
2847     {
2848       Event event( Event::SELECT_ALL );
2849       mImpl->mEventData->mEventQueue.push_back( event );
2850     }
2851     else
2852     {
2853       Event event( Event::SELECT );
2854       event.p2.mFloat = x;
2855       event.p3.mFloat = y;
2856       mImpl->mEventData->mEventQueue.push_back( event );
2857     }
2858
2859     mImpl->mEventData->mCheckScrollAmount = true;
2860     mImpl->mEventData->mIsLeftHandleSelected = true;
2861     mImpl->mEventData->mIsRightHandleSelected = true;
2862     mImpl->RequestRelayout();
2863   }
2864 }
2865
2866 InputMethodContext::CallbackData Controller::OnInputMethodContextEvent( InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent )
2867 {
2868   // Whether the text needs to be relaid-out.
2869   bool requestRelayout = false;
2870
2871   // Whether to retrieve the text and cursor position to be sent to the InputMethodContext.
2872   bool retrieveText = false;
2873   bool retrieveCursor = false;
2874
2875   switch( inputMethodContextEvent.eventName )
2876   {
2877     case InputMethodContext::COMMIT:
2878     {
2879       InsertText( inputMethodContextEvent.predictiveString, Text::Controller::COMMIT );
2880       requestRelayout = true;
2881       retrieveCursor = true;
2882       break;
2883     }
2884     case InputMethodContext::PRE_EDIT:
2885     {
2886       InsertText( inputMethodContextEvent.predictiveString, Text::Controller::PRE_EDIT );
2887       requestRelayout = true;
2888       retrieveCursor = true;
2889       break;
2890     }
2891     case InputMethodContext::DELETE_SURROUNDING:
2892     {
2893       const bool textDeleted = RemoveText( inputMethodContextEvent.cursorOffset,
2894                                            inputMethodContextEvent.numberOfChars,
2895                                            DONT_UPDATE_INPUT_STYLE );
2896
2897       if( textDeleted )
2898       {
2899         if( ( 0u != mImpl->mModel->mLogicalModel->mText.Count() ) ||
2900             !mImpl->IsPlaceholderAvailable() )
2901         {
2902           mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
2903         }
2904         else
2905         {
2906           ShowPlaceholderText();
2907         }
2908         mImpl->mEventData->mUpdateCursorPosition = true;
2909         mImpl->mEventData->mScrollAfterDelete = true;
2910
2911         requestRelayout = true;
2912       }
2913       break;
2914     }
2915     case InputMethodContext::GET_SURROUNDING:
2916     {
2917       retrieveText = true;
2918       retrieveCursor = true;
2919       break;
2920     }
2921     case InputMethodContext::PRIVATE_COMMAND:
2922     {
2923       // PRIVATECOMMAND event is just for getting the private command message
2924       retrieveText = true;
2925       retrieveCursor = true;
2926       break;
2927     }
2928     case InputMethodContext::VOID:
2929     {
2930       // do nothing
2931       break;
2932     }
2933   } // end switch
2934
2935   if( requestRelayout )
2936   {
2937     mImpl->mOperationsPending = ALL_OPERATIONS;
2938     mImpl->RequestRelayout();
2939   }
2940
2941   std::string text;
2942   CharacterIndex cursorPosition = 0u;
2943   Length numberOfWhiteSpaces = 0u;
2944
2945   if( retrieveCursor )
2946   {
2947     numberOfWhiteSpaces = mImpl->GetNumberOfWhiteSpaces( 0u );
2948
2949     cursorPosition = mImpl->GetLogicalCursorPosition();
2950
2951     if( cursorPosition < numberOfWhiteSpaces )
2952     {
2953       cursorPosition = 0u;
2954     }
2955     else
2956     {
2957       cursorPosition -= numberOfWhiteSpaces;
2958     }
2959   }
2960
2961   if( retrieveText )
2962   {
2963     if( !mImpl->IsShowingPlaceholderText() )
2964     {
2965       // Retrieves the normal text string.
2966       mImpl->GetText( numberOfWhiteSpaces, text );
2967     }
2968     else
2969     {
2970       // When the current text is Placeholder Text, the surrounding text should be empty string.
2971       // It means DALi should send empty string ("") to IME.
2972       text = "";
2973     }
2974   }
2975
2976   InputMethodContext::CallbackData callbackData( ( retrieveText || retrieveCursor ), cursorPosition, text, false );
2977
2978   if( requestRelayout &&
2979       ( NULL != mImpl->mEditableControlInterface ) )
2980   {
2981     // Do this last since it provides callbacks into application code
2982     mImpl->mEditableControlInterface->TextChanged();
2983   }
2984
2985   return callbackData;
2986 }
2987
2988 void Controller::PasteClipboardItemEvent()
2989 {
2990   // Retrieve the clipboard contents first
2991   ClipboardEventNotifier notifier( ClipboardEventNotifier::Get() );
2992   std::string stringToPaste( notifier.GetContent() );
2993
2994   // Commit the current pre-edit text; the contents of the clipboard should be appended
2995   mImpl->ResetInputMethodContext();
2996
2997   // Temporary disable hiding clipboard
2998   mImpl->SetClipboardHideEnable( false );
2999
3000   // Paste
3001   PasteText( stringToPaste );
3002
3003   mImpl->SetClipboardHideEnable( true );
3004 }
3005
3006 // protected : Inherit from Text::Decorator::ControllerInterface.
3007
3008 void Controller::GetTargetSize( Vector2& targetSize )
3009 {
3010   targetSize = mImpl->mModel->mVisualModel->mControlSize;
3011 }
3012
3013 void Controller::AddDecoration( Actor& actor, bool needsClipping )
3014 {
3015   if( NULL != mImpl->mEditableControlInterface )
3016   {
3017     mImpl->mEditableControlInterface->AddDecoration( actor, needsClipping );
3018   }
3019 }
3020
3021 void Controller::DecorationEvent( HandleType handleType, HandleState state, float x, float y )
3022 {
3023   DALI_ASSERT_DEBUG( mImpl->mEventData && "Unexpected DecorationEvent" );
3024
3025   if( NULL != mImpl->mEventData )
3026   {
3027     switch( handleType )
3028     {
3029       case GRAB_HANDLE:
3030       {
3031         Event event( Event::GRAB_HANDLE_EVENT );
3032         event.p1.mUint  = state;
3033         event.p2.mFloat = x;
3034         event.p3.mFloat = y;
3035
3036         mImpl->mEventData->mEventQueue.push_back( event );
3037         break;
3038       }
3039       case LEFT_SELECTION_HANDLE:
3040       {
3041         Event event( Event::LEFT_SELECTION_HANDLE_EVENT );
3042         event.p1.mUint  = state;
3043         event.p2.mFloat = x;
3044         event.p3.mFloat = y;
3045
3046         mImpl->mEventData->mEventQueue.push_back( event );
3047         break;
3048       }
3049       case RIGHT_SELECTION_HANDLE:
3050       {
3051         Event event( Event::RIGHT_SELECTION_HANDLE_EVENT );
3052         event.p1.mUint  = state;
3053         event.p2.mFloat = x;
3054         event.p3.mFloat = y;
3055
3056         mImpl->mEventData->mEventQueue.push_back( event );
3057         break;
3058       }
3059       case LEFT_SELECTION_HANDLE_MARKER:
3060       case RIGHT_SELECTION_HANDLE_MARKER:
3061       {
3062         // Markers do not move the handles.
3063         break;
3064       }
3065       case HANDLE_TYPE_COUNT:
3066       {
3067         DALI_ASSERT_DEBUG( !"Controller::HandleEvent. Unexpected handle type" );
3068       }
3069     }
3070
3071     mImpl->RequestRelayout();
3072   }
3073 }
3074
3075 // protected : Inherit from TextSelectionPopup::TextPopupButtonCallbackInterface.
3076
3077 void Controller::TextPopupButtonTouched( Dali::Toolkit::TextSelectionPopup::Buttons button )
3078 {
3079   if( NULL == mImpl->mEventData )
3080   {
3081     return;
3082   }
3083
3084   switch( button )
3085   {
3086     case Toolkit::TextSelectionPopup::CUT:
3087     {
3088       mImpl->SendSelectionToClipboard( true ); // Synchronous call to modify text
3089       mImpl->mOperationsPending = ALL_OPERATIONS;
3090
3091       if( ( 0u != mImpl->mModel->mLogicalModel->mText.Count() ) ||
3092           !mImpl->IsPlaceholderAvailable() )
3093       {
3094         mImpl->QueueModifyEvent( ModifyEvent::TEXT_DELETED );
3095       }
3096       else
3097       {
3098         ShowPlaceholderText();
3099       }
3100
3101       mImpl->mEventData->mUpdateCursorPosition = true;
3102       mImpl->mEventData->mScrollAfterDelete = true;
3103
3104       mImpl->RequestRelayout();
3105
3106       if( NULL != mImpl->mEditableControlInterface )
3107       {
3108         mImpl->mEditableControlInterface->TextChanged();
3109       }
3110       break;
3111     }
3112     case Toolkit::TextSelectionPopup::COPY:
3113     {
3114       mImpl->SendSelectionToClipboard( false ); // Text not modified
3115
3116       mImpl->mEventData->mUpdateCursorPosition = true;
3117
3118       mImpl->RequestRelayout(); // Cursor, Handles, Selection Highlight, Popup
3119       break;
3120     }
3121     case Toolkit::TextSelectionPopup::PASTE:
3122     {
3123       mImpl->RequestGetTextFromClipboard(); // Request clipboard service to retrieve an item
3124       break;
3125     }
3126     case Toolkit::TextSelectionPopup::SELECT:
3127     {
3128       const Vector2& currentCursorPosition = mImpl->mEventData->mDecorator->GetPosition( PRIMARY_CURSOR );
3129
3130       if( mImpl->mEventData->mSelectionEnabled )
3131       {
3132         // Creates a SELECT event.
3133         SelectEvent( currentCursorPosition.x, currentCursorPosition.y, false );
3134       }
3135       break;
3136     }
3137     case Toolkit::TextSelectionPopup::SELECT_ALL:
3138     {
3139       // Creates a SELECT_ALL event
3140       SelectEvent( 0.f, 0.f, true );
3141       break;
3142     }
3143     case Toolkit::TextSelectionPopup::CLIPBOARD:
3144     {
3145       mImpl->ShowClipboard();
3146       break;
3147     }
3148     case Toolkit::TextSelectionPopup::NONE:
3149     {
3150       // Nothing to do.
3151       break;
3152     }
3153   }
3154 }
3155
3156 void Controller::DisplayTimeExpired()
3157 {
3158   mImpl->mEventData->mUpdateCursorPosition = true;
3159   // Apply modifications to the model
3160   mImpl->mOperationsPending = ALL_OPERATIONS;
3161
3162   mImpl->RequestRelayout();
3163 }
3164
3165 // private : Update.
3166
3167 void Controller::InsertText( const std::string& text, Controller::InsertType type )
3168 {
3169   bool removedPrevious = false;
3170   bool removedSelected = false;
3171   bool maxLengthReached = false;
3172
3173   DALI_ASSERT_DEBUG( NULL != mImpl->mEventData && "Unexpected InsertText" )
3174
3175   if( NULL == mImpl->mEventData )
3176   {
3177     return;
3178   }
3179
3180   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Controller::InsertText %p %s (%s) mPrimaryCursorPosition %d mPreEditFlag %d mPreEditStartPosition %d mPreEditLength %d\n",
3181                  this, text.c_str(), (COMMIT == type ? "COMMIT" : "PRE_EDIT"),
3182                  mImpl->mEventData->mPrimaryCursorPosition, mImpl->mEventData->mPreEditFlag, mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
3183
3184   // TODO: At the moment the underline runs are only for pre-edit.
3185   mImpl->mModel->mVisualModel->mUnderlineRuns.Clear();
3186
3187   // Remove the previous InputMethodContext pre-edit.
3188   if( mImpl->mEventData->mPreEditFlag && ( 0u != mImpl->mEventData->mPreEditLength ) )
3189   {
3190     removedPrevious = RemoveText( -static_cast<int>( mImpl->mEventData->mPrimaryCursorPosition - mImpl->mEventData->mPreEditStartPosition ),
3191                                   mImpl->mEventData->mPreEditLength,
3192                                   DONT_UPDATE_INPUT_STYLE );
3193
3194     mImpl->mEventData->mPrimaryCursorPosition = mImpl->mEventData->mPreEditStartPosition;
3195     mImpl->mEventData->mPreEditLength = 0u;
3196   }
3197   else
3198   {
3199     // Remove the previous Selection.
3200     removedSelected = RemoveSelectedText();
3201
3202   }
3203
3204   Vector<Character> utf32Characters;
3205   Length characterCount = 0u;
3206
3207   if( !text.empty() )
3208   {
3209     //  Convert text into UTF-32
3210     utf32Characters.Resize( text.size() );
3211
3212     // This is a bit horrible but std::string returns a (signed) char*
3213     const uint8_t* utf8 = reinterpret_cast<const uint8_t*>( text.c_str() );
3214
3215     // Transform a text array encoded in utf8 into an array encoded in utf32.
3216     // It returns the actual number of characters.
3217     characterCount = Utf8ToUtf32( utf8, text.size(), utf32Characters.Begin() );
3218     utf32Characters.Resize( characterCount );
3219
3220     DALI_ASSERT_DEBUG( text.size() >= utf32Characters.Count() && "Invalid UTF32 conversion length" );
3221     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "UTF8 size %d, UTF32 size %d\n", text.size(), utf32Characters.Count() );
3222   }
3223
3224   if( 0u != utf32Characters.Count() ) // Check if Utf8ToUtf32 conversion succeeded
3225   {
3226     // The placeholder text is no longer needed
3227     if( mImpl->IsShowingPlaceholderText() )
3228     {
3229       ResetText();
3230     }
3231
3232     mImpl->ChangeState( EventData::EDITING );
3233
3234     // Handle the InputMethodContext (predicitive text) state changes
3235     if( COMMIT == type )
3236     {
3237       // InputMethodContext is no longer handling key-events
3238       mImpl->ClearPreEditFlag();
3239     }
3240     else // PRE_EDIT
3241     {
3242       if( !mImpl->mEventData->mPreEditFlag )
3243       {
3244         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Entered PreEdit state\n" );
3245
3246         // Record the start of the pre-edit text
3247         mImpl->mEventData->mPreEditStartPosition = mImpl->mEventData->mPrimaryCursorPosition;
3248       }
3249
3250       mImpl->mEventData->mPreEditLength = utf32Characters.Count();
3251       mImpl->mEventData->mPreEditFlag = true;
3252
3253       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "mPreEditStartPosition %d mPreEditLength %d\n", mImpl->mEventData->mPreEditStartPosition, mImpl->mEventData->mPreEditLength );
3254     }
3255
3256     const Length numberOfCharactersInModel = mImpl->mModel->mLogicalModel->mText.Count();
3257
3258     // Restrict new text to fit within Maximum characters setting.
3259     Length maxSizeOfNewText = std::min( ( mImpl->mMaximumNumberOfCharacters - numberOfCharactersInModel ), characterCount );
3260     maxLengthReached = ( characterCount > maxSizeOfNewText );
3261
3262     // The cursor position.
3263     CharacterIndex& cursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
3264
3265     // Update the text's style.
3266
3267     // Updates the text style runs by adding characters.
3268     mImpl->mModel->mLogicalModel->UpdateTextStyleRuns( cursorIndex, maxSizeOfNewText );
3269
3270     // Get the character index from the cursor index.
3271     const CharacterIndex styleIndex = ( cursorIndex > 0u ) ? cursorIndex - 1u : 0u;
3272
3273     // Retrieve the text's style for the given index.
3274     InputStyle style;
3275     mImpl->RetrieveDefaultInputStyle( style );
3276     mImpl->mModel->mLogicalModel->RetrieveStyle( styleIndex, style );
3277
3278     // Whether to add a new text color run.
3279     const bool addColorRun = ( style.textColor != mImpl->mEventData->mInputStyle.textColor ) && !mImpl->mEventData->mInputStyle.isDefaultColor;
3280
3281     // Whether to add a new font run.
3282     const bool addFontNameRun = ( style.familyName != mImpl->mEventData->mInputStyle.familyName ) && mImpl->mEventData->mInputStyle.isFamilyDefined;
3283     const bool addFontWeightRun = ( style.weight != mImpl->mEventData->mInputStyle.weight ) && mImpl->mEventData->mInputStyle.isWeightDefined;
3284     const bool addFontWidthRun = ( style.width != mImpl->mEventData->mInputStyle.width ) && mImpl->mEventData->mInputStyle.isWidthDefined;
3285     const bool addFontSlantRun = ( style.slant != mImpl->mEventData->mInputStyle.slant ) && mImpl->mEventData->mInputStyle.isSlantDefined;
3286     const bool addFontSizeRun = ( style.size != mImpl->mEventData->mInputStyle.size ) && mImpl->mEventData->mInputStyle.isSizeDefined ;
3287
3288     // Add style runs.
3289     if( addColorRun )
3290     {
3291       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mColorRuns.Count();
3292       mImpl->mModel->mLogicalModel->mColorRuns.Resize( numberOfRuns + 1u );
3293
3294       ColorRun& colorRun = *( mImpl->mModel->mLogicalModel->mColorRuns.Begin() + numberOfRuns );
3295       colorRun.color = mImpl->mEventData->mInputStyle.textColor;
3296       colorRun.characterRun.characterIndex = cursorIndex;
3297       colorRun.characterRun.numberOfCharacters = maxSizeOfNewText;
3298     }
3299
3300     if( addFontNameRun   ||
3301         addFontWeightRun ||
3302         addFontWidthRun  ||
3303         addFontSlantRun  ||
3304         addFontSizeRun )
3305     {
3306       const VectorBase::SizeType numberOfRuns = mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Count();
3307       mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Resize( numberOfRuns + 1u );
3308
3309       FontDescriptionRun& fontDescriptionRun = *( mImpl->mModel->mLogicalModel->mFontDescriptionRuns.Begin() + numberOfRuns );
3310
3311       if( addFontNameRun )
3312       {
3313         fontDescriptionRun.familyLength = mImpl->mEventData->mInputStyle.familyName.size();
3314         fontDescriptionRun.familyName = new char[fontDescriptionRun.familyLength];
3315         memcpy( fontDescriptionRun.familyName, mImpl->mEventData->mInputStyle.familyName.c_str(), fontDescriptionRun.familyLength );
3316         fontDescriptionRun.familyDefined = true;
3317
3318         // The memory allocated for the font family name is freed when the font description is removed from the logical model.
3319       }
3320
3321       if( addFontWeightRun )
3322       {
3323         fontDescriptionRun.weight = mImpl->mEventData->mInputStyle.weight;
3324         fontDescriptionRun.weightDefined = true;
3325       }
3326
3327       if( addFontWidthRun )
3328       {
3329         fontDescriptionRun.width = mImpl->mEventData->mInputStyle.width;
3330         fontDescriptionRun.widthDefined = true;
3331       }
3332
3333       if( addFontSlantRun )
3334       {
3335         fontDescriptionRun.slant = mImpl->mEventData->mInputStyle.slant;
3336         fontDescriptionRun.slantDefined = true;
3337       }
3338
3339       if( addFontSizeRun )
3340       {
3341         fontDescriptionRun.size = static_cast<PointSize26Dot6>( mImpl->mEventData->mInputStyle.size * 64.f );
3342         fontDescriptionRun.sizeDefined = true;
3343       }
3344
3345       fontDescriptionRun.characterRun.characterIndex = cursorIndex;
3346       fontDescriptionRun.characterRun.numberOfCharacters = maxSizeOfNewText;
3347     }
3348
3349     // Insert at current cursor position.
3350     Vector<Character>& modifyText = mImpl->mModel->mLogicalModel->mText;
3351
3352     if( cursorIndex < numberOfCharactersInModel )
3353     {
3354       modifyText.Insert( modifyText.Begin() + cursorIndex, utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
3355     }
3356     else
3357     {
3358       modifyText.Insert( modifyText.End(), utf32Characters.Begin(), utf32Characters.Begin() + maxSizeOfNewText );
3359     }
3360
3361     // Mark the first paragraph to be updated.
3362     if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() )
3363     {
3364       mImpl->mTextUpdateInfo.mCharacterIndex = 0;
3365       mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
3366       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = numberOfCharactersInModel + maxSizeOfNewText;
3367       mImpl->mTextUpdateInfo.mClearAll = true;
3368     }
3369     else
3370     {
3371       mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex );
3372       mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd += maxSizeOfNewText;
3373     }
3374
3375     // Update the cursor index.
3376     cursorIndex += maxSizeOfNewText;
3377
3378     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "Inserted %d characters, new size %d new cursor %d\n", maxSizeOfNewText, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition );
3379   }
3380
3381   if( ( 0u == mImpl->mModel->mLogicalModel->mText.Count() ) &&
3382       mImpl->IsPlaceholderAvailable() )
3383   {
3384     // Show place-holder if empty after removing the pre-edit text
3385     ShowPlaceholderText();
3386     mImpl->mEventData->mUpdateCursorPosition = true;
3387     mImpl->ClearPreEditFlag();
3388   }
3389   else if( removedPrevious ||
3390            removedSelected ||
3391            ( 0 != utf32Characters.Count() ) )
3392   {
3393     // Queue an inserted event
3394     mImpl->QueueModifyEvent( ModifyEvent::TEXT_INSERTED );
3395
3396     mImpl->mEventData->mUpdateCursorPosition = true;
3397     if( removedSelected )
3398     {
3399       mImpl->mEventData->mScrollAfterDelete = true;
3400     }
3401     else
3402     {
3403       mImpl->mEventData->mScrollAfterUpdatePosition = true;
3404     }
3405   }
3406
3407   if( maxLengthReached )
3408   {
3409     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "MaxLengthReached (%d)\n", mImpl->mModel->mLogicalModel->mText.Count() );
3410
3411     mImpl->ResetInputMethodContext();
3412
3413     if( NULL != mImpl->mEditableControlInterface )
3414     {
3415       // Do this last since it provides callbacks into application code
3416       mImpl->mEditableControlInterface->MaxLengthReached();
3417     }
3418   }
3419 }
3420
3421 void Controller::PasteText( const std::string& stringToPaste )
3422 {
3423   InsertText( stringToPaste, Text::Controller::COMMIT );
3424   mImpl->ChangeState( EventData::EDITING );
3425   mImpl->RequestRelayout();
3426
3427   if( NULL != mImpl->mEditableControlInterface )
3428   {
3429     // Do this last since it provides callbacks into application code
3430     mImpl->mEditableControlInterface->TextChanged();
3431   }
3432 }
3433
3434 bool Controller::RemoveText( int cursorOffset,
3435                              int numberOfCharacters,
3436                              UpdateInputStyleType type )
3437 {
3438   bool removed = false;
3439
3440   if( NULL == mImpl->mEventData )
3441   {
3442     return removed;
3443   }
3444
3445   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p mText.Count() %d cursor %d cursorOffset %d numberOfCharacters %d\n",
3446                  this, mImpl->mModel->mLogicalModel->mText.Count(), mImpl->mEventData->mPrimaryCursorPosition, cursorOffset, numberOfCharacters );
3447
3448   if( !mImpl->IsShowingPlaceholderText() )
3449   {
3450     // Delete at current cursor position
3451     Vector<Character>& currentText = mImpl->mModel->mLogicalModel->mText;
3452     CharacterIndex& oldCursorIndex = mImpl->mEventData->mPrimaryCursorPosition;
3453
3454     CharacterIndex cursorIndex = 0;
3455
3456     // Validate the cursor position & number of characters
3457     if( ( static_cast< int >( mImpl->mEventData->mPrimaryCursorPosition ) + cursorOffset ) >= 0 )
3458     {
3459       cursorIndex = mImpl->mEventData->mPrimaryCursorPosition + cursorOffset;
3460     }
3461
3462     if( ( cursorIndex + numberOfCharacters ) > currentText.Count() )
3463     {
3464       numberOfCharacters = currentText.Count() - cursorIndex;
3465     }
3466
3467     if( mImpl->mEventData->mPreEditFlag || // If the preedit flag is enabled, it means two (or more) of them came together i.e. when two keys have been pressed at the same time.
3468         ( ( cursorIndex + numberOfCharacters ) <= mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters ) )
3469     {
3470       // Mark the paragraphs to be updated.
3471       if( Layout::Engine::SINGLE_LINE_BOX == mImpl->mLayoutEngine.GetLayout() )
3472       {
3473         mImpl->mTextUpdateInfo.mCharacterIndex = 0;
3474         mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters;
3475         mImpl->mTextUpdateInfo.mNumberOfCharactersToAdd = mImpl->mTextUpdateInfo.mPreviousNumberOfCharacters - numberOfCharacters;
3476         mImpl->mTextUpdateInfo.mClearAll = true;
3477       }
3478       else
3479       {
3480         mImpl->mTextUpdateInfo.mCharacterIndex = std::min( cursorIndex, mImpl->mTextUpdateInfo.mCharacterIndex );
3481         mImpl->mTextUpdateInfo.mNumberOfCharactersToRemove += numberOfCharacters;
3482       }
3483
3484       // Update the input style and remove the text's style before removing the text.
3485
3486       if( UPDATE_INPUT_STYLE == type )
3487       {
3488         // Keep a copy of the current input style.
3489         InputStyle currentInputStyle;
3490         currentInputStyle.Copy( mImpl->mEventData->mInputStyle );
3491
3492         // Set first the default input style.
3493         mImpl->RetrieveDefaultInputStyle( mImpl->mEventData->mInputStyle );
3494
3495         // Update the input style.
3496         mImpl->mModel->mLogicalModel->RetrieveStyle( cursorIndex, mImpl->mEventData->mInputStyle );
3497
3498         // Compare if the input style has changed.
3499         const bool hasInputStyleChanged = !currentInputStyle.Equal( mImpl->mEventData->mInputStyle );
3500
3501         if( hasInputStyleChanged )
3502         {
3503           const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask( mImpl->mEventData->mInputStyle );
3504           // Queue the input style changed signal.
3505           mImpl->mEventData->mInputStyleChangedQueue.PushBack( styleChangedMask );
3506         }
3507       }
3508
3509       // Updates the text style runs by removing characters. Runs with no characters are removed.
3510       mImpl->mModel->mLogicalModel->UpdateTextStyleRuns( cursorIndex, -numberOfCharacters );
3511
3512       // Remove the characters.
3513       Vector<Character>::Iterator first = currentText.Begin() + cursorIndex;
3514       Vector<Character>::Iterator last  = first + numberOfCharacters;
3515
3516       currentText.Erase( first, last );
3517
3518       // Cursor position retreat
3519       oldCursorIndex = cursorIndex;
3520
3521       mImpl->mEventData->mScrollAfterDelete = true;
3522
3523       DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::RemoveText %p removed %d\n", this, numberOfCharacters );
3524       removed = true;
3525     }
3526   }
3527
3528   return removed;
3529 }
3530
3531 bool Controller::RemoveSelectedText()
3532 {
3533   bool textRemoved( false );
3534
3535   if( EventData::SELECTING == mImpl->mEventData->mState )
3536   {
3537     std::string removedString;
3538     mImpl->RetrieveSelection( removedString, true );
3539
3540     if( !removedString.empty() )
3541     {
3542       textRemoved = true;
3543       mImpl->ChangeState( EventData::EDITING );
3544     }
3545   }
3546
3547   return textRemoved;
3548 }
3549
3550 // private : Relayout.
3551
3552 bool Controller::DoRelayout( const Size& size,
3553                              OperationsMask operationsRequired,
3554                              Size& layoutSize )
3555 {
3556   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::DoRelayout %p size %f,%f\n", this, size.width, size.height );
3557   bool viewUpdated( false );
3558
3559   // Calculate the operations to be done.
3560   const OperationsMask operations = static_cast<OperationsMask>( mImpl->mOperationsPending & operationsRequired );
3561
3562   const CharacterIndex startIndex = mImpl->mTextUpdateInfo.mParagraphCharacterIndex;
3563   const Length requestedNumberOfCharacters = mImpl->mTextUpdateInfo.mRequestedNumberOfCharacters;
3564
3565   // Get the current layout size.
3566   layoutSize = mImpl->mModel->mVisualModel->GetLayoutSize();
3567
3568   if( NO_OPERATION != ( LAYOUT & operations ) )
3569   {
3570     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::DoRelayout LAYOUT & operations\n");
3571
3572     // Some vectors with data needed to layout and reorder may be void
3573     // after the first time the text has been laid out.
3574     // Fill the vectors again.
3575
3576     // Calculate the number of glyphs to layout.
3577     const Vector<GlyphIndex>& charactersToGlyph = mImpl->mModel->mVisualModel->mCharactersToGlyph;
3578     const Vector<Length>& glyphsPerCharacter = mImpl->mModel->mVisualModel->mGlyphsPerCharacter;
3579     const GlyphIndex* const charactersToGlyphBuffer = charactersToGlyph.Begin();
3580     const Length* const glyphsPerCharacterBuffer = glyphsPerCharacter.Begin();
3581
3582     const CharacterIndex lastIndex = startIndex + ( ( requestedNumberOfCharacters > 0u ) ? requestedNumberOfCharacters - 1u : 0u );
3583     const GlyphIndex startGlyphIndex = mImpl->mTextUpdateInfo.mStartGlyphIndex;
3584
3585     // Make sure the index is not out of bound
3586     if ( charactersToGlyph.Count() != glyphsPerCharacter.Count() ||
3587          requestedNumberOfCharacters > charactersToGlyph.Count() ||
3588          ( lastIndex >= charactersToGlyph.Count() && charactersToGlyph.Count() > 0u ) )
3589     {
3590       std::string currentText;
3591       GetText( currentText );
3592
3593       DALI_LOG_ERROR( "Controller::DoRelayout: Attempting to access invalid buffer\n" );
3594       DALI_LOG_ERROR( "Current text is: %s\n", currentText.c_str() );
3595       DALI_LOG_ERROR( "startIndex: %u, lastIndex: %u, requestedNumberOfCharacters: %u, charactersToGlyph.Count = %lu, glyphsPerCharacter.Count = %lu\n", startIndex, lastIndex, requestedNumberOfCharacters, charactersToGlyph.Count(), glyphsPerCharacter.Count());
3596
3597       return false;
3598     }
3599
3600     const Length numberOfGlyphs = ( requestedNumberOfCharacters > 0u ) ? *( charactersToGlyphBuffer + lastIndex ) + *( glyphsPerCharacterBuffer + lastIndex ) - startGlyphIndex : 0u;
3601     const Length totalNumberOfGlyphs = mImpl->mModel->mVisualModel->mGlyphs.Count();
3602
3603     if( 0u == totalNumberOfGlyphs )
3604     {
3605       if( NO_OPERATION != ( UPDATE_LAYOUT_SIZE & operations ) )
3606       {
3607         mImpl->mModel->mVisualModel->SetLayoutSize( Size::ZERO );
3608       }
3609
3610       // Nothing else to do if there is no glyphs.
3611       DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::DoRelayout no glyphs, view updated true\n" );
3612       return true;
3613     }
3614
3615     const Vector<LineBreakInfo>& lineBreakInfo = mImpl->mModel->mLogicalModel->mLineBreakInfo;
3616     const Vector<WordBreakInfo>& wordBreakInfo = mImpl->mModel->mLogicalModel->mWordBreakInfo;
3617     const Vector<CharacterDirection>& characterDirection = mImpl->mModel->mLogicalModel->mCharacterDirections;
3618     const Vector<GlyphInfo>& glyphs = mImpl->mModel->mVisualModel->mGlyphs;
3619     const Vector<CharacterIndex>& glyphsToCharactersMap = mImpl->mModel->mVisualModel->mGlyphsToCharacters;
3620     const Vector<Length>& charactersPerGlyph = mImpl->mModel->mVisualModel->mCharactersPerGlyph;
3621     const Character* const textBuffer = mImpl->mModel->mLogicalModel->mText.Begin();
3622     const float outlineWidth = static_cast<float>( mImpl->mModel->GetOutlineWidth() );
3623
3624     // Set the layout parameters.
3625     Layout::Parameters layoutParameters( size,
3626                                          textBuffer,
3627                                          lineBreakInfo.Begin(),
3628                                          wordBreakInfo.Begin(),
3629                                          ( 0u != characterDirection.Count() ) ? characterDirection.Begin() : NULL,
3630                                          glyphs.Begin(),
3631                                          glyphsToCharactersMap.Begin(),
3632                                          charactersPerGlyph.Begin(),
3633                                          charactersToGlyphBuffer,
3634                                          glyphsPerCharacterBuffer,
3635                                          totalNumberOfGlyphs,
3636                                          mImpl->mModel->mHorizontalAlignment,
3637                                          mImpl->mModel->mLineWrapMode,
3638                                          outlineWidth,
3639                                          mImpl->mModel->mIgnoreSpaces