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