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