Add TextField BACKGROUND property and more Preedit style options
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller-impl.cpp
1 /*
2  * Copyright (c) 2017 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-impl.h>
20
21 // EXTERNAL INCLUDES
22 #include <dali/public-api/adaptor-framework/key.h>
23 #include <dali/public-api/rendering/renderer.h>
24 #include <dali/integration-api/debug.h>
25 #include <limits>
26
27 // INTERNAL INCLUDES
28 #include <dali-toolkit/devel-api/controls/control-depth-index-ranges.h>
29 #include <dali-toolkit/internal/text/bidirectional-support.h>
30 #include <dali-toolkit/internal/text/character-set-conversion.h>
31 #include <dali-toolkit/internal/text/color-segmentation.h>
32 #include <dali-toolkit/internal/text/cursor-helper-functions.h>
33 #include <dali-toolkit/internal/text/multi-language-support.h>
34 #include <dali-toolkit/internal/text/segmentation.h>
35 #include <dali-toolkit/internal/text/shaper.h>
36 #include <dali-toolkit/internal/text/text-control-interface.h>
37 #include <dali-toolkit/internal/text/text-run-container.h>
38
39 using namespace Dali;
40
41 namespace
42 {
43
44 /**
45  * @brief Struct used to calculate the selection box.
46  */
47 struct SelectionBoxInfo
48 {
49   float lineOffset;
50   float lineHeight;
51   float minX;
52   float maxX;
53 };
54
55 #if defined(DEBUG_ENABLED)
56   Debug::Filter* gLogFilter = Debug::Filter::New(Debug::NoLogging, true, "LOG_TEXT_CONTROLS");
57 #endif
58
59 const float MAX_FLOAT = std::numeric_limits<float>::max();
60 const float MIN_FLOAT = std::numeric_limits<float>::min();
61 const Dali::Toolkit::Text::CharacterDirection LTR = false; ///< Left To Right direction
62
63 #define MAKE_SHADER(A)#A
64
65 const char* VERTEX_SHADER_BACKGROUND = MAKE_SHADER(
66 attribute mediump vec2    aPosition;
67 attribute mediump vec4    aColor;
68 varying   mediump vec4    vColor;
69 uniform   highp mat4      uMvpMatrix;
70
71 void main()
72 {
73   mediump vec4 position = vec4( aPosition, 0.0, 1.0 );
74   gl_Position = uMvpMatrix * position;
75   vColor = aColor;
76 }
77 );
78
79 const char* FRAGMENT_SHADER_BACKGROUND = MAKE_SHADER(
80 varying mediump vec4      vColor;
81 uniform lowp    vec4      uColor;
82
83 void main()
84 {
85   gl_FragColor = vColor * uColor;
86 }
87 );
88
89 struct BackgroundVertex
90 {
91   Vector2 mPosition;        ///< Vertex posiiton
92   Vector4 mColor;           ///< Vertex color
93 };
94
95 struct BackgroundMesh
96 {
97   Vector< BackgroundVertex > mVertices;    ///< container of vertices
98   Vector< unsigned short > mIndices;       ///< container of indices
99 };
100
101 const Dali::Vector4 LIGHT_BLUE( 0.75f, 0.96f, 1.f, 1.f );
102 const Dali::Vector4 BACKGROUND_SUB4( 0.58f, 0.87f, 0.96f, 1.f );
103 const Dali::Vector4 BACKGROUND_SUB5( 0.83f, 0.94f, 0.98f, 1.f );
104 const Dali::Vector4 BACKGROUND_SUB6( 1.f, 0.5f, 0.5f, 1.f );
105 const Dali::Vector4 BACKGROUND_SUB7( 1.f, 0.8f, 0.8f, 1.f );
106
107 } // namespace
108
109 namespace Dali
110 {
111
112 namespace Toolkit
113 {
114
115 namespace Text
116 {
117
118 EventData::EventData( DecoratorPtr decorator, InputMethodContext& inputMethodContext )
119 : mDecorator( decorator ),
120   mInputMethodContext( inputMethodContext ),
121   mPlaceholderFont( NULL ),
122   mPlaceholderTextActive(),
123   mPlaceholderTextInactive(),
124   mPlaceholderTextColor( 0.8f, 0.8f, 0.8f, 0.8f ), // This color has been published in the Public API (placeholder-properties.h).
125   mEventQueue(),
126   mInputStyleChangedQueue(),
127   mPreviousState( INACTIVE ),
128   mState( INACTIVE ),
129   mPrimaryCursorPosition( 0u ),
130   mLeftSelectionPosition( 0u ),
131   mRightSelectionPosition( 0u ),
132   mPreEditStartPosition( 0u ),
133   mPreEditLength( 0u ),
134   mCursorHookPositionX( 0.f ),
135   mDoubleTapAction( Controller::NoTextTap::NO_ACTION ),
136   mLongPressAction( Controller::NoTextTap::SHOW_SELECTION_POPUP ),
137   mIsShowingPlaceholderText( false ),
138   mPreEditFlag( false ),
139   mDecoratorUpdated( false ),
140   mCursorBlinkEnabled( true ),
141   mGrabHandleEnabled( true ),
142   mGrabHandlePopupEnabled( true ),
143   mSelectionEnabled( true ),
144   mUpdateCursorHookPosition( false ),
145   mUpdateCursorPosition( false ),
146   mUpdateGrabHandlePosition( false ),
147   mUpdateLeftSelectionPosition( false ),
148   mUpdateRightSelectionPosition( false ),
149   mIsLeftHandleSelected( false ),
150   mIsRightHandleSelected( false ),
151   mUpdateHighlightBox( false ),
152   mScrollAfterUpdatePosition( false ),
153   mScrollAfterDelete( false ),
154   mAllTextSelected( false ),
155   mUpdateInputStyle( false ),
156   mPasswordInput( false ),
157   mCheckScrollAmount( false ),
158   mIsPlaceholderPixelSize( false ),
159   mIsPlaceholderElideEnabled( false ),
160   mPlaceholderEllipsisFlag( false ),
161   mShiftSelectionFlag( true ),
162   mUpdateAlignment( false )
163 {
164 }
165
166 EventData::~EventData()
167 {}
168
169 bool Controller::Impl::ProcessInputEvents()
170 {
171   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "-->Controller::ProcessInputEvents\n" );
172   if( NULL == mEventData )
173   {
174     // Nothing to do if there is no text input.
175     DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::ProcessInputEvents no event data\n" );
176     return false;
177   }
178
179   if( mEventData->mDecorator )
180   {
181     for( std::vector<Event>::iterator iter = mEventData->mEventQueue.begin();
182          iter != mEventData->mEventQueue.end();
183          ++iter )
184     {
185       switch( iter->type )
186       {
187         case Event::CURSOR_KEY_EVENT:
188         {
189           OnCursorKeyEvent( *iter );
190           break;
191         }
192         case Event::TAP_EVENT:
193         {
194           OnTapEvent( *iter );
195           break;
196         }
197         case Event::LONG_PRESS_EVENT:
198         {
199           OnLongPressEvent( *iter );
200           break;
201         }
202         case Event::PAN_EVENT:
203         {
204           OnPanEvent( *iter );
205           break;
206         }
207         case Event::GRAB_HANDLE_EVENT:
208         case Event::LEFT_SELECTION_HANDLE_EVENT:
209         case Event::RIGHT_SELECTION_HANDLE_EVENT: // Fall through
210         {
211           OnHandleEvent( *iter );
212           break;
213         }
214         case Event::SELECT:
215         {
216           OnSelectEvent( *iter );
217           break;
218         }
219         case Event::SELECT_ALL:
220         {
221           OnSelectAllEvent();
222           break;
223         }
224       }
225     }
226   }
227
228   if( mEventData->mUpdateCursorPosition ||
229       mEventData->mUpdateHighlightBox )
230   {
231     NotifyInputMethodContext();
232   }
233
234   // The cursor must also be repositioned after inserts into the model
235   if( mEventData->mUpdateCursorPosition )
236   {
237     // Updates the cursor position and scrolls the text to make it visible.
238     CursorInfo cursorInfo;
239     // Calculate the cursor position from the new cursor index.
240     GetCursorPosition( mEventData->mPrimaryCursorPosition,
241                        cursorInfo );
242
243     if( mEventData->mUpdateCursorHookPosition )
244     {
245       // Update the cursor hook position. Used to move the cursor with the keys 'up' and 'down'.
246       mEventData->mCursorHookPositionX = cursorInfo.primaryPosition.x;
247       mEventData->mUpdateCursorHookPosition = false;
248     }
249
250     // Scroll first the text after delete ...
251     if( mEventData->mScrollAfterDelete )
252     {
253       ScrollTextToMatchCursor( cursorInfo );
254     }
255
256     // ... then, text can be scrolled to make the cursor visible.
257     if( mEventData->mScrollAfterUpdatePosition )
258     {
259       const Vector2 currentCursorPosition( cursorInfo.primaryPosition.x, cursorInfo.lineOffset );
260       ScrollToMakePositionVisible( currentCursorPosition, cursorInfo.lineHeight );
261     }
262     mEventData->mScrollAfterUpdatePosition = false;
263     mEventData->mScrollAfterDelete = false;
264
265     UpdateCursorPosition( cursorInfo );
266
267     mEventData->mDecoratorUpdated = true;
268     mEventData->mUpdateCursorPosition = false;
269     mEventData->mUpdateGrabHandlePosition = false;
270   }
271   else
272   {
273     CursorInfo leftHandleInfo;
274     CursorInfo rightHandleInfo;
275
276     if( mEventData->mUpdateHighlightBox )
277     {
278       GetCursorPosition( mEventData->mLeftSelectionPosition,
279                          leftHandleInfo );
280
281       GetCursorPosition( mEventData->mRightSelectionPosition,
282                          rightHandleInfo );
283
284       if( mEventData->mScrollAfterUpdatePosition && ( mEventData->mIsLeftHandleSelected ? mEventData->mUpdateLeftSelectionPosition : mEventData->mUpdateRightSelectionPosition ) )
285       {
286         if( mEventData->mIsLeftHandleSelected && mEventData->mIsRightHandleSelected )
287         {
288           CursorInfo& infoLeft = leftHandleInfo;
289
290           const Vector2 currentCursorPositionLeft( infoLeft.primaryPosition.x, infoLeft.lineOffset );
291           ScrollToMakePositionVisible( currentCursorPositionLeft, infoLeft.lineHeight );
292
293           CursorInfo& infoRight = rightHandleInfo;
294
295           const Vector2 currentCursorPositionRight( infoRight.primaryPosition.x, infoRight.lineOffset );
296           ScrollToMakePositionVisible( currentCursorPositionRight, infoRight.lineHeight );
297         }
298         else
299         {
300           CursorInfo& info = mEventData->mIsLeftHandleSelected ? leftHandleInfo : rightHandleInfo;
301
302           const Vector2 currentCursorPosition( info.primaryPosition.x, info.lineOffset );
303           ScrollToMakePositionVisible( currentCursorPosition, info.lineHeight );
304         }
305       }
306     }
307
308     if( mEventData->mUpdateLeftSelectionPosition )
309     {
310       UpdateSelectionHandle( LEFT_SELECTION_HANDLE,
311                              leftHandleInfo );
312
313       SetPopupButtons();
314       mEventData->mDecoratorUpdated = true;
315       mEventData->mUpdateLeftSelectionPosition = false;
316     }
317
318     if( mEventData->mUpdateRightSelectionPosition )
319     {
320       UpdateSelectionHandle( RIGHT_SELECTION_HANDLE,
321                              rightHandleInfo );
322
323       SetPopupButtons();
324       mEventData->mDecoratorUpdated = true;
325       mEventData->mUpdateRightSelectionPosition = false;
326     }
327
328     if( mEventData->mUpdateHighlightBox )
329     {
330       RepositionSelectionHandles();
331
332       mEventData->mUpdateLeftSelectionPosition = false;
333       mEventData->mUpdateRightSelectionPosition = false;
334       mEventData->mUpdateHighlightBox = false;
335       mEventData->mIsLeftHandleSelected = false;
336       mEventData->mIsRightHandleSelected = false;
337     }
338
339     mEventData->mScrollAfterUpdatePosition = false;
340   }
341
342   if( mEventData->mUpdateInputStyle )
343   {
344     // Keep a copy of the current input style.
345     InputStyle currentInputStyle;
346     currentInputStyle.Copy( mEventData->mInputStyle );
347
348     // Set the default style first.
349     RetrieveDefaultInputStyle( mEventData->mInputStyle );
350
351     // Get the character index from the cursor index.
352     const CharacterIndex styleIndex = ( mEventData->mPrimaryCursorPosition > 0u ) ? mEventData->mPrimaryCursorPosition - 1u : 0u;
353
354     // Retrieve the style from the style runs stored in the logical model.
355     mModel->mLogicalModel->RetrieveStyle( styleIndex, mEventData->mInputStyle );
356
357     // Compare if the input style has changed.
358     const bool hasInputStyleChanged = !currentInputStyle.Equal( mEventData->mInputStyle );
359
360     if( hasInputStyleChanged )
361     {
362       const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask( mEventData->mInputStyle );
363       // Queue the input style changed signal.
364       mEventData->mInputStyleChangedQueue.PushBack( styleChangedMask );
365     }
366
367     mEventData->mUpdateInputStyle = false;
368   }
369
370   mEventData->mEventQueue.clear();
371
372   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "<--Controller::ProcessInputEvents\n" );
373
374   const bool decoratorUpdated = mEventData->mDecoratorUpdated;
375   mEventData->mDecoratorUpdated = false;
376
377   return decoratorUpdated;
378 }
379
380 void Controller::Impl::NotifyInputMethodContext()
381 {
382   if( mEventData && mEventData->mInputMethodContext )
383   {
384     CharacterIndex cursorPosition = GetLogicalCursorPosition();
385
386     const Length numberOfWhiteSpaces = GetNumberOfWhiteSpaces( 0u );
387
388     // Update the cursor position by removing the initial white spaces.
389     if( cursorPosition < numberOfWhiteSpaces )
390     {
391       cursorPosition = 0u;
392     }
393     else
394     {
395       cursorPosition -= numberOfWhiteSpaces;
396     }
397
398     mEventData->mInputMethodContext.SetCursorPosition( cursorPosition );
399     mEventData->mInputMethodContext.NotifyCursorPosition();
400   }
401 }
402
403 void Controller::Impl::NotifyInputMethodContextMultiLineStatus()
404 {
405   if ( mEventData && mEventData->mInputMethodContext )
406   {
407     Text::Layout::Engine::Type layout = mLayoutEngine.GetLayout();
408     mEventData->mInputMethodContext.NotifyTextInputMultiLine( layout == Text::Layout::Engine::MULTI_LINE_BOX );
409   }
410 }
411
412 CharacterIndex Controller::Impl::GetLogicalCursorPosition() const
413 {
414   CharacterIndex cursorPosition = 0u;
415
416   if( mEventData )
417   {
418     if( ( EventData::SELECTING == mEventData->mState ) ||
419         ( EventData::SELECTION_HANDLE_PANNING == mEventData->mState ) )
420     {
421       cursorPosition = std::min( mEventData->mRightSelectionPosition, mEventData->mLeftSelectionPosition );
422     }
423     else
424     {
425       cursorPosition = mEventData->mPrimaryCursorPosition;
426     }
427   }
428
429   return cursorPosition;
430 }
431
432 Length Controller::Impl::GetNumberOfWhiteSpaces( CharacterIndex index ) const
433 {
434   Length numberOfWhiteSpaces = 0u;
435
436   // Get the buffer to the text.
437   Character* utf32CharacterBuffer = mModel->mLogicalModel->mText.Begin();
438
439   const Length totalNumberOfCharacters = mModel->mLogicalModel->mText.Count();
440   for( ; index < totalNumberOfCharacters; ++index, ++numberOfWhiteSpaces )
441   {
442     if( !TextAbstraction::IsWhiteSpace( *( utf32CharacterBuffer + index ) ) )
443     {
444       break;
445     }
446   }
447
448   return numberOfWhiteSpaces;
449 }
450
451 void Controller::Impl::GetText( CharacterIndex index, std::string& text ) const
452 {
453   // Get the total number of characters.
454   Length numberOfCharacters = mModel->mLogicalModel->mText.Count();
455
456   // Retrieve the text.
457   if( 0u != numberOfCharacters )
458   {
459     Utf32ToUtf8( mModel->mLogicalModel->mText.Begin() + index, numberOfCharacters - index, text );
460   }
461 }
462
463 void Controller::Impl::CalculateTextUpdateIndices( Length& numberOfCharacters )
464 {
465   mTextUpdateInfo.mParagraphCharacterIndex = 0u;
466   mTextUpdateInfo.mStartGlyphIndex = 0u;
467   mTextUpdateInfo.mStartLineIndex = 0u;
468   numberOfCharacters = 0u;
469
470   const Length numberOfParagraphs = mModel->mLogicalModel->mParagraphInfo.Count();
471   if( 0u == numberOfParagraphs )
472   {
473     mTextUpdateInfo.mParagraphCharacterIndex = 0u;
474     numberOfCharacters = 0u;
475
476     mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
477
478     // Nothing else to do if there are no paragraphs.
479     return;
480   }
481
482   // Find the paragraphs to be updated.
483   Vector<ParagraphRunIndex> paragraphsToBeUpdated;
484   if( mTextUpdateInfo.mCharacterIndex >= mTextUpdateInfo.mPreviousNumberOfCharacters )
485   {
486     // Text is being added at the end of the current text.
487     if( mTextUpdateInfo.mIsLastCharacterNewParagraph )
488     {
489       // Text is being added in a new paragraph after the last character of the text.
490       mTextUpdateInfo.mParagraphCharacterIndex = mTextUpdateInfo.mPreviousNumberOfCharacters;
491       numberOfCharacters = 0u;
492       mTextUpdateInfo.mRequestedNumberOfCharacters = mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
493
494       mTextUpdateInfo.mStartGlyphIndex = mModel->mVisualModel->mGlyphs.Count();
495       mTextUpdateInfo.mStartLineIndex = mModel->mVisualModel->mLines.Count() - 1u;
496
497       // Nothing else to do;
498       return;
499     }
500
501     paragraphsToBeUpdated.PushBack( numberOfParagraphs - 1u );
502   }
503   else
504   {
505     Length numberOfCharactersToUpdate = 0u;
506     if( mTextUpdateInfo.mFullRelayoutNeeded )
507     {
508       numberOfCharactersToUpdate = mTextUpdateInfo.mPreviousNumberOfCharacters;
509     }
510     else
511     {
512       numberOfCharactersToUpdate = ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) ? mTextUpdateInfo.mNumberOfCharactersToRemove : 1u;
513     }
514     mModel->mLogicalModel->FindParagraphs( mTextUpdateInfo.mCharacterIndex,
515                                            numberOfCharactersToUpdate,
516                                            paragraphsToBeUpdated );
517   }
518
519   if( 0u != paragraphsToBeUpdated.Count() )
520   {
521     const ParagraphRunIndex firstParagraphIndex = *( paragraphsToBeUpdated.Begin() );
522     const ParagraphRun& firstParagraph = *( mModel->mLogicalModel->mParagraphInfo.Begin() + firstParagraphIndex );
523     mTextUpdateInfo.mParagraphCharacterIndex = firstParagraph.characterRun.characterIndex;
524
525     ParagraphRunIndex lastParagraphIndex = *( paragraphsToBeUpdated.End() - 1u );
526     const ParagraphRun& lastParagraph = *( mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex );
527
528     if( ( mTextUpdateInfo.mNumberOfCharactersToRemove > 0u ) &&                                            // Some character are removed.
529         ( lastParagraphIndex < numberOfParagraphs - 1u ) &&                                                // There is a next paragraph.
530         ( ( lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters ) == // The last removed character is the new paragraph character.
531           ( mTextUpdateInfo.mCharacterIndex + mTextUpdateInfo.mNumberOfCharactersToRemove ) ) )
532     {
533       // The new paragraph character of the last updated paragraph has been removed so is going to be merged with the next one.
534       const ParagraphRun& lastParagraph = *( mModel->mLogicalModel->mParagraphInfo.Begin() + lastParagraphIndex + 1u );
535
536       numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
537     }
538     else
539     {
540       numberOfCharacters = lastParagraph.characterRun.characterIndex + lastParagraph.characterRun.numberOfCharacters - mTextUpdateInfo.mParagraphCharacterIndex;
541     }
542   }
543
544   mTextUpdateInfo.mRequestedNumberOfCharacters = numberOfCharacters + mTextUpdateInfo.mNumberOfCharactersToAdd - mTextUpdateInfo.mNumberOfCharactersToRemove;
545   mTextUpdateInfo.mStartGlyphIndex = *( mModel->mVisualModel->mCharactersToGlyph.Begin() + mTextUpdateInfo.mParagraphCharacterIndex );
546 }
547
548 void Controller::Impl::ClearFullModelData( OperationsMask operations )
549 {
550   if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
551   {
552     mModel->mLogicalModel->mLineBreakInfo.Clear();
553     mModel->mLogicalModel->mParagraphInfo.Clear();
554   }
555
556   if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
557   {
558     mModel->mLogicalModel->mScriptRuns.Clear();
559   }
560
561   if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
562   {
563     mModel->mLogicalModel->mFontRuns.Clear();
564   }
565
566   if( 0u != mModel->mLogicalModel->mBidirectionalParagraphInfo.Count() )
567   {
568     if( NO_OPERATION != ( BIDI_INFO & operations ) )
569     {
570       mModel->mLogicalModel->mBidirectionalParagraphInfo.Clear();
571       mModel->mLogicalModel->mCharacterDirections.Clear();
572     }
573
574     if( NO_OPERATION != ( REORDER & operations ) )
575     {
576       // Free the allocated memory used to store the conversion table in the bidirectional line info run.
577       for( Vector<BidirectionalLineInfoRun>::Iterator it = mModel->mLogicalModel->mBidirectionalLineInfo.Begin(),
578              endIt = mModel->mLogicalModel->mBidirectionalLineInfo.End();
579            it != endIt;
580            ++it )
581       {
582         BidirectionalLineInfoRun& bidiLineInfo = *it;
583
584         free( bidiLineInfo.visualToLogicalMap );
585         bidiLineInfo.visualToLogicalMap = NULL;
586       }
587       mModel->mLogicalModel->mBidirectionalLineInfo.Clear();
588     }
589   }
590
591   if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
592   {
593     mModel->mVisualModel->mGlyphs.Clear();
594     mModel->mVisualModel->mGlyphsToCharacters.Clear();
595     mModel->mVisualModel->mCharactersToGlyph.Clear();
596     mModel->mVisualModel->mCharactersPerGlyph.Clear();
597     mModel->mVisualModel->mGlyphsPerCharacter.Clear();
598     mModel->mVisualModel->mGlyphPositions.Clear();
599   }
600
601   if( NO_OPERATION != ( LAYOUT & operations ) )
602   {
603     mModel->mVisualModel->mLines.Clear();
604   }
605
606   if( NO_OPERATION != ( COLOR & operations ) )
607   {
608     mModel->mVisualModel->mColorIndices.Clear();
609     mModel->mVisualModel->mBackgroundColorIndices.Clear();
610   }
611 }
612
613 void Controller::Impl::ClearCharacterModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
614 {
615   const CharacterIndex endIndexPlusOne = endIndex + 1u;
616
617   if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
618   {
619     // Clear the line break info.
620     LineBreakInfo* lineBreakInfoBuffer = mModel->mLogicalModel->mLineBreakInfo.Begin();
621
622     mModel->mLogicalModel->mLineBreakInfo.Erase( lineBreakInfoBuffer + startIndex,
623                                                  lineBreakInfoBuffer + endIndexPlusOne );
624
625     // Clear the paragraphs.
626     ClearCharacterRuns( startIndex,
627                         endIndex,
628                         mModel->mLogicalModel->mParagraphInfo );
629   }
630
631   if( NO_OPERATION != ( GET_SCRIPTS & operations ) )
632   {
633     // Clear the scripts.
634     ClearCharacterRuns( startIndex,
635                         endIndex,
636                         mModel->mLogicalModel->mScriptRuns );
637   }
638
639   if( NO_OPERATION != ( VALIDATE_FONTS & operations ) )
640   {
641     // Clear the fonts.
642     ClearCharacterRuns( startIndex,
643                         endIndex,
644                         mModel->mLogicalModel->mFontRuns );
645   }
646
647   if( 0u != mModel->mLogicalModel->mBidirectionalParagraphInfo.Count() )
648   {
649     if( NO_OPERATION != ( BIDI_INFO & operations ) )
650     {
651       // Clear the bidirectional paragraph info.
652       ClearCharacterRuns( startIndex,
653                           endIndex,
654                           mModel->mLogicalModel->mBidirectionalParagraphInfo );
655
656       // Clear the character's directions.
657       CharacterDirection* characterDirectionsBuffer = mModel->mLogicalModel->mCharacterDirections.Begin();
658
659       mModel->mLogicalModel->mCharacterDirections.Erase( characterDirectionsBuffer + startIndex,
660                                                          characterDirectionsBuffer + endIndexPlusOne );
661     }
662
663     if( NO_OPERATION != ( REORDER & operations ) )
664     {
665       uint32_t startRemoveIndex = mModel->mLogicalModel->mBidirectionalLineInfo.Count();
666       uint32_t endRemoveIndex = startRemoveIndex;
667       ClearCharacterRuns( startIndex,
668                           endIndex,
669                           mModel->mLogicalModel->mBidirectionalLineInfo,
670                           startRemoveIndex,
671                           endRemoveIndex );
672
673       BidirectionalLineInfoRun* bidirectionalLineInfoBuffer = mModel->mLogicalModel->mBidirectionalLineInfo.Begin();
674
675       // Free the allocated memory used to store the conversion table in the bidirectional line info run.
676       for( Vector<BidirectionalLineInfoRun>::Iterator it = bidirectionalLineInfoBuffer + startRemoveIndex,
677              endIt = bidirectionalLineInfoBuffer + endRemoveIndex;
678            it != endIt;
679            ++it )
680       {
681         BidirectionalLineInfoRun& bidiLineInfo = *it;
682
683         free( bidiLineInfo.visualToLogicalMap );
684         bidiLineInfo.visualToLogicalMap = NULL;
685       }
686
687       mModel->mLogicalModel->mBidirectionalLineInfo.Erase( bidirectionalLineInfoBuffer + startRemoveIndex,
688                                                            bidirectionalLineInfoBuffer + endRemoveIndex );
689     }
690   }
691 }
692
693 void Controller::Impl::ClearGlyphModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
694 {
695   const CharacterIndex endIndexPlusOne = endIndex + 1u;
696   const Length numberOfCharactersRemoved = endIndexPlusOne - startIndex;
697
698   // Convert the character index to glyph index before deleting the character to glyph and the glyphs per character buffers.
699   GlyphIndex* charactersToGlyphBuffer = mModel->mVisualModel->mCharactersToGlyph.Begin();
700   Length* glyphsPerCharacterBuffer = mModel->mVisualModel->mGlyphsPerCharacter.Begin();
701
702   const GlyphIndex endGlyphIndexPlusOne = *( charactersToGlyphBuffer + endIndex ) + *( glyphsPerCharacterBuffer + endIndex );
703   const Length numberOfGlyphsRemoved = endGlyphIndexPlusOne - mTextUpdateInfo.mStartGlyphIndex;
704
705   if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
706   {
707     // Update the character to glyph indices.
708     for( Vector<GlyphIndex>::Iterator it =  charactersToGlyphBuffer + endIndexPlusOne,
709            endIt =  charactersToGlyphBuffer + mModel->mVisualModel->mCharactersToGlyph.Count();
710          it != endIt;
711          ++it )
712     {
713       CharacterIndex& index = *it;
714       index -= numberOfGlyphsRemoved;
715     }
716
717     // Clear the character to glyph conversion table.
718     mModel->mVisualModel->mCharactersToGlyph.Erase( charactersToGlyphBuffer + startIndex,
719                                                     charactersToGlyphBuffer + endIndexPlusOne );
720
721     // Clear the glyphs per character table.
722     mModel->mVisualModel->mGlyphsPerCharacter.Erase( glyphsPerCharacterBuffer + startIndex,
723                                                      glyphsPerCharacterBuffer + endIndexPlusOne );
724
725     // Clear the glyphs buffer.
726     GlyphInfo* glyphsBuffer = mModel->mVisualModel->mGlyphs.Begin();
727     mModel->mVisualModel->mGlyphs.Erase( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex,
728                                          glyphsBuffer + endGlyphIndexPlusOne );
729
730     CharacterIndex* glyphsToCharactersBuffer = mModel->mVisualModel->mGlyphsToCharacters.Begin();
731
732     // Update the glyph to character indices.
733     for( Vector<CharacterIndex>::Iterator it = glyphsToCharactersBuffer + endGlyphIndexPlusOne,
734            endIt = glyphsToCharactersBuffer + mModel->mVisualModel->mGlyphsToCharacters.Count();
735          it != endIt;
736          ++it )
737     {
738       CharacterIndex& index = *it;
739       index -= numberOfCharactersRemoved;
740     }
741
742     // Clear the glyphs to characters buffer.
743     mModel->mVisualModel->mGlyphsToCharacters.Erase( glyphsToCharactersBuffer + mTextUpdateInfo.mStartGlyphIndex,
744                                                      glyphsToCharactersBuffer  + endGlyphIndexPlusOne );
745
746     // Clear the characters per glyph buffer.
747     Length* charactersPerGlyphBuffer = mModel->mVisualModel->mCharactersPerGlyph.Begin();
748     mModel->mVisualModel->mCharactersPerGlyph.Erase( charactersPerGlyphBuffer + mTextUpdateInfo.mStartGlyphIndex,
749                                                      charactersPerGlyphBuffer + endGlyphIndexPlusOne );
750
751     // Clear the positions buffer.
752     Vector2* positionsBuffer = mModel->mVisualModel->mGlyphPositions.Begin();
753     mModel->mVisualModel->mGlyphPositions.Erase( positionsBuffer + mTextUpdateInfo.mStartGlyphIndex,
754                                                  positionsBuffer + endGlyphIndexPlusOne );
755   }
756
757   if( NO_OPERATION != ( LAYOUT & operations ) )
758   {
759     // Clear the lines.
760     uint32_t startRemoveIndex = mModel->mVisualModel->mLines.Count();
761     uint32_t endRemoveIndex = startRemoveIndex;
762     ClearCharacterRuns( startIndex,
763                         endIndex,
764                         mModel->mVisualModel->mLines,
765                         startRemoveIndex,
766                         endRemoveIndex );
767
768     // Will update the glyph runs.
769     startRemoveIndex = mModel->mVisualModel->mLines.Count();
770     endRemoveIndex = startRemoveIndex;
771     ClearGlyphRuns( mTextUpdateInfo.mStartGlyphIndex,
772                     endGlyphIndexPlusOne - 1u,
773                     mModel->mVisualModel->mLines,
774                     startRemoveIndex,
775                     endRemoveIndex );
776
777     // Set the line index from where to insert the new laid-out lines.
778     mTextUpdateInfo.mStartLineIndex = startRemoveIndex;
779
780     LineRun* linesBuffer = mModel->mVisualModel->mLines.Begin();
781     mModel->mVisualModel->mLines.Erase( linesBuffer + startRemoveIndex,
782                                         linesBuffer + endRemoveIndex );
783   }
784
785   if( NO_OPERATION != ( COLOR & operations ) )
786   {
787     if( 0u != mModel->mVisualModel->mColorIndices.Count() )
788     {
789       ColorIndex* colorIndexBuffer = mModel->mVisualModel->mColorIndices.Begin();
790       mModel->mVisualModel->mColorIndices.Erase( colorIndexBuffer + mTextUpdateInfo.mStartGlyphIndex,
791                                                  colorIndexBuffer + endGlyphIndexPlusOne );
792     }
793
794     if( 0u != mModel->mVisualModel->mBackgroundColorIndices.Count() )
795     {
796       ColorIndex* backgroundColorIndexBuffer = mModel->mVisualModel->mBackgroundColorIndices.Begin();
797       mModel->mVisualModel->mBackgroundColorIndices.Erase( backgroundColorIndexBuffer + mTextUpdateInfo.mStartGlyphIndex,
798                                                            backgroundColorIndexBuffer + endGlyphIndexPlusOne );
799     }
800   }
801 }
802
803 void Controller::Impl::ClearModelData( CharacterIndex startIndex, CharacterIndex endIndex, OperationsMask operations )
804 {
805   if( mTextUpdateInfo.mClearAll ||
806       ( ( 0u == startIndex ) &&
807         ( mTextUpdateInfo.mPreviousNumberOfCharacters == endIndex + 1u ) ) )
808   {
809     ClearFullModelData( operations );
810   }
811   else
812   {
813     // Clear the model data related with characters.
814     ClearCharacterModelData( startIndex, endIndex, operations );
815
816     // Clear the model data related with glyphs.
817     ClearGlyphModelData( startIndex, endIndex, operations );
818   }
819
820   // The estimated number of lines. Used to avoid reallocations when layouting.
821   mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mModel->mVisualModel->mLines.Count(), mModel->mLogicalModel->mParagraphInfo.Count() );
822
823   mModel->mVisualModel->ClearCaches();
824 }
825
826 bool Controller::Impl::UpdateModel( OperationsMask operationsRequired )
827 {
828   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel\n" );
829
830   // Calculate the operations to be done.
831   const OperationsMask operations = static_cast<OperationsMask>( mOperationsPending & operationsRequired );
832
833   if( NO_OPERATION == operations )
834   {
835     // Nothing to do if no operations are pending and required.
836     return false;
837   }
838
839   Vector<Character>& srcCharacters = mModel->mLogicalModel->mText;
840   Vector<Character> displayCharacters;
841   bool useHiddenText = false;
842   if ( mHiddenInput && mEventData != NULL && !mEventData->mIsShowingPlaceholderText)
843   {
844     mHiddenInput->Substitute( srcCharacters,displayCharacters );
845     useHiddenText = true;
846   }
847
848   Vector<Character>& utf32Characters = useHiddenText ? displayCharacters : srcCharacters;
849   const Length numberOfCharacters = utf32Characters.Count();
850
851   // Index to the first character of the first paragraph to be updated.
852   CharacterIndex startIndex = 0u;
853   // Number of characters of the paragraphs to be removed.
854   Length paragraphCharacters = 0u;
855
856   CalculateTextUpdateIndices( paragraphCharacters );
857
858   // Check whether the indices for updating the text is valid
859   if ( numberOfCharacters > 0u &&
860        ( mTextUpdateInfo.mParagraphCharacterIndex > numberOfCharacters ||
861          mTextUpdateInfo.mRequestedNumberOfCharacters > numberOfCharacters ) )
862   {
863     std::string currentText;
864     Utf32ToUtf8( mModel->mLogicalModel->mText.Begin(), numberOfCharacters, currentText );
865
866     DALI_LOG_ERROR( "Controller::Impl::UpdateModel: mTextUpdateInfo has invalid indices\n" );
867     DALI_LOG_ERROR( "Number of characters: %d, current text is: %s\n", numberOfCharacters, currentText.c_str() );
868
869     // Dump mTextUpdateInfo
870     DALI_LOG_ERROR( "Dump mTextUpdateInfo:\n" );
871     DALI_LOG_ERROR( "     mTextUpdateInfo.mCharacterIndex = %u\n", mTextUpdateInfo.mCharacterIndex );
872     DALI_LOG_ERROR( "     mTextUpdateInfo.mNumberOfCharactersToRemove = %u\n", mTextUpdateInfo.mNumberOfCharactersToRemove );
873     DALI_LOG_ERROR( "     mTextUpdateInfo.mNumberOfCharactersToAdd = %u\n", mTextUpdateInfo.mNumberOfCharactersToAdd );
874     DALI_LOG_ERROR( "     mTextUpdateInfo.mPreviousNumberOfCharacters = %u\n", mTextUpdateInfo.mPreviousNumberOfCharacters );
875     DALI_LOG_ERROR( "     mTextUpdateInfo.mParagraphCharacterIndex = %u\n", mTextUpdateInfo.mParagraphCharacterIndex );
876     DALI_LOG_ERROR( "     mTextUpdateInfo.mRequestedNumberOfCharacters = %u\n", mTextUpdateInfo.mRequestedNumberOfCharacters );
877     DALI_LOG_ERROR( "     mTextUpdateInfo.mStartGlyphIndex = %u\n", mTextUpdateInfo.mStartGlyphIndex );
878     DALI_LOG_ERROR( "     mTextUpdateInfo.mStartLineIndex = %u\n", mTextUpdateInfo.mStartLineIndex );
879     DALI_LOG_ERROR( "     mTextUpdateInfo.mEstimatedNumberOfLines = %u\n", mTextUpdateInfo.mEstimatedNumberOfLines );
880     DALI_LOG_ERROR( "     mTextUpdateInfo.mClearAll = %d\n", mTextUpdateInfo.mClearAll );
881     DALI_LOG_ERROR( "     mTextUpdateInfo.mFullRelayoutNeeded = %d\n", mTextUpdateInfo.mFullRelayoutNeeded );
882     DALI_LOG_ERROR( "     mTextUpdateInfo.mIsLastCharacterNewParagraph = %d\n", mTextUpdateInfo.mIsLastCharacterNewParagraph );
883
884     return false;
885   }
886
887   startIndex = mTextUpdateInfo.mParagraphCharacterIndex;
888
889   if( mTextUpdateInfo.mClearAll ||
890       ( 0u != paragraphCharacters ) )
891   {
892     ClearModelData( startIndex, startIndex + ( ( paragraphCharacters > 0u ) ? paragraphCharacters - 1u : 0u ), operations );
893   }
894
895   mTextUpdateInfo.mClearAll = false;
896
897   // Whether the model is updated.
898   bool updated = false;
899
900   Vector<LineBreakInfo>& lineBreakInfo = mModel->mLogicalModel->mLineBreakInfo;
901   const Length requestedNumberOfCharacters = mTextUpdateInfo.mRequestedNumberOfCharacters;
902
903   if( NO_OPERATION != ( GET_LINE_BREAKS & operations ) )
904   {
905     // Retrieves the line break info. The line break info is used to split the text in 'paragraphs' to
906     // calculate the bidirectional info for each 'paragraph'.
907     // It's also used to layout the text (where it should be a new line) or to shape the text (text in different lines
908     // is not shaped together).
909     lineBreakInfo.Resize( numberOfCharacters, TextAbstraction::LINE_NO_BREAK );
910
911     SetLineBreakInfo( utf32Characters,
912                       startIndex,
913                       requestedNumberOfCharacters,
914                       lineBreakInfo );
915
916     // Create the paragraph info.
917     mModel->mLogicalModel->CreateParagraphInfo( startIndex,
918                                                 requestedNumberOfCharacters );
919     updated = true;
920   }
921
922   const bool getScripts = NO_OPERATION != ( GET_SCRIPTS & operations );
923   const bool validateFonts = NO_OPERATION != ( VALIDATE_FONTS & operations );
924
925   Vector<ScriptRun>& scripts = mModel->mLogicalModel->mScriptRuns;
926   Vector<FontRun>& validFonts = mModel->mLogicalModel->mFontRuns;
927
928   if( getScripts || validateFonts )
929   {
930     // Validates the fonts assigned by the application or assigns default ones.
931     // It makes sure all the characters are going to be rendered by the correct font.
932     MultilanguageSupport multilanguageSupport = MultilanguageSupport::Get();
933
934     if( getScripts )
935     {
936       // Retrieves the scripts used in the text.
937       multilanguageSupport.SetScripts( utf32Characters,
938                                        startIndex,
939                                        requestedNumberOfCharacters,
940                                        scripts );
941     }
942
943     if( validateFonts )
944     {
945       // Validate the fonts set through the mark-up string.
946       Vector<FontDescriptionRun>& fontDescriptionRuns = mModel->mLogicalModel->mFontDescriptionRuns;
947
948       // Get the default font's description.
949       TextAbstraction::FontDescription defaultFontDescription;
950       TextAbstraction::PointSize26Dot6 defaultPointSize = TextAbstraction::FontClient::DEFAULT_POINT_SIZE;
951
952       if( IsShowingPlaceholderText() && mEventData && ( NULL != mEventData->mPlaceholderFont ) )
953       {
954         // If the placeholder font is set specifically, only placeholder font is changed.
955         defaultFontDescription = mEventData->mPlaceholderFont->mFontDescription;
956         if( mEventData->mPlaceholderFont->sizeDefined )
957         {
958           defaultPointSize = mEventData->mPlaceholderFont->mDefaultPointSize * 64u;
959         }
960       }
961       else if( NULL != mFontDefaults )
962       {
963         // Set the normal font and the placeholder font.
964         defaultFontDescription = mFontDefaults->mFontDescription;
965
966         if( mTextFitEnabled )
967         {
968           defaultPointSize = mFontDefaults->mFitPointSize * 64u;
969         }
970         else
971         {
972           defaultPointSize = mFontDefaults->mDefaultPointSize * 64u;
973         }
974       }
975
976       // Validates the fonts. If there is a character with no assigned font it sets a default one.
977       // After this call, fonts are validated.
978       multilanguageSupport.ValidateFonts( utf32Characters,
979                                           scripts,
980                                           fontDescriptionRuns,
981                                           defaultFontDescription,
982                                           defaultPointSize,
983                                           startIndex,
984                                           requestedNumberOfCharacters,
985                                           validFonts );
986     }
987     updated = true;
988   }
989
990   Vector<Character> mirroredUtf32Characters;
991   bool textMirrored = false;
992   const Length numberOfParagraphs = mModel->mLogicalModel->mParagraphInfo.Count();
993   if( NO_OPERATION != ( BIDI_INFO & operations ) )
994   {
995     Vector<BidirectionalParagraphInfoRun>& bidirectionalInfo = mModel->mLogicalModel->mBidirectionalParagraphInfo;
996     bidirectionalInfo.Reserve( numberOfParagraphs );
997
998     // Calculates the bidirectional info for the whole paragraph if it contains right to left scripts.
999     SetBidirectionalInfo( utf32Characters,
1000                           scripts,
1001                           lineBreakInfo,
1002                           startIndex,
1003                           requestedNumberOfCharacters,
1004                           bidirectionalInfo,
1005                           mModel->mMatchSystemLanguageDirection,
1006                           mLayoutDirection );
1007
1008     if( 0u != bidirectionalInfo.Count() )
1009     {
1010       // Only set the character directions if there is right to left characters.
1011       Vector<CharacterDirection>& directions = mModel->mLogicalModel->mCharacterDirections;
1012       GetCharactersDirection( bidirectionalInfo,
1013                               numberOfCharacters,
1014                               startIndex,
1015                               requestedNumberOfCharacters,
1016                               directions );
1017
1018       // This paragraph has right to left text. Some characters may need to be mirrored.
1019       // TODO: consider if the mirrored string can be stored as well.
1020
1021       textMirrored = GetMirroredText( utf32Characters,
1022                                       directions,
1023                                       bidirectionalInfo,
1024                                       startIndex,
1025                                       requestedNumberOfCharacters,
1026                                       mirroredUtf32Characters );
1027     }
1028     else
1029     {
1030       // There is no right to left characters. Clear the directions vector.
1031       mModel->mLogicalModel->mCharacterDirections.Clear();
1032     }
1033     updated = true;
1034   }
1035
1036   Vector<GlyphInfo>& glyphs = mModel->mVisualModel->mGlyphs;
1037   Vector<CharacterIndex>& glyphsToCharactersMap = mModel->mVisualModel->mGlyphsToCharacters;
1038   Vector<Length>& charactersPerGlyph = mModel->mVisualModel->mCharactersPerGlyph;
1039   Vector<GlyphIndex> newParagraphGlyphs;
1040   newParagraphGlyphs.Reserve( numberOfParagraphs );
1041
1042   const Length currentNumberOfGlyphs = glyphs.Count();
1043   if( NO_OPERATION != ( SHAPE_TEXT & operations ) )
1044   {
1045     const Vector<Character>& textToShape = textMirrored ? mirroredUtf32Characters : utf32Characters;
1046     // Shapes the text.
1047     ShapeText( textToShape,
1048                lineBreakInfo,
1049                scripts,
1050                validFonts,
1051                startIndex,
1052                mTextUpdateInfo.mStartGlyphIndex,
1053                requestedNumberOfCharacters,
1054                glyphs,
1055                glyphsToCharactersMap,
1056                charactersPerGlyph,
1057                newParagraphGlyphs );
1058
1059     // Create the 'number of glyphs' per character and the glyph to character conversion tables.
1060     mModel->mVisualModel->CreateGlyphsPerCharacterTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters );
1061     mModel->mVisualModel->CreateCharacterToGlyphTable( startIndex, mTextUpdateInfo.mStartGlyphIndex, requestedNumberOfCharacters );
1062     updated = true;
1063   }
1064
1065   const Length numberOfGlyphs = glyphs.Count() - currentNumberOfGlyphs;
1066
1067   if( NO_OPERATION != ( GET_GLYPH_METRICS & operations ) )
1068   {
1069     GlyphInfo* glyphsBuffer = glyphs.Begin();
1070     mMetrics->GetGlyphMetrics( glyphsBuffer + mTextUpdateInfo.mStartGlyphIndex, numberOfGlyphs );
1071
1072     // Update the width and advance of all new paragraph characters.
1073     for( Vector<GlyphIndex>::ConstIterator it = newParagraphGlyphs.Begin(), endIt = newParagraphGlyphs.End(); it != endIt; ++it )
1074     {
1075       const GlyphIndex index = *it;
1076       GlyphInfo& glyph = *( glyphsBuffer + index );
1077
1078       glyph.xBearing = 0.f;
1079       glyph.width = 0.f;
1080       glyph.advance = 0.f;
1081     }
1082     updated = true;
1083   }
1084
1085   if( ( NULL != mEventData ) &&
1086       mEventData->mPreEditFlag &&
1087       ( 0u != mModel->mVisualModel->mCharactersToGlyph.Count() ) )
1088   {
1089     Vector< Dali::InputMethodContext::PreeditAttributeData > attrs;
1090     mEventData->mInputMethodContext.GetPreeditStyle( attrs );
1091     Dali::InputMethodContext::PreeditStyle type = Dali::InputMethodContext::PreeditStyle::NONE;
1092
1093     // Check the type of preedit and run it.
1094     for( Vector<Dali::InputMethodContext::PreeditAttributeData>::Iterator it = attrs.Begin(), endIt = attrs.End(); it != endIt; it++ )
1095     {
1096       Dali::InputMethodContext::PreeditAttributeData attrData = *it;
1097       DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::UpdateModel PreeditStyle type : %d  start %d end %d \n", attrData.preeditType, attrData.startIndex, attrData.endIndex  );
1098       type =  attrData.preeditType;
1099
1100       // Check the number of commit characters for the start position.
1101       unsigned int numberOfCommit = mEventData->mPrimaryCursorPosition - mEventData->mPreEditLength;
1102       Length numberOfIndices = attrData.endIndex - attrData.startIndex;
1103
1104       switch( type )
1105       {
1106         case Dali::InputMethodContext::PreeditStyle::UNDERLINE:
1107         {
1108           // Add the underline for the pre-edit text.
1109           GlyphRun underlineRun;
1110           underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
1111           underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
1112           mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1113           break;
1114         }
1115         case Dali::InputMethodContext::PreeditStyle::REVERSE:
1116         {
1117           Vector4 textColor = mModel->mVisualModel->GetTextColor();
1118           ColorRun backgroundColorRun;
1119           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1120           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1121           backgroundColorRun.color = textColor;
1122           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1123
1124           Vector4 backgroundColor = mModel->mVisualModel->GetBackgroundColor();
1125           Vector<ColorRun>  colorRuns;
1126           colorRuns.Resize( 1u );
1127           ColorRun& colorRun = *( colorRuns.Begin() );
1128           colorRun.color = backgroundColor;
1129           colorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1130           colorRun.characterRun.numberOfCharacters = numberOfIndices;
1131
1132           mModel->mLogicalModel->mColorRuns.PushBack( colorRun );
1133           break;
1134         }
1135         case Dali::InputMethodContext::PreeditStyle::HIGHLIGHT:
1136         {
1137           ColorRun backgroundColorRun;
1138           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1139           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1140           backgroundColorRun.color = LIGHT_BLUE;
1141           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1142           break;
1143         }
1144         case Dali::InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_1:
1145         {
1146           // CUSTOM_PLATFORM_STYLE_1 should be drawn with background and underline together.
1147           ColorRun backgroundColorRun;
1148           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1149           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1150           backgroundColorRun.color = BACKGROUND_SUB4;
1151           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1152
1153           GlyphRun underlineRun;
1154           underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
1155           underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
1156           mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1157           break;
1158         }
1159         case Dali::InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_2:
1160         {
1161           // CUSTOM_PLATFORM_STYLE_2 should be drawn with background and underline together.
1162           ColorRun backgroundColorRun;
1163           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1164           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1165           backgroundColorRun.color = BACKGROUND_SUB5;
1166           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1167
1168           GlyphRun underlineRun;
1169           underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
1170           underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
1171           mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1172           break;
1173         }
1174         case Dali::InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_3:
1175         {
1176           // CUSTOM_PLATFORM_STYLE_3 should be drawn with background and underline together.
1177           ColorRun backgroundColorRun;
1178           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1179           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1180           backgroundColorRun.color = BACKGROUND_SUB6;
1181           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1182
1183           GlyphRun underlineRun;
1184           underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
1185           underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
1186           mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1187           break;
1188         }
1189         case Dali::InputMethodContext::PreeditStyle::CUSTOM_PLATFORM_STYLE_4:
1190         {
1191           // CUSTOM_PLATFORM_STYLE_4 should be drawn with background and underline together.
1192           ColorRun backgroundColorRun;
1193           backgroundColorRun.characterRun.characterIndex = attrData.startIndex + numberOfCommit;
1194           backgroundColorRun.characterRun.numberOfCharacters = numberOfIndices;
1195           backgroundColorRun.color = BACKGROUND_SUB7;
1196           mModel->mLogicalModel->mBackgroundColorRuns.PushBack( backgroundColorRun );
1197
1198           GlyphRun underlineRun;
1199           underlineRun.glyphIndex = attrData.startIndex + numberOfCommit;
1200           underlineRun.numberOfGlyphs = attrData.endIndex - attrData.startIndex;
1201           mModel->mVisualModel->mUnderlineRuns.PushBack( underlineRun );
1202           break;
1203         }
1204         case Dali::InputMethodContext::PreeditStyle::NONE:
1205         default:
1206         {
1207           break;
1208         }
1209       }
1210     }
1211     attrs.Clear();
1212     updated = true;
1213   }
1214
1215   if( NO_OPERATION != ( COLOR & operations ) )
1216   {
1217     // Set the color runs in glyphs.
1218     SetColorSegmentationInfo( mModel->mLogicalModel->mColorRuns,
1219                               mModel->mVisualModel->mCharactersToGlyph,
1220                               mModel->mVisualModel->mGlyphsPerCharacter,
1221                               startIndex,
1222                               mTextUpdateInfo.mStartGlyphIndex,
1223                               requestedNumberOfCharacters,
1224                               mModel->mVisualModel->mColors,
1225                               mModel->mVisualModel->mColorIndices );
1226
1227     // Set the background color runs in glyphs.
1228     SetColorSegmentationInfo( mModel->mLogicalModel->mBackgroundColorRuns,
1229                               mModel->mVisualModel->mCharactersToGlyph,
1230                               mModel->mVisualModel->mGlyphsPerCharacter,
1231                               startIndex,
1232                               mTextUpdateInfo.mStartGlyphIndex,
1233                               requestedNumberOfCharacters,
1234                               mModel->mVisualModel->mBackgroundColors,
1235                               mModel->mVisualModel->mBackgroundColorIndices );
1236
1237     updated = true;
1238   }
1239
1240
1241   // The estimated number of lines. Used to avoid reallocations when layouting.
1242   mTextUpdateInfo.mEstimatedNumberOfLines = std::max( mModel->mVisualModel->mLines.Count(), mModel->mLogicalModel->mParagraphInfo.Count() );
1243
1244   // Set the previous number of characters for the next time the text is updated.
1245   mTextUpdateInfo.mPreviousNumberOfCharacters = numberOfCharacters;
1246
1247   return updated;
1248 }
1249
1250 void Controller::Impl::RetrieveDefaultInputStyle( InputStyle& inputStyle )
1251 {
1252   // Sets the default text's color.
1253   inputStyle.textColor = mTextColor;
1254   inputStyle.isDefaultColor = true;
1255
1256   inputStyle.familyName.clear();
1257   inputStyle.weight = TextAbstraction::FontWeight::NORMAL;
1258   inputStyle.width = TextAbstraction::FontWidth::NORMAL;
1259   inputStyle.slant = TextAbstraction::FontSlant::NORMAL;
1260   inputStyle.size = 0.f;
1261
1262   inputStyle.lineSpacing = 0.f;
1263
1264   inputStyle.underlineProperties.clear();
1265   inputStyle.shadowProperties.clear();
1266   inputStyle.embossProperties.clear();
1267   inputStyle.outlineProperties.clear();
1268
1269   inputStyle.isFamilyDefined = false;
1270   inputStyle.isWeightDefined = false;
1271   inputStyle.isWidthDefined = false;
1272   inputStyle.isSlantDefined = false;
1273   inputStyle.isSizeDefined = false;
1274
1275   inputStyle.isLineSpacingDefined = false;
1276
1277   inputStyle.isUnderlineDefined = false;
1278   inputStyle.isShadowDefined = false;
1279   inputStyle.isEmbossDefined = false;
1280   inputStyle.isOutlineDefined = false;
1281
1282   // Sets the default font's family name, weight, width, slant and size.
1283   if( mFontDefaults )
1284   {
1285     if( mFontDefaults->familyDefined )
1286     {
1287       inputStyle.familyName = mFontDefaults->mFontDescription.family;
1288       inputStyle.isFamilyDefined = true;
1289     }
1290
1291     if( mFontDefaults->weightDefined )
1292     {
1293       inputStyle.weight = mFontDefaults->mFontDescription.weight;
1294       inputStyle.isWeightDefined = true;
1295     }
1296
1297     if( mFontDefaults->widthDefined )
1298     {
1299       inputStyle.width = mFontDefaults->mFontDescription.width;
1300       inputStyle.isWidthDefined = true;
1301     }
1302
1303     if( mFontDefaults->slantDefined )
1304     {
1305       inputStyle.slant = mFontDefaults->mFontDescription.slant;
1306       inputStyle.isSlantDefined = true;
1307     }
1308
1309     if( mFontDefaults->sizeDefined )
1310     {
1311       inputStyle.size = mFontDefaults->mDefaultPointSize;
1312       inputStyle.isSizeDefined = true;
1313     }
1314   }
1315 }
1316
1317 float Controller::Impl::GetDefaultFontLineHeight()
1318 {
1319   FontId defaultFontId = 0u;
1320   if( NULL == mFontDefaults )
1321   {
1322     TextAbstraction::FontDescription fontDescription;
1323     defaultFontId = mFontClient.GetFontId( fontDescription );
1324   }
1325   else
1326   {
1327     defaultFontId = mFontDefaults->GetFontId( mFontClient );
1328   }
1329
1330   Text::FontMetrics fontMetrics;
1331   mMetrics->GetFontMetrics( defaultFontId, fontMetrics );
1332
1333   return( fontMetrics.ascender - fontMetrics.descender );
1334 }
1335
1336 void Controller::Impl::OnCursorKeyEvent( const Event& event )
1337 {
1338   if( NULL == mEventData || !IsShowingRealText() )
1339   {
1340     // Nothing to do if there is no text input.
1341     return;
1342   }
1343
1344   int keyCode = event.p1.mInt;
1345   bool isShiftModifier = event.p2.mBool;
1346
1347   CharacterIndex previousPrimaryCursorPosition = mEventData->mPrimaryCursorPosition;
1348
1349   if( Dali::DALI_KEY_CURSOR_LEFT == keyCode )
1350   {
1351     if( mEventData->mPrimaryCursorPosition > 0u )
1352     {
1353       if ( !isShiftModifier && mEventData->mDecorator->IsHighlightVisible() )
1354       {
1355         mEventData->mPrimaryCursorPosition = std::min(mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
1356       }
1357       else
1358       {
1359         mEventData->mPrimaryCursorPosition = CalculateNewCursorIndex( mEventData->mPrimaryCursorPosition - 1u );
1360       }
1361     }
1362   }
1363   else if( Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
1364   {
1365     if( mModel->mLogicalModel->mText.Count() > mEventData->mPrimaryCursorPosition )
1366     {
1367       if ( !isShiftModifier && mEventData->mDecorator->IsHighlightVisible() )
1368       {
1369         mEventData->mPrimaryCursorPosition = std::max(mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition);
1370       }
1371       else
1372       {
1373         mEventData->mPrimaryCursorPosition = CalculateNewCursorIndex( mEventData->mPrimaryCursorPosition );
1374       }
1375     }
1376   }
1377   else if( Dali::DALI_KEY_CURSOR_UP == keyCode && !isShiftModifier )
1378   {
1379     // Ignore Shift-Up for text selection for now.
1380
1381     // Get first the line index of the current cursor position index.
1382     CharacterIndex characterIndex = 0u;
1383
1384     if( mEventData->mPrimaryCursorPosition > 0u )
1385     {
1386       characterIndex = mEventData->mPrimaryCursorPosition - 1u;
1387     }
1388
1389     const LineIndex lineIndex = mModel->mVisualModel->GetLineOfCharacter( characterIndex );
1390     const LineIndex previousLineIndex = ( lineIndex > 0 ? lineIndex - 1u : lineIndex );
1391
1392     // Retrieve the cursor position info.
1393     CursorInfo cursorInfo;
1394     GetCursorPosition( mEventData->mPrimaryCursorPosition,
1395                        cursorInfo );
1396
1397     // Get the line above.
1398     const LineRun& line = *( mModel->mVisualModel->mLines.Begin() + previousLineIndex );
1399
1400     // Get the next hit 'y' point.
1401     const float hitPointY = cursorInfo.lineOffset - 0.5f * ( line.ascender - line.descender );
1402
1403     // Use the cursor hook position 'x' and the next hit 'y' position to calculate the new cursor index.
1404     bool matchedCharacter = false;
1405     mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1406                                                                       mModel->mLogicalModel,
1407                                                                       mMetrics,
1408                                                                       mEventData->mCursorHookPositionX,
1409                                                                       hitPointY,
1410                                                                       CharacterHitTest::TAP,
1411                                                                       matchedCharacter );
1412   }
1413   else if( Dali::DALI_KEY_CURSOR_DOWN == keyCode && !isShiftModifier )
1414   {
1415     // Ignore Shift-Down for text selection for now.
1416
1417     // Get first the line index of the current cursor position index.
1418     CharacterIndex characterIndex = 0u;
1419
1420     if( mEventData->mPrimaryCursorPosition > 0u )
1421     {
1422       characterIndex = mEventData->mPrimaryCursorPosition - 1u;
1423     }
1424
1425     const LineIndex lineIndex = mModel->mVisualModel->GetLineOfCharacter( characterIndex );
1426
1427     if( lineIndex + 1u < mModel->mVisualModel->mLines.Count() )
1428     {
1429       // Retrieve the cursor position info.
1430       CursorInfo cursorInfo;
1431       GetCursorPosition( mEventData->mPrimaryCursorPosition,
1432                          cursorInfo );
1433
1434       // Get the line below.
1435       const LineRun& line = *( mModel->mVisualModel->mLines.Begin() + lineIndex + 1u );
1436
1437       // Get the next hit 'y' point.
1438       const float hitPointY = cursorInfo.lineOffset + cursorInfo.lineHeight + 0.5f * ( line.ascender - line.descender );
1439
1440       // Use the cursor hook position 'x' and the next hit 'y' position to calculate the new cursor index.
1441       bool matchedCharacter = false;
1442       mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1443                                                                         mModel->mLogicalModel,
1444                                                                         mMetrics,
1445                                                                         mEventData->mCursorHookPositionX,
1446                                                                         hitPointY,
1447                                                                         CharacterHitTest::TAP,
1448                                                                         matchedCharacter );
1449     }
1450   }
1451
1452   if ( !isShiftModifier && mEventData->mState != EventData::SELECTING )
1453   {
1454     // Update selection position after moving the cursor
1455     mEventData->mLeftSelectionPosition = mEventData->mPrimaryCursorPosition;
1456     mEventData->mRightSelectionPosition = mEventData->mPrimaryCursorPosition;
1457   }
1458
1459   if ( isShiftModifier && IsShowingRealText() && mEventData->mShiftSelectionFlag )
1460   {
1461     // Handle text selection
1462     bool selecting = false;
1463
1464     if ( Dali::DALI_KEY_CURSOR_LEFT == keyCode || Dali::DALI_KEY_CURSOR_RIGHT == keyCode )
1465     {
1466       // Shift-Left/Right to select the text
1467       int cursorPositionDelta = mEventData->mPrimaryCursorPosition - previousPrimaryCursorPosition;
1468       if ( cursorPositionDelta > 0 || mEventData->mRightSelectionPosition > 0u ) // Check the boundary
1469       {
1470         mEventData->mRightSelectionPosition += cursorPositionDelta;
1471       }
1472       selecting = true;
1473     }
1474     else if ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition )
1475     {
1476       // Show no grab handles and text highlight if Shift-Up/Down pressed but no selected text
1477       selecting = true;
1478     }
1479
1480     if ( selecting )
1481     {
1482       // Notify the cursor position to the InputMethodContext.
1483       if( mEventData->mInputMethodContext )
1484       {
1485         mEventData->mInputMethodContext.SetCursorPosition( mEventData->mPrimaryCursorPosition );
1486         mEventData->mInputMethodContext.NotifyCursorPosition();
1487       }
1488
1489       ChangeState( EventData::SELECTING );
1490
1491       mEventData->mUpdateLeftSelectionPosition = true;
1492       mEventData->mUpdateRightSelectionPosition = true;
1493       mEventData->mUpdateGrabHandlePosition = true;
1494       mEventData->mUpdateHighlightBox = true;
1495
1496       // Hide the text selection popup if select the text using keyboard instead of moving grab handles
1497       if( mEventData->mGrabHandlePopupEnabled )
1498       {
1499         mEventData->mDecorator->SetPopupActive( false );
1500       }
1501     }
1502   }
1503   else
1504   {
1505     // Handle normal cursor move
1506     ChangeState( EventData::EDITING );
1507     mEventData->mUpdateCursorPosition = true;
1508   }
1509
1510   mEventData->mUpdateInputStyle = true;
1511   mEventData->mScrollAfterUpdatePosition = true;
1512 }
1513
1514 void Controller::Impl::OnTapEvent( const Event& event )
1515 {
1516   if( NULL != mEventData )
1517   {
1518     const unsigned int tapCount = event.p1.mUint;
1519
1520     if( 1u == tapCount )
1521     {
1522       if( IsShowingRealText() )
1523       {
1524         // Convert from control's coords to text's coords.
1525         const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1526         const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1527
1528         // Keep the tap 'x' position. Used to move the cursor.
1529         mEventData->mCursorHookPositionX = xPosition;
1530
1531         // Whether to touch point hits on a glyph.
1532         bool matchedCharacter = false;
1533         mEventData->mPrimaryCursorPosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1534                                                                           mModel->mLogicalModel,
1535                                                                           mMetrics,
1536                                                                           xPosition,
1537                                                                           yPosition,
1538                                                                           CharacterHitTest::TAP,
1539                                                                           matchedCharacter );
1540
1541         // When the cursor position is changing, delay cursor blinking
1542         mEventData->mDecorator->DelayCursorBlink();
1543       }
1544       else
1545       {
1546         mEventData->mPrimaryCursorPosition = 0u;
1547       }
1548
1549       // Update selection position after tapping
1550       mEventData->mLeftSelectionPosition = mEventData->mPrimaryCursorPosition;
1551       mEventData->mRightSelectionPosition = mEventData->mPrimaryCursorPosition;
1552
1553       mEventData->mUpdateCursorPosition = true;
1554       mEventData->mUpdateGrabHandlePosition = true;
1555       mEventData->mScrollAfterUpdatePosition = true;
1556       mEventData->mUpdateInputStyle = true;
1557
1558       // Notify the cursor position to the InputMethodContext.
1559       if( mEventData->mInputMethodContext )
1560       {
1561         mEventData->mInputMethodContext.SetCursorPosition( mEventData->mPrimaryCursorPosition );
1562         mEventData->mInputMethodContext.NotifyCursorPosition();
1563       }
1564     }
1565     else if( 2u == tapCount )
1566     {
1567       if( mEventData->mSelectionEnabled )
1568       {
1569         // Convert from control's coords to text's coords.
1570         const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1571         const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1572
1573         // Calculates the logical position from the x,y coords.
1574         RepositionSelectionHandles( xPosition,
1575                                     yPosition,
1576                                     mEventData->mDoubleTapAction );
1577       }
1578     }
1579   }
1580 }
1581
1582 void Controller::Impl::OnPanEvent( const Event& event )
1583 {
1584   if( NULL == mEventData )
1585   {
1586     // Nothing to do if there is no text input.
1587     return;
1588   }
1589
1590   const bool isHorizontalScrollEnabled = mEventData->mDecorator->IsHorizontalScrollEnabled();
1591   const bool isVerticalScrollEnabled = mEventData->mDecorator->IsVerticalScrollEnabled();
1592
1593   if( !isHorizontalScrollEnabled && !isVerticalScrollEnabled )
1594   {
1595     // Nothing to do if scrolling is not enabled.
1596     return;
1597   }
1598
1599   const int state = event.p1.mInt;
1600
1601   switch( state )
1602   {
1603     case Gesture::Started:
1604     {
1605       // Will remove the cursor, handles or text's popup, ...
1606       ChangeState( EventData::TEXT_PANNING );
1607       break;
1608     }
1609     case Gesture::Continuing:
1610     {
1611       const Vector2& layoutSize = mModel->mVisualModel->GetLayoutSize();
1612       const Vector2 currentScroll = mModel->mScrollPosition;
1613
1614       if( isHorizontalScrollEnabled )
1615       {
1616         const float displacementX = event.p2.mFloat;
1617         mModel->mScrollPosition.x += displacementX;
1618
1619         ClampHorizontalScroll( layoutSize );
1620       }
1621
1622       if( isVerticalScrollEnabled )
1623       {
1624         const float displacementY = event.p3.mFloat;
1625         mModel->mScrollPosition.y += displacementY;
1626
1627         ClampVerticalScroll( layoutSize );
1628       }
1629
1630       mEventData->mDecorator->UpdatePositions( mModel->mScrollPosition - currentScroll );
1631       break;
1632     }
1633     case Gesture::Finished:
1634     case Gesture::Cancelled: // FALLTHROUGH
1635     {
1636       // Will go back to the previous state to show the cursor, handles, the text's popup, ...
1637       ChangeState( mEventData->mPreviousState );
1638       break;
1639     }
1640     default:
1641       break;
1642   }
1643 }
1644
1645 void Controller::Impl::OnLongPressEvent( const Event& event )
1646 {
1647   DALI_LOG_INFO( gLogFilter, Debug::General, "Controller::OnLongPressEvent\n" );
1648
1649   if( !IsShowingRealText() && ( EventData::EDITING == mEventData->mState ) )
1650   {
1651     ChangeState( EventData::EDITING_WITH_POPUP );
1652     mEventData->mDecoratorUpdated = true;
1653     mEventData->mUpdateInputStyle = true;
1654   }
1655   else
1656   {
1657     if( mEventData->mSelectionEnabled )
1658     {
1659       // Convert from control's coords to text's coords.
1660       const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1661       const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1662
1663       // Calculates the logical position from the x,y coords.
1664       RepositionSelectionHandles( xPosition,
1665                                   yPosition,
1666                                   mEventData->mLongPressAction );
1667     }
1668   }
1669 }
1670
1671 void Controller::Impl::OnHandleEvent( const Event& event )
1672 {
1673   if( NULL == mEventData )
1674   {
1675     // Nothing to do if there is no text input.
1676     return;
1677   }
1678
1679   const unsigned int state = event.p1.mUint;
1680   const bool handleStopScrolling = ( HANDLE_STOP_SCROLLING == state );
1681   const bool isSmoothHandlePanEnabled = mEventData->mDecorator->IsSmoothHandlePanEnabled();
1682
1683   if( HANDLE_PRESSED == state )
1684   {
1685     // Convert from decorator's coords to text's coords.
1686     const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1687     const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1688
1689     // Need to calculate the handle's new position.
1690     bool matchedCharacter = false;
1691     const CharacterIndex handleNewPosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1692                                                                           mModel->mLogicalModel,
1693                                                                           mMetrics,
1694                                                                           xPosition,
1695                                                                           yPosition,
1696                                                                           CharacterHitTest::SCROLL,
1697                                                                           matchedCharacter );
1698
1699     if( Event::GRAB_HANDLE_EVENT == event.type )
1700     {
1701       ChangeState ( EventData::GRAB_HANDLE_PANNING );
1702
1703       if( handleNewPosition != mEventData->mPrimaryCursorPosition )
1704       {
1705         // Updates the cursor position if the handle's new position is different than the current one.
1706         mEventData->mUpdateCursorPosition = true;
1707         // Does not update the grab handle position if the smooth panning is enabled. (The decorator does it smooth).
1708         mEventData->mUpdateGrabHandlePosition = !isSmoothHandlePanEnabled;
1709         mEventData->mPrimaryCursorPosition = handleNewPosition;
1710       }
1711
1712       // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
1713       mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
1714     }
1715     else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
1716     {
1717       ChangeState ( EventData::SELECTION_HANDLE_PANNING );
1718
1719       if( ( handleNewPosition != mEventData->mLeftSelectionPosition ) &&
1720           ( handleNewPosition != mEventData->mRightSelectionPosition ) )
1721       {
1722         // Updates the highlight box if the handle's new position is different than the current one.
1723         mEventData->mUpdateHighlightBox = true;
1724         // Does not update the selection handle position if the smooth panning is enabled. (The decorator does it smooth).
1725         mEventData->mUpdateLeftSelectionPosition = !isSmoothHandlePanEnabled;
1726         mEventData->mLeftSelectionPosition = handleNewPosition;
1727       }
1728
1729       // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
1730       mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
1731
1732       // Will define the order to scroll the text to match the handle position.
1733       mEventData->mIsLeftHandleSelected = true;
1734       mEventData->mIsRightHandleSelected = false;
1735     }
1736     else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
1737     {
1738       ChangeState ( EventData::SELECTION_HANDLE_PANNING );
1739
1740       if( ( handleNewPosition != mEventData->mRightSelectionPosition ) &&
1741           ( handleNewPosition != mEventData->mLeftSelectionPosition ) )
1742       {
1743         // Updates the highlight box if the handle's new position is different than the current one.
1744         mEventData->mUpdateHighlightBox = true;
1745         // Does not update the selection handle position if the smooth panning is enabled. (The decorator does it smooth).
1746         mEventData->mUpdateRightSelectionPosition = !isSmoothHandlePanEnabled;
1747         mEventData->mRightSelectionPosition = handleNewPosition;
1748       }
1749
1750       // Updates the decorator if the soft handle panning is enabled. It triggers a relayout in the decorator and the new position of the handle is set.
1751       mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
1752
1753       // Will define the order to scroll the text to match the handle position.
1754       mEventData->mIsLeftHandleSelected = false;
1755       mEventData->mIsRightHandleSelected = true;
1756     }
1757   } // end ( HANDLE_PRESSED == state )
1758   else if( ( HANDLE_RELEASED == state ) ||
1759            handleStopScrolling )
1760   {
1761     CharacterIndex handlePosition = 0u;
1762     if( handleStopScrolling || isSmoothHandlePanEnabled )
1763     {
1764       // Convert from decorator's coords to text's coords.
1765       const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1766       const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1767
1768       bool matchedCharacter = false;
1769       handlePosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1770                                                     mModel->mLogicalModel,
1771                                                     mMetrics,
1772                                                     xPosition,
1773                                                     yPosition,
1774                                                     CharacterHitTest::SCROLL,
1775                                                     matchedCharacter );
1776     }
1777
1778     if( Event::GRAB_HANDLE_EVENT == event.type )
1779     {
1780       mEventData->mUpdateCursorPosition = true;
1781       mEventData->mUpdateGrabHandlePosition = true;
1782       mEventData->mUpdateInputStyle = true;
1783
1784       if( !IsClipboardEmpty() )
1785       {
1786         ChangeState( EventData::EDITING_WITH_PASTE_POPUP ); // Moving grabhandle will show Paste Popup
1787       }
1788
1789       if( handleStopScrolling || isSmoothHandlePanEnabled )
1790       {
1791         mEventData->mScrollAfterUpdatePosition = true;
1792         mEventData->mPrimaryCursorPosition = handlePosition;
1793       }
1794     }
1795     else if( Event::LEFT_SELECTION_HANDLE_EVENT == event.type )
1796     {
1797       ChangeState( EventData::SELECTING );
1798
1799       mEventData->mUpdateHighlightBox = true;
1800       mEventData->mUpdateLeftSelectionPosition = true;
1801       mEventData->mUpdateRightSelectionPosition = true;
1802
1803       if( handleStopScrolling || isSmoothHandlePanEnabled )
1804       {
1805         mEventData->mScrollAfterUpdatePosition = true;
1806
1807         if( ( handlePosition != mEventData->mRightSelectionPosition ) &&
1808             ( handlePosition != mEventData->mLeftSelectionPosition ) )
1809         {
1810           mEventData->mLeftSelectionPosition = handlePosition;
1811         }
1812       }
1813     }
1814     else if( Event::RIGHT_SELECTION_HANDLE_EVENT == event.type )
1815     {
1816       ChangeState( EventData::SELECTING );
1817
1818       mEventData->mUpdateHighlightBox = true;
1819       mEventData->mUpdateRightSelectionPosition = true;
1820       mEventData->mUpdateLeftSelectionPosition = true;
1821
1822       if( handleStopScrolling || isSmoothHandlePanEnabled )
1823       {
1824         mEventData->mScrollAfterUpdatePosition = true;
1825         if( ( handlePosition != mEventData->mRightSelectionPosition ) &&
1826             ( handlePosition != mEventData->mLeftSelectionPosition ) )
1827         {
1828           mEventData->mRightSelectionPosition = handlePosition;
1829         }
1830       }
1831     }
1832
1833     mEventData->mDecoratorUpdated = true;
1834   } // end ( ( HANDLE_RELEASED == state ) || ( HANDLE_STOP_SCROLLING == state ) )
1835   else if( HANDLE_SCROLLING == state )
1836   {
1837     const float xSpeed = event.p2.mFloat;
1838     const float ySpeed = event.p3.mFloat;
1839     const Vector2& layoutSize = mModel->mVisualModel->GetLayoutSize();
1840     const Vector2 currentScrollPosition = mModel->mScrollPosition;
1841
1842     mModel->mScrollPosition.x += xSpeed;
1843     mModel->mScrollPosition.y += ySpeed;
1844
1845     ClampHorizontalScroll( layoutSize );
1846     ClampVerticalScroll( layoutSize );
1847
1848     bool endOfScroll = false;
1849     if( Vector2::ZERO == ( currentScrollPosition - mModel->mScrollPosition ) )
1850     {
1851       // Notify the decorator there is no more text to scroll.
1852       // The decorator won't send more scroll events.
1853       mEventData->mDecorator->NotifyEndOfScroll();
1854       // Still need to set the position of the handle.
1855       endOfScroll = true;
1856     }
1857
1858     // Set the position of the handle.
1859     const bool scrollRightDirection = xSpeed > 0.f;
1860     const bool scrollBottomDirection = ySpeed > 0.f;
1861     const bool leftSelectionHandleEvent = Event::LEFT_SELECTION_HANDLE_EVENT == event.type;
1862     const bool rightSelectionHandleEvent = Event::RIGHT_SELECTION_HANDLE_EVENT == event.type;
1863
1864     if( Event::GRAB_HANDLE_EVENT == event.type )
1865     {
1866       ChangeState( EventData::GRAB_HANDLE_PANNING );
1867
1868       // Get the grab handle position in decorator coords.
1869       Vector2 position = mEventData->mDecorator->GetPosition( GRAB_HANDLE );
1870
1871       if( mEventData->mDecorator->IsHorizontalScrollEnabled() )
1872       {
1873         // Position the grag handle close to either the left or right edge.
1874         position.x = scrollRightDirection ? 0.f : mModel->mVisualModel->mControlSize.width;
1875       }
1876
1877       if( mEventData->mDecorator->IsVerticalScrollEnabled() )
1878       {
1879         position.x = mEventData->mCursorHookPositionX;
1880
1881         // Position the grag handle close to either the top or bottom edge.
1882         position.y = scrollBottomDirection ? 0.f : mModel->mVisualModel->mControlSize.height;
1883       }
1884
1885       // Get the new handle position.
1886       // The grab handle's position is in decorator's coords. Need to transforms to text's coords.
1887       bool matchedCharacter = false;
1888       const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1889                                                                          mModel->mLogicalModel,
1890                                                                          mMetrics,
1891                                                                          position.x - mModel->mScrollPosition.x,
1892                                                                          position.y - mModel->mScrollPosition.y,
1893                                                                          CharacterHitTest::SCROLL,
1894                                                                          matchedCharacter );
1895
1896       if( mEventData->mPrimaryCursorPosition != handlePosition )
1897       {
1898         mEventData->mUpdateCursorPosition = true;
1899         mEventData->mUpdateGrabHandlePosition = !isSmoothHandlePanEnabled;
1900         mEventData->mScrollAfterUpdatePosition = true;
1901         mEventData->mPrimaryCursorPosition = handlePosition;
1902       }
1903       mEventData->mUpdateInputStyle = mEventData->mUpdateCursorPosition;
1904
1905       // Updates the decorator if the soft handle panning is enabled.
1906       mEventData->mDecoratorUpdated = isSmoothHandlePanEnabled;
1907     }
1908     else if( leftSelectionHandleEvent || rightSelectionHandleEvent )
1909     {
1910       ChangeState( EventData::SELECTION_HANDLE_PANNING );
1911
1912       // Get the selection handle position in decorator coords.
1913       Vector2 position = mEventData->mDecorator->GetPosition( leftSelectionHandleEvent ? Text::LEFT_SELECTION_HANDLE : Text::RIGHT_SELECTION_HANDLE );
1914
1915       if( mEventData->mDecorator->IsHorizontalScrollEnabled() )
1916       {
1917         // Position the selection handle close to either the left or right edge.
1918         position.x = scrollRightDirection ? 0.f : mModel->mVisualModel->mControlSize.width;
1919       }
1920
1921       if( mEventData->mDecorator->IsVerticalScrollEnabled() )
1922       {
1923         position.x = mEventData->mCursorHookPositionX;
1924
1925         // Position the grag handle close to either the top or bottom edge.
1926         position.y = scrollBottomDirection ? 0.f : mModel->mVisualModel->mControlSize.height;
1927       }
1928
1929       // Get the new handle position.
1930       // The selection handle's position is in decorator's coords. Need to transform to text's coords.
1931       bool matchedCharacter = false;
1932       const CharacterIndex handlePosition = Text::GetClosestCursorIndex( mModel->mVisualModel,
1933                                                                          mModel->mLogicalModel,
1934                                                                          mMetrics,
1935                                                                          position.x - mModel->mScrollPosition.x,
1936                                                                          position.y - mModel->mScrollPosition.y,
1937                                                                          CharacterHitTest::SCROLL,
1938                                                                          matchedCharacter );
1939
1940       if( leftSelectionHandleEvent )
1941       {
1942         const bool differentHandles = ( mEventData->mLeftSelectionPosition != handlePosition ) && ( mEventData->mRightSelectionPosition != handlePosition );
1943
1944         if( differentHandles || endOfScroll )
1945         {
1946           mEventData->mUpdateHighlightBox = true;
1947           mEventData->mUpdateLeftSelectionPosition = !isSmoothHandlePanEnabled;
1948           mEventData->mUpdateRightSelectionPosition = isSmoothHandlePanEnabled;
1949           mEventData->mLeftSelectionPosition = handlePosition;
1950         }
1951       }
1952       else
1953       {
1954         const bool differentHandles = ( mEventData->mRightSelectionPosition != handlePosition ) && ( mEventData->mLeftSelectionPosition != handlePosition );
1955         if( differentHandles || endOfScroll )
1956         {
1957           mEventData->mUpdateHighlightBox = true;
1958           mEventData->mUpdateRightSelectionPosition = !isSmoothHandlePanEnabled;
1959           mEventData->mUpdateLeftSelectionPosition = isSmoothHandlePanEnabled;
1960           mEventData->mRightSelectionPosition = handlePosition;
1961         }
1962       }
1963
1964       if( mEventData->mUpdateLeftSelectionPosition || mEventData->mUpdateRightSelectionPosition )
1965       {
1966         RepositionSelectionHandles();
1967
1968         mEventData->mScrollAfterUpdatePosition = !isSmoothHandlePanEnabled;
1969       }
1970     }
1971     mEventData->mDecoratorUpdated = true;
1972   } // end ( HANDLE_SCROLLING == state )
1973 }
1974
1975 void Controller::Impl::OnSelectEvent( const Event& event )
1976 {
1977   if( NULL == mEventData )
1978   {
1979     // Nothing to do if there is no text.
1980     return;
1981   }
1982
1983   if( mEventData->mSelectionEnabled )
1984   {
1985     // Convert from control's coords to text's coords.
1986     const float xPosition = event.p2.mFloat - mModel->mScrollPosition.x;
1987     const float yPosition = event.p3.mFloat - mModel->mScrollPosition.y;
1988
1989     // Calculates the logical position from the x,y coords.
1990     RepositionSelectionHandles( xPosition,
1991                                 yPosition,
1992                                 Controller::NoTextTap::HIGHLIGHT );
1993   }
1994 }
1995
1996 void Controller::Impl::OnSelectAllEvent()
1997 {
1998   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "OnSelectAllEvent mEventData->mSelectionEnabled%s \n", mEventData->mSelectionEnabled?"true":"false");
1999
2000   if( NULL == mEventData )
2001   {
2002     // Nothing to do if there is no text.
2003     return;
2004   }
2005
2006   if( mEventData->mSelectionEnabled )
2007   {
2008     // Calculates the logical position from the start.
2009     RepositionSelectionHandles( 0.f - mModel->mScrollPosition.x,
2010                                 0.f - mModel->mScrollPosition.y,
2011                                 Controller::NoTextTap::HIGHLIGHT );
2012
2013     mEventData->mLeftSelectionPosition = 0u;
2014     mEventData->mRightSelectionPosition = mModel->mLogicalModel->mText.Count();
2015   }
2016 }
2017
2018 void Controller::Impl::RetrieveSelection( std::string& selectedText, bool deleteAfterRetrieval )
2019 {
2020   if( mEventData->mLeftSelectionPosition == mEventData->mRightSelectionPosition )
2021   {
2022     // Nothing to select if handles are in the same place.
2023     selectedText.clear();
2024     return;
2025   }
2026
2027   const bool handlesCrossed = mEventData->mLeftSelectionPosition > mEventData->mRightSelectionPosition;
2028
2029   //Get start and end position of selection
2030   const CharacterIndex startOfSelectedText = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
2031   const Length lengthOfSelectedText = ( handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition ) - startOfSelectedText;
2032
2033   Vector<Character>& utf32Characters = mModel->mLogicalModel->mText;
2034   const Length numberOfCharacters = utf32Characters.Count();
2035
2036   // Validate the start and end selection points
2037   if( ( startOfSelectedText + lengthOfSelectedText ) <= numberOfCharacters )
2038   {
2039     //Get text as a UTF8 string
2040     Utf32ToUtf8( &utf32Characters[startOfSelectedText], lengthOfSelectedText, selectedText );
2041
2042     if( deleteAfterRetrieval ) // Only delete text if copied successfully
2043     {
2044       // Keep a copy of the current input style.
2045       InputStyle currentInputStyle;
2046       currentInputStyle.Copy( mEventData->mInputStyle );
2047
2048       // Set as input style the style of the first deleted character.
2049       mModel->mLogicalModel->RetrieveStyle( startOfSelectedText, mEventData->mInputStyle );
2050
2051       // Compare if the input style has changed.
2052       const bool hasInputStyleChanged = !currentInputStyle.Equal( mEventData->mInputStyle );
2053
2054       if( hasInputStyleChanged )
2055       {
2056         const InputStyle::Mask styleChangedMask = currentInputStyle.GetInputStyleChangeMask( mEventData->mInputStyle );
2057         // Queue the input style changed signal.
2058         mEventData->mInputStyleChangedQueue.PushBack( styleChangedMask );
2059       }
2060
2061       mModel->mLogicalModel->UpdateTextStyleRuns( startOfSelectedText, -static_cast<int>( lengthOfSelectedText ) );
2062
2063       // Mark the paragraphs to be updated.
2064       if( Layout::Engine::SINGLE_LINE_BOX == mLayoutEngine.GetLayout() )
2065       {
2066         mTextUpdateInfo.mCharacterIndex = 0;
2067         mTextUpdateInfo.mNumberOfCharactersToRemove = mTextUpdateInfo.mPreviousNumberOfCharacters;
2068         mTextUpdateInfo.mNumberOfCharactersToAdd = mTextUpdateInfo.mPreviousNumberOfCharacters - lengthOfSelectedText;
2069         mTextUpdateInfo.mClearAll = true;
2070       }
2071       else
2072       {
2073         mTextUpdateInfo.mCharacterIndex = startOfSelectedText;
2074         mTextUpdateInfo.mNumberOfCharactersToRemove = lengthOfSelectedText;
2075       }
2076
2077       // Delete text between handles
2078       Vector<Character>::Iterator first = utf32Characters.Begin() + startOfSelectedText;
2079       Vector<Character>::Iterator last  = first + lengthOfSelectedText;
2080       utf32Characters.Erase( first, last );
2081
2082       // Will show the cursor at the first character of the selection.
2083       mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mRightSelectionPosition : mEventData->mLeftSelectionPosition;
2084     }
2085     else
2086     {
2087       // Will show the cursor at the last character of the selection.
2088       mEventData->mPrimaryCursorPosition = handlesCrossed ? mEventData->mLeftSelectionPosition : mEventData->mRightSelectionPosition;
2089     }
2090
2091     mEventData->mDecoratorUpdated = true;
2092   }
2093 }
2094
2095 void Controller::Impl::ShowClipboard()
2096 {
2097   if( mClipboard )
2098   {
2099     mClipboard.ShowClipboard();
2100   }
2101 }
2102
2103 void Controller::Impl::HideClipboard()
2104 {
2105   if( mClipboard && mClipboardHideEnabled )
2106   {
2107     mClipboard.HideClipboard();
2108   }
2109 }
2110
2111 void Controller::Impl::SetClipboardHideEnable(bool enable)
2112 {
2113   mClipboardHideEnabled = enable;
2114 }
2115
2116 bool Controller::Impl::CopyStringToClipboard( std::string& source )
2117 {
2118   //Send string to clipboard
2119   return ( mClipboard && mClipboard.SetItem( source ) );
2120 }
2121
2122 void Controller::Impl::SendSelectionToClipboard( bool deleteAfterSending )
2123 {
2124   std::string selectedText;
2125   RetrieveSelection( selectedText, deleteAfterSending );
2126   CopyStringToClipboard( selectedText );
2127   ChangeState( EventData::EDITING );
2128 }
2129
2130 void Controller::Impl::RequestGetTextFromClipboard()
2131 {
2132   if ( mClipboard )
2133   {
2134     mClipboard.RequestItem();
2135   }
2136 }
2137
2138 void Controller::Impl::RepositionSelectionHandles()
2139 {
2140   CharacterIndex selectionStart = mEventData->mLeftSelectionPosition;
2141   CharacterIndex selectionEnd = mEventData->mRightSelectionPosition;
2142
2143   if( selectionStart == selectionEnd )
2144   {
2145     // Nothing to select if handles are in the same place.
2146     // So, deactive Highlight box.
2147     mEventData->mDecorator->SetHighlightActive( false );
2148     return;
2149   }
2150
2151   mEventData->mDecorator->ClearHighlights();
2152
2153   const GlyphIndex* const charactersToGlyphBuffer = mModel->mVisualModel->mCharactersToGlyph.Begin();
2154   const Length* const glyphsPerCharacterBuffer = mModel->mVisualModel->mGlyphsPerCharacter.Begin();
2155   const GlyphInfo* const glyphsBuffer = mModel->mVisualModel->mGlyphs.Begin();
2156   const Vector2* const positionsBuffer = mModel->mVisualModel->mGlyphPositions.Begin();
2157   const Length* const charactersPerGlyphBuffer = mModel->mVisualModel->mCharactersPerGlyph.Begin();
2158   const CharacterIndex* const glyphToCharacterBuffer = mModel->mVisualModel->mGlyphsToCharacters.Begin();
2159   const CharacterDirection* const modelCharacterDirectionsBuffer = ( 0u != mModel->mLogicalModel->mCharacterDirections.Count() ) ? mModel->mLogicalModel->mCharacterDirections.Begin() : NULL;
2160
2161   const bool isLastCharacter = selectionEnd >= mModel->mLogicalModel->mText.Count();
2162   const CharacterDirection startDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + selectionStart ) );
2163   const CharacterDirection endDirection = ( ( NULL == modelCharacterDirectionsBuffer ) ? false : *( modelCharacterDirectionsBuffer + ( selectionEnd - ( isLastCharacter ? 1u : 0u ) ) ) );
2164
2165   // Swap the indices if the start is greater than the end.
2166   const bool indicesSwapped = selectionStart > selectionEnd;
2167
2168   // Tell the decorator to flip the selection handles if needed.
2169   mEventData->mDecorator->SetSelectionHandleFlipState( indicesSwapped, startDirection, endDirection );
2170
2171   if( indicesSwapped )
2172   {
2173     std::swap( selectionStart, selectionEnd );
2174   }
2175
2176   // Get the indices to the first and last selected glyphs.
2177   const CharacterIndex selectionEndMinusOne = selectionEnd - 1u;
2178   const GlyphIndex glyphStart = *( charactersToGlyphBuffer + selectionStart );
2179   const Length numberOfGlyphs = *( glyphsPerCharacterBuffer + selectionEndMinusOne );
2180   const GlyphIndex glyphEnd = *( charactersToGlyphBuffer + selectionEndMinusOne ) + ( ( numberOfGlyphs > 0 ) ? numberOfGlyphs - 1u : 0u );
2181
2182   // Get the lines where the glyphs are laid-out.
2183   const LineRun* lineRun = mModel->mVisualModel->mLines.Begin();
2184
2185   LineIndex lineIndex = 0u;
2186   Length numberOfLines = 0u;
2187   mModel->mVisualModel->GetNumberOfLines( glyphStart,
2188                                           1u + glyphEnd - glyphStart,
2189                                           lineIndex,
2190                                           numberOfLines );
2191   const LineIndex firstLineIndex = lineIndex;
2192
2193   // Create the structure to store some selection box info.
2194   Vector<SelectionBoxInfo> selectionBoxLinesInfo;
2195   selectionBoxLinesInfo.Resize( numberOfLines );
2196
2197   SelectionBoxInfo* selectionBoxInfo = selectionBoxLinesInfo.Begin();
2198   selectionBoxInfo->minX = MAX_FLOAT;
2199   selectionBoxInfo->maxX = MIN_FLOAT;
2200
2201   // Keep the min and max 'x' position to calculate the size and position of the highlighed text.
2202   float minHighlightX = std::numeric_limits<float>::max();
2203   float maxHighlightX = std::numeric_limits<float>::min();
2204   Size highLightSize;
2205   Vector2 highLightPosition; // The highlight position in decorator's coords.
2206
2207   // Retrieve the first line and get the line's vertical offset, the line's height and the index to the last glyph.
2208
2209   // The line's vertical offset of all the lines before the line where the first glyph is laid-out.
2210   selectionBoxInfo->lineOffset = CalculateLineOffset( mModel->mVisualModel->mLines,
2211                                                       firstLineIndex );
2212
2213   // Transform to decorator's (control) coords.
2214   selectionBoxInfo->lineOffset += mModel->mScrollPosition.y;
2215
2216   lineRun += firstLineIndex;
2217
2218   // The line height is the addition of the line ascender and the line descender.
2219   // However, the line descender has a negative value, hence the subtraction.
2220   selectionBoxInfo->lineHeight = lineRun->ascender - lineRun->descender;
2221
2222   GlyphIndex lastGlyphOfLine = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1u;
2223
2224   // Check if the first glyph is a ligature that must be broken like Latin ff, fi, or Arabic ﻻ, etc which needs special code.
2225   const Length numberOfCharactersStart = *( charactersPerGlyphBuffer + glyphStart );
2226   bool splitStartGlyph = ( numberOfCharactersStart > 1u ) && HasLigatureMustBreak( mModel->mLogicalModel->GetScript( selectionStart ) );
2227
2228   // Check if the last glyph is a ligature that must be broken like Latin ff, fi, or Arabic ﻻ, etc which needs special code.
2229   const Length numberOfCharactersEnd = *( charactersPerGlyphBuffer + glyphEnd );
2230   bool splitEndGlyph = ( glyphStart != glyphEnd ) && ( numberOfCharactersEnd > 1u ) && HasLigatureMustBreak( mModel->mLogicalModel->GetScript( selectionEndMinusOne ) );
2231
2232   // The number of quads of the selection box.
2233   const unsigned int numberOfQuads = 1u + ( glyphEnd - glyphStart ) + ( ( numberOfLines > 1u ) ? 2u * numberOfLines : 0u );
2234   mEventData->mDecorator->ResizeHighlightQuads( numberOfQuads );
2235
2236   // Count the actual number of quads.
2237   unsigned int actualNumberOfQuads = 0u;
2238   Vector4 quad;
2239
2240   // Traverse the glyphs.
2241   for( GlyphIndex index = glyphStart; index <= glyphEnd; ++index )
2242   {
2243     const GlyphInfo& glyph = *( glyphsBuffer + index );
2244     const Vector2& position = *( positionsBuffer + index );
2245
2246     if( splitStartGlyph )
2247     {
2248       // If the first glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box.
2249
2250       const float glyphAdvance = glyph.advance / static_cast<float>( numberOfCharactersStart );
2251       const CharacterIndex interGlyphIndex = selectionStart - *( glyphToCharacterBuffer + glyphStart );
2252       // Get the direction of the character.
2253       CharacterDirection isCurrentRightToLeft = false;
2254       if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
2255       {
2256         isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionStart );
2257       }
2258
2259       // The end point could be in the middle of the ligature.
2260       // Calculate the number of characters selected.
2261       const Length numberOfCharacters = ( glyphStart == glyphEnd ) ? ( selectionEnd - selectionStart ) : ( numberOfCharactersStart - interGlyphIndex );
2262
2263       quad.x = lineRun->alignmentOffset + position.x - glyph.xBearing + mModel->mScrollPosition.x + glyphAdvance * static_cast<float>( isCurrentRightToLeft ? ( numberOfCharactersStart - interGlyphIndex - numberOfCharacters ) : interGlyphIndex );
2264       quad.y = selectionBoxInfo->lineOffset;
2265       quad.z = quad.x + static_cast<float>( numberOfCharacters ) * glyphAdvance;
2266       quad.w = selectionBoxInfo->lineOffset + selectionBoxInfo->lineHeight;
2267
2268       // Store the min and max 'x' for each line.
2269       selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, quad.x );
2270       selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, quad.z );
2271
2272       mEventData->mDecorator->AddHighlight( actualNumberOfQuads, quad );
2273       ++actualNumberOfQuads;
2274
2275       splitStartGlyph = false;
2276       continue;
2277     }
2278
2279     if( splitEndGlyph && ( index == glyphEnd ) )
2280     {
2281       // Equally, if the last glyph is a ligature that must be broken it may be needed to add only part of the glyph to the highlight box.
2282
2283       const float glyphAdvance = glyph.advance / static_cast<float>( numberOfCharactersEnd );
2284       const CharacterIndex interGlyphIndex = selectionEnd - *( glyphToCharacterBuffer + glyphEnd );
2285       // Get the direction of the character.
2286       CharacterDirection isCurrentRightToLeft = false;
2287       if( NULL != modelCharacterDirectionsBuffer ) // If modelCharacterDirectionsBuffer is NULL, it means the whole text is left to right.
2288       {
2289         isCurrentRightToLeft = *( modelCharacterDirectionsBuffer + selectionEnd );
2290       }
2291
2292       const Length numberOfCharacters = numberOfCharactersEnd - interGlyphIndex;
2293
2294       quad.x = lineRun->alignmentOffset + position.x - glyph.xBearing + mModel->mScrollPosition.x + ( isCurrentRightToLeft ? ( glyphAdvance * static_cast<float>( numberOfCharacters ) ) : 0.f );
2295       quad.y = selectionBoxInfo->lineOffset;
2296       quad.z = quad.x + static_cast<float>( interGlyphIndex ) * glyphAdvance;
2297       quad.w = quad.y + selectionBoxInfo->lineHeight;
2298
2299       // Store the min and max 'x' for each line.
2300       selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, quad.x );
2301       selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, quad.z );
2302
2303       mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2304                                             quad );
2305       ++actualNumberOfQuads;
2306
2307       splitEndGlyph = false;
2308       continue;
2309     }
2310
2311     quad.x = lineRun->alignmentOffset + position.x - glyph.xBearing + mModel->mScrollPosition.x;
2312     quad.y = selectionBoxInfo->lineOffset;
2313     quad.z = quad.x + glyph.advance;
2314     quad.w = quad.y + selectionBoxInfo->lineHeight;
2315
2316     // Store the min and max 'x' for each line.
2317     selectionBoxInfo->minX = std::min( selectionBoxInfo->minX, quad.x );
2318     selectionBoxInfo->maxX = std::max( selectionBoxInfo->maxX, quad.z );
2319
2320     mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2321                                           quad );
2322     ++actualNumberOfQuads;
2323
2324     // Whether to retrieve the next line.
2325     if( index == lastGlyphOfLine )
2326     {
2327       ++lineIndex;
2328       if( lineIndex < firstLineIndex + numberOfLines )
2329       {
2330         // Retrieve the next line.
2331         ++lineRun;
2332
2333         // Get the last glyph of the new line.
2334         lastGlyphOfLine = lineRun->glyphRun.glyphIndex + lineRun->glyphRun.numberOfGlyphs - 1u;
2335
2336         // Keep the offset and height of the current selection box.
2337         const float currentLineOffset = selectionBoxInfo->lineOffset;
2338         const float currentLineHeight = selectionBoxInfo->lineHeight;
2339
2340         // Get the selection box info for the next line.
2341         ++selectionBoxInfo;
2342
2343         selectionBoxInfo->minX = MAX_FLOAT;
2344         selectionBoxInfo->maxX = MIN_FLOAT;
2345
2346         // Update the line's vertical offset.
2347         selectionBoxInfo->lineOffset = currentLineOffset + currentLineHeight;
2348
2349         // The line height is the addition of the line ascender and the line descender.
2350         // However, the line descender has a negative value, hence the subtraction.
2351         selectionBoxInfo->lineHeight = lineRun->ascender - lineRun->descender;
2352       }
2353     }
2354   }
2355
2356   // Traverses all the lines and updates the min and max 'x' positions and the total height.
2357   // The final width is calculated after 'boxifying' the selection.
2358   for( Vector<SelectionBoxInfo>::ConstIterator it = selectionBoxLinesInfo.Begin(),
2359          endIt = selectionBoxLinesInfo.End();
2360        it != endIt;
2361        ++it )
2362   {
2363     const SelectionBoxInfo& info = *it;
2364
2365     // Update the size of the highlighted text.
2366     highLightSize.height += info.lineHeight;
2367     minHighlightX = std::min( minHighlightX, info.minX );
2368     maxHighlightX = std::max( maxHighlightX, info.maxX );
2369   }
2370
2371   // Add extra geometry to 'boxify' the selection.
2372
2373   if( 1u < numberOfLines )
2374   {
2375     // Boxify the first line.
2376     lineRun = mModel->mVisualModel->mLines.Begin() + firstLineIndex;
2377     const SelectionBoxInfo& firstSelectionBoxLineInfo = *( selectionBoxLinesInfo.Begin() );
2378
2379     bool boxifyBegin = ( LTR != lineRun->direction ) && ( LTR != startDirection );
2380     bool boxifyEnd = ( LTR == lineRun->direction ) && ( LTR == startDirection );
2381
2382     if( boxifyBegin )
2383     {
2384       quad.x = 0.f;
2385       quad.y = firstSelectionBoxLineInfo.lineOffset;
2386       quad.z = firstSelectionBoxLineInfo.minX;
2387       quad.w = firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight;
2388
2389       // Boxify at the beginning of the line.
2390       mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2391                                             quad );
2392       ++actualNumberOfQuads;
2393
2394       // Update the size of the highlighted text.
2395       minHighlightX = 0.f;
2396     }
2397
2398     if( boxifyEnd )
2399     {
2400       quad.x = firstSelectionBoxLineInfo.maxX;
2401       quad.y = firstSelectionBoxLineInfo.lineOffset;
2402       quad.z = mModel->mVisualModel->mControlSize.width;
2403       quad.w = firstSelectionBoxLineInfo.lineOffset + firstSelectionBoxLineInfo.lineHeight;
2404
2405       // Boxify at the end of the line.
2406       mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2407                                             quad );
2408       ++actualNumberOfQuads;
2409
2410       // Update the size of the highlighted text.
2411       maxHighlightX = mModel->mVisualModel->mControlSize.width;
2412     }
2413
2414     // Boxify the central lines.
2415     if( 2u < numberOfLines )
2416     {
2417       for( Vector<SelectionBoxInfo>::ConstIterator it = selectionBoxLinesInfo.Begin() + 1u,
2418              endIt = selectionBoxLinesInfo.End() - 1u;
2419            it != endIt;
2420            ++it )
2421       {
2422         const SelectionBoxInfo& info = *it;
2423
2424         quad.x = 0.f;
2425         quad.y = info.lineOffset;
2426         quad.z = info.minX;
2427         quad.w = info.lineOffset + info.lineHeight;
2428
2429         mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2430                                               quad );
2431         ++actualNumberOfQuads;
2432
2433         quad.x = info.maxX;
2434         quad.y = info.lineOffset;
2435         quad.z = mModel->mVisualModel->mControlSize.width;
2436         quad.w = info.lineOffset + info.lineHeight;
2437
2438         mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2439                                               quad );
2440         ++actualNumberOfQuads;
2441       }
2442
2443       // Update the size of the highlighted text.
2444       minHighlightX = 0.f;
2445       maxHighlightX = mModel->mVisualModel->mControlSize.width;
2446     }
2447
2448     // Boxify the last line.
2449     lineRun = mModel->mVisualModel->mLines.Begin() + firstLineIndex + numberOfLines - 1u;
2450     const SelectionBoxInfo& lastSelectionBoxLineInfo = *( selectionBoxLinesInfo.End() - 1u );
2451
2452     boxifyBegin = ( LTR == lineRun->direction ) && ( LTR == endDirection );
2453     boxifyEnd = ( LTR != lineRun->direction ) && ( LTR != endDirection );
2454
2455     if( boxifyBegin )
2456     {
2457       quad.x = 0.f;
2458       quad.y = lastSelectionBoxLineInfo.lineOffset;
2459       quad.z = lastSelectionBoxLineInfo.minX;
2460       quad.w = lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight;
2461
2462       // Boxify at the beginning of the line.
2463       mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2464                                             quad );
2465       ++actualNumberOfQuads;
2466
2467       // Update the size of the highlighted text.
2468       minHighlightX = 0.f;
2469     }
2470
2471     if( boxifyEnd )
2472     {
2473       quad.x = lastSelectionBoxLineInfo.maxX;
2474       quad.y = lastSelectionBoxLineInfo.lineOffset;
2475       quad.z = mModel->mVisualModel->mControlSize.width;
2476       quad.w = lastSelectionBoxLineInfo.lineOffset + lastSelectionBoxLineInfo.lineHeight;
2477
2478       // Boxify at the end of the line.
2479       mEventData->mDecorator->AddHighlight( actualNumberOfQuads,
2480                                             quad );
2481       ++actualNumberOfQuads;
2482
2483       // Update the size of the highlighted text.
2484       maxHighlightX = mModel->mVisualModel->mControlSize.width;
2485     }
2486   }
2487
2488   // Set the actual number of quads.
2489   mEventData->mDecorator->ResizeHighlightQuads( actualNumberOfQuads );
2490
2491   // Sets the highlight's size and position. In decorator's coords.
2492   // The highlight's height has been calculated above (before 'boxifying' the highlight).
2493   highLightSize.width = maxHighlightX - minHighlightX;
2494
2495   highLightPosition.x = minHighlightX;
2496   const SelectionBoxInfo& firstSelectionBoxLineInfo = *( selectionBoxLinesInfo.Begin() );
2497   highLightPosition.y = firstSelectionBoxLineInfo.lineOffset;
2498
2499   mEventData->mDecorator->SetHighLightBox( highLightPosition, highLightSize, static_cast<float>( mModel->GetOutlineWidth() ) );
2500
2501   if( !mEventData->mDecorator->IsSmoothHandlePanEnabled() )
2502   {
2503     CursorInfo primaryCursorInfo;
2504     GetCursorPosition( mEventData->mLeftSelectionPosition,
2505                        primaryCursorInfo );
2506
2507     const Vector2 primaryPosition = primaryCursorInfo.primaryPosition + mModel->mScrollPosition;
2508
2509     mEventData->mDecorator->SetPosition( LEFT_SELECTION_HANDLE,
2510                                          primaryPosition.x,
2511                                          primaryCursorInfo.lineOffset + mModel->mScrollPosition.y,
2512                                          primaryCursorInfo.lineHeight );
2513
2514     CursorInfo secondaryCursorInfo;
2515     GetCursorPosition( mEventData->mRightSelectionPosition,
2516                        secondaryCursorInfo );
2517
2518     const Vector2 secondaryPosition = secondaryCursorInfo.primaryPosition + mModel->mScrollPosition;
2519
2520     mEventData->mDecorator->SetPosition( RIGHT_SELECTION_HANDLE,
2521                                          secondaryPosition.x,
2522                                          secondaryCursorInfo.lineOffset + mModel->mScrollPosition.y,
2523                                          secondaryCursorInfo.lineHeight );
2524   }
2525
2526   // Set the flag to update the decorator.
2527   mEventData->mDecoratorUpdated = true;
2528 }
2529
2530 void Controller::Impl::RepositionSelectionHandles( float visualX, float visualY, Controller::NoTextTap::Action action )
2531 {
2532   if( NULL == mEventData )
2533   {
2534     // Nothing to do if there is no text input.
2535     return;
2536   }
2537
2538   if( IsShowingPlaceholderText() )
2539   {
2540     // Nothing to do if there is the place-holder text.
2541     return;
2542   }
2543
2544   const Length numberOfGlyphs = mModel->mVisualModel->mGlyphs.Count();
2545   const Length numberOfLines  = mModel->mVisualModel->mLines.Count();
2546   if( ( 0 == numberOfGlyphs ) ||
2547       ( 0 == numberOfLines ) )
2548   {
2549     // Nothing to do if there is no text.
2550     return;
2551   }
2552
2553   // Find which word was selected
2554   CharacterIndex selectionStart( 0 );
2555   CharacterIndex selectionEnd( 0 );
2556   CharacterIndex noTextHitIndex( 0 );
2557   const bool characterHit = FindSelectionIndices( mModel->mVisualModel,
2558                                                   mModel->mLogicalModel,
2559                                                   mMetrics,
2560                                                   visualX,
2561                                                   visualY,
2562                                                   selectionStart,
2563                                                   selectionEnd,
2564                                                   noTextHitIndex );
2565   DALI_LOG_INFO( gLogFilter, Debug::Verbose, "%p selectionStart %d selectionEnd %d\n", this, selectionStart, selectionEnd );
2566
2567   if( characterHit || ( Controller::NoTextTap::HIGHLIGHT == action ) )
2568   {
2569     ChangeState( EventData::SELECTING );
2570
2571     mEventData->mLeftSelectionPosition = selectionStart;
2572     mEventData->mRightSelectionPosition = selectionEnd;
2573
2574     mEventData->mUpdateLeftSelectionPosition = true;
2575     mEventData->mUpdateRightSelectionPosition = true;
2576     mEventData->mUpdateHighlightBox = true;
2577
2578     // It may happen an InputMethodContext commit event arrives before the selection event
2579     // if the InputMethodContext is in pre-edit state. The commit event will set the
2580     // mEventData->mUpdateCursorPosition flag to true. If it's not set back
2581     // to false, the highlight box won't be updated.
2582     mEventData->mUpdateCursorPosition = false;
2583
2584     mEventData->mScrollAfterUpdatePosition = ( mEventData->mLeftSelectionPosition != mEventData->mRightSelectionPosition );
2585
2586     // Cursor to be positioned at end of selection so if selection interrupted and edit mode restarted the cursor will be at end of selection
2587     mEventData->mPrimaryCursorPosition = std::max( mEventData->mLeftSelectionPosition, mEventData->mRightSelectionPosition );
2588   }
2589   else if( Controller::NoTextTap::SHOW_SELECTION_POPUP == action )
2590   {
2591     // Nothing to select. i.e. a white space, out of bounds
2592     ChangeState( EventData::EDITING_WITH_POPUP );
2593
2594     mEventData->mPrimaryCursorPosition = noTextHitIndex;
2595
2596     mEventData->mUpdateCursorPosition = true;
2597     mEventData->mUpdateGrabHandlePosition = true;
2598     mEventData->mScrollAfterUpdatePosition = true;
2599     mEventData->mUpdateInputStyle = true;
2600   }
2601   else if( Controller::NoTextTap::NO_ACTION == action )
2602   {
2603     // Nothing to select. i.e. a white space, out of bounds
2604     mEventData->mPrimaryCursorPosition = noTextHitIndex;
2605
2606     mEventData->mUpdateCursorPosition = true;
2607     mEventData->mUpdateGrabHandlePosition = true;
2608     mEventData->mScrollAfterUpdatePosition = true;
2609     mEventData->mUpdateInputStyle = true;
2610   }
2611 }
2612
2613 void Controller::Impl::SetPopupButtons()
2614 {
2615   /**
2616    *  Sets the Popup buttons to be shown depending on State.
2617    *
2618    *  If SELECTING :  CUT & COPY + ( PASTE & CLIPBOARD if content available to paste )
2619    *
2620    *  If EDITING_WITH_POPUP : SELECT & SELECT_ALL
2621    */
2622
2623   TextSelectionPopup::Buttons buttonsToShow = TextSelectionPopup::NONE;
2624
2625   if( EventData::SELECTING == mEventData->mState )
2626   {
2627     buttonsToShow = TextSelectionPopup::Buttons(  TextSelectionPopup::CUT | TextSelectionPopup::COPY );
2628
2629     if( !IsClipboardEmpty() )
2630     {
2631       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
2632       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
2633     }
2634
2635     if( !mEventData->mAllTextSelected )
2636     {
2637       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::SELECT_ALL ) );
2638     }
2639   }
2640   else if( EventData::EDITING_WITH_POPUP == mEventData->mState )
2641   {
2642     if( mModel->mLogicalModel->mText.Count() && !IsShowingPlaceholderText() )
2643     {
2644       buttonsToShow = TextSelectionPopup::Buttons( TextSelectionPopup::SELECT | TextSelectionPopup::SELECT_ALL );
2645     }
2646
2647     if( !IsClipboardEmpty() )
2648     {
2649       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
2650       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
2651     }
2652   }
2653   else if( EventData::EDITING_WITH_PASTE_POPUP == mEventData->mState )
2654   {
2655     if ( !IsClipboardEmpty() )
2656     {
2657       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::PASTE ) );
2658       buttonsToShow = TextSelectionPopup::Buttons ( ( buttonsToShow | TextSelectionPopup::CLIPBOARD ) );
2659     }
2660   }
2661
2662   mEventData->mDecorator->SetEnabledPopupButtons( buttonsToShow );
2663 }
2664
2665 void Controller::Impl::ChangeState( EventData::State newState )
2666 {
2667   if( NULL == mEventData )
2668   {
2669     // Nothing to do if there is no text input.
2670     return;
2671   }
2672
2673   DALI_LOG_INFO( gLogFilter, Debug::General, "ChangeState state:%d  newstate:%d\n", mEventData->mState, newState );
2674
2675   if( mEventData->mState != newState )
2676   {
2677     mEventData->mPreviousState = mEventData->mState;
2678     mEventData->mState = newState;
2679
2680     switch( mEventData->mState )
2681     {
2682       case EventData::INACTIVE:
2683       {
2684         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
2685         mEventData->mDecorator->StopCursorBlink();
2686         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2687         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2688         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2689         mEventData->mDecorator->SetHighlightActive( false );
2690         mEventData->mDecorator->SetPopupActive( false );
2691         mEventData->mDecoratorUpdated = true;
2692         break;
2693       }
2694       case EventData::INTERRUPTED:
2695       {
2696         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2697         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2698         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2699         mEventData->mDecorator->SetHighlightActive( false );
2700         mEventData->mDecorator->SetPopupActive( false );
2701         mEventData->mDecoratorUpdated = true;
2702         break;
2703       }
2704       case EventData::SELECTING:
2705       {
2706         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
2707         mEventData->mDecorator->StopCursorBlink();
2708         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2709         if ( mEventData->mGrabHandleEnabled )
2710         {
2711           mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
2712           mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
2713         }
2714         mEventData->mDecorator->SetHighlightActive( true );
2715         if( mEventData->mGrabHandlePopupEnabled )
2716         {
2717           SetPopupButtons();
2718           mEventData->mDecorator->SetPopupActive( true );
2719         }
2720         mEventData->mDecoratorUpdated = true;
2721         break;
2722       }
2723       case EventData::EDITING:
2724       {
2725         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
2726         if( mEventData->mCursorBlinkEnabled )
2727         {
2728           mEventData->mDecorator->StartCursorBlink();
2729         }
2730         // Grab handle is not shown until a tap is received whilst EDITING
2731         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2732         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2733         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2734         mEventData->mDecorator->SetHighlightActive( false );
2735         if( mEventData->mGrabHandlePopupEnabled )
2736         {
2737           mEventData->mDecorator->SetPopupActive( false );
2738         }
2739         mEventData->mDecoratorUpdated = true;
2740         break;
2741       }
2742       case EventData::EDITING_WITH_POPUP:
2743       {
2744         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_POPUP \n", newState );
2745
2746         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
2747         if( mEventData->mCursorBlinkEnabled )
2748         {
2749           mEventData->mDecorator->StartCursorBlink();
2750         }
2751         if( mEventData->mSelectionEnabled )
2752         {
2753           mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2754           mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2755           mEventData->mDecorator->SetHighlightActive( false );
2756         }
2757         else if ( mEventData->mGrabHandleEnabled )
2758         {
2759           mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
2760         }
2761         if( mEventData->mGrabHandlePopupEnabled )
2762         {
2763           SetPopupButtons();
2764           mEventData->mDecorator->SetPopupActive( true );
2765         }
2766         mEventData->mDecoratorUpdated = true;
2767         break;
2768       }
2769       case EventData::EDITING_WITH_GRAB_HANDLE:
2770       {
2771         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_GRAB_HANDLE \n", newState );
2772
2773         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
2774         if( mEventData->mCursorBlinkEnabled )
2775         {
2776           mEventData->mDecorator->StartCursorBlink();
2777         }
2778         // Grab handle is not shown until a tap is received whilst EDITING
2779         if ( mEventData->mGrabHandleEnabled )
2780         {
2781           mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
2782         }
2783         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2784         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2785         mEventData->mDecorator->SetHighlightActive( false );
2786         if( mEventData->mGrabHandlePopupEnabled )
2787         {
2788           mEventData->mDecorator->SetPopupActive( false );
2789         }
2790         mEventData->mDecoratorUpdated = true;
2791         break;
2792       }
2793       case EventData::SELECTION_HANDLE_PANNING:
2794       {
2795         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
2796         mEventData->mDecorator->StopCursorBlink();
2797         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2798         if ( mEventData->mGrabHandleEnabled )
2799         {
2800           mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, true );
2801           mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, true );
2802         }
2803         mEventData->mDecorator->SetHighlightActive( true );
2804         if( mEventData->mGrabHandlePopupEnabled )
2805         {
2806           mEventData->mDecorator->SetPopupActive( false );
2807         }
2808         mEventData->mDecoratorUpdated = true;
2809         break;
2810       }
2811       case EventData::GRAB_HANDLE_PANNING:
2812       {
2813         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "GRAB_HANDLE_PANNING \n", newState );
2814
2815         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
2816         if( mEventData->mCursorBlinkEnabled )
2817         {
2818           mEventData->mDecorator->StartCursorBlink();
2819         }
2820         if ( mEventData->mGrabHandleEnabled )
2821         {
2822           mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
2823         }
2824         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2825         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2826         mEventData->mDecorator->SetHighlightActive( false );
2827         if( mEventData->mGrabHandlePopupEnabled )
2828         {
2829           mEventData->mDecorator->SetPopupActive( false );
2830         }
2831         mEventData->mDecoratorUpdated = true;
2832         break;
2833       }
2834       case EventData::EDITING_WITH_PASTE_POPUP:
2835       {
2836         DALI_LOG_INFO( gLogFilter, Debug::Verbose, "EDITING_WITH_PASTE_POPUP \n", newState );
2837
2838         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_PRIMARY );
2839         if( mEventData->mCursorBlinkEnabled )
2840         {
2841           mEventData->mDecorator->StartCursorBlink();
2842         }
2843
2844         if ( mEventData->mGrabHandleEnabled )
2845         {
2846           mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, true );
2847         }
2848         mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2849         mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2850         mEventData->mDecorator->SetHighlightActive( false );
2851
2852         if( mEventData->mGrabHandlePopupEnabled )
2853         {
2854           SetPopupButtons();
2855           mEventData->mDecorator->SetPopupActive( true );
2856         }
2857         mEventData->mDecoratorUpdated = true;
2858         break;
2859       }
2860       case EventData::TEXT_PANNING:
2861       {
2862         mEventData->mDecorator->SetActiveCursor( ACTIVE_CURSOR_NONE );
2863         mEventData->mDecorator->StopCursorBlink();
2864         mEventData->mDecorator->SetHandleActive( GRAB_HANDLE, false );
2865         if( mEventData->mDecorator->IsHandleActive( LEFT_SELECTION_HANDLE ) ||
2866             mEventData->mDecorator->IsHandleActive( RIGHT_SELECTION_HANDLE ) )
2867         {
2868           mEventData->mDecorator->SetHandleActive( LEFT_SELECTION_HANDLE, false );
2869           mEventData->mDecorator->SetHandleActive( RIGHT_SELECTION_HANDLE, false );
2870           mEventData->mDecorator->SetHighlightActive( true );
2871         }
2872
2873         if( mEventData->mGrabHandlePopupEnabled )
2874         {
2875           mEventData->mDecorator->SetPopupActive( false );
2876         }
2877
2878         mEventData->mDecoratorUpdated = true;
2879         break;
2880       }
2881     }
2882   }
2883 }
2884
2885 void Controller::Impl::GetCursorPosition( CharacterIndex logical,
2886                                           CursorInfo& cursorInfo )
2887 {
2888   if( !IsShowingRealText() )
2889   {
2890     // Do not want to use the place-holder text to set the cursor position.
2891
2892     // Use the line's height of the font's family set to set the cursor's size.
2893     // If there is no font's family set, use the default font.
2894     // Use the current alignment to place the cursor at the beginning, center or end of the box.
2895
2896     cursorInfo.lineOffset = 0.f;
2897     cursorInfo.lineHeight = GetDefaultFontLineHeight();
2898     cursorInfo.primaryCursorHeight = cursorInfo.lineHeight;
2899
2900     bool isRTL = false;
2901     if( mModel->mMatchSystemLanguageDirection )
2902     {
2903       isRTL = mLayoutDirection == LayoutDirection::RIGHT_TO_LEFT;
2904     }
2905
2906     switch( mModel->mHorizontalAlignment )
2907     {
2908       case Text::HorizontalAlignment::BEGIN :
2909       {
2910         if( isRTL )
2911         {
2912           cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
2913         }
2914         else
2915         {
2916           cursorInfo.primaryPosition.x = 0.f;
2917         }
2918         break;
2919       }
2920       case Text::HorizontalAlignment::CENTER:
2921       {
2922         cursorInfo.primaryPosition.x = floorf( 0.5f * mModel->mVisualModel->mControlSize.width );
2923         break;
2924       }
2925       case Text::HorizontalAlignment::END:
2926       {
2927         if( isRTL )
2928         {
2929           cursorInfo.primaryPosition.x = 0.f;
2930         }
2931         else
2932         {
2933           cursorInfo.primaryPosition.x = mModel->mVisualModel->mControlSize.width - mEventData->mDecorator->GetCursorWidth();
2934         }
2935         break;
2936       }
2937     }
2938
2939     // Nothing else to do.
2940     return;
2941   }
2942
2943   const bool isMultiLine = ( Layout::Engine::MULTI_LINE_BOX == mLayoutEngine.GetLayout() );
2944   GetCursorPositionParameters parameters;
2945   parameters.visualModel = mModel->mVisualModel;
2946   parameters.logicalModel = mModel->mLogicalModel;
2947   parameters.metrics = mMetrics;
2948   parameters.logical = logical;
2949   parameters.isMultiline = isMultiLine;
2950
2951   Text::GetCursorPosition( parameters,
2952                            cursorInfo );
2953
2954   // Adds Outline offset.
2955   const float outlineWidth = static_cast<float>( mModel->GetOutlineWidth() );
2956   cursorInfo.primaryPosition.x += outlineWidth;
2957   cursorInfo.primaryPosition.y += outlineWidth;
2958   cursorInfo.secondaryPosition.x += outlineWidth;
2959   cursorInfo.secondaryPosition.y += outlineWidth;
2960
2961   if( isMultiLine )
2962   {
2963     // If the text is editable and multi-line, the cursor position after a white space shouldn't exceed the boundaries of the text control.
2964
2965     // Note the white spaces laid-out at the end of the line might exceed the boundaries of the control.
2966     // The reason is a wrapped line must not start with a white space so they are laid-out at the end of the line.
2967
2968     if( 0.f > cursorInfo.primaryPosition.x )
2969     {
2970       cursorInfo.primaryPosition.x = 0.f;
2971     }
2972
2973     const float edgeWidth = mModel->mVisualModel->mControlSize.width - static_cast<float>( mEventData->mDecorator->GetCursorWidth() );
2974     if( cursorInfo.primaryPosition.x > edgeWidth )
2975     {
2976       cursorInfo.primaryPosition.x = edgeWidth;
2977     }
2978   }
2979 }
2980
2981 CharacterIndex Controller::Impl::CalculateNewCursorIndex( CharacterIndex index ) const
2982 {
2983   if( NULL == mEventData )
2984   {
2985     // Nothing to do if there is no text input.