Merge "Replace Signal with std::function." into devel/master
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / text / text-controller.h
1 #ifndef DALI_TOOLKIT_TEXT_CONTROLLER_H
2 #define DALI_TOOLKIT_TEXT_CONTROLLER_H
3
4 /*
5  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18  *
19  */
20
21 // EXTERNAL INCLUDES
22 #include <dali/devel-api/adaptor-framework/input-method-context.h>
23 #include <dali/public-api/events/gesture.h>
24
25 // INTERNAL INCLUDES
26 #include <dali-toolkit/devel-api/controls/text-controls/text-label-devel.h>
27 #include <dali-toolkit/devel-api/controls/text-controls/text-selection-popup-callback-interface.h>
28 #include <dali-toolkit/devel-api/text/text-enumerations-devel.h>
29 #include <dali-toolkit/internal/text/decorator/text-decorator.h>
30 #include <dali-toolkit/internal/text/hidden-text.h>
31 #include <dali-toolkit/internal/text/input-filter.h>
32 #include <dali-toolkit/internal/text/layouts/layout-engine.h>
33 #include <dali-toolkit/internal/text/text-anchor-control-interface.h>
34 #include <dali-toolkit/internal/text/text-model-interface.h>
35 #include <dali-toolkit/internal/text/text-selectable-control-interface.h>
36 #include <dali-toolkit/public-api/text/text-enumerations.h>
37
38 namespace Dali
39 {
40 namespace Toolkit
41 {
42 namespace Text
43 {
44 class Controller;
45 class ControlInterface;
46 class EditableControlInterface;
47 class View;
48 class RenderingController;
49
50 /**
51    * @brief Text selection operations .
52    */
53 enum SelectionType
54 {
55   INTERACTIVE = 0x0000,
56   ALL         = 0x0001,
57   NONE        = 0x0002
58 };
59
60 typedef IntrusivePtr<Controller> ControllerPtr;
61
62 /**
63  * @brief A Text Controller is used by UI Controls which display text.
64  *
65  * It manipulates the Logical & Visual text models on behalf of the UI Controls.
66  * It provides a view of the text that can be used by rendering back-ends.
67  *
68  * For selectable/editable UI controls, the controller handles input events from the UI control
69  * and decorations (grab handles etc) via the Decorator::ControllerInterface interface.
70  *
71  * The text selection popup button callbacks are as well handled via the TextSelectionPopupCallbackInterface interface.
72  */
73 class Controller : public RefObject, public Decorator::ControllerInterface, public TextSelectionPopupCallbackInterface, public HiddenText::Observer
74 {
75 public: // Enumerated types.
76   /**
77    * @brief Text related operations to be done in the relayout process.
78    */
79   enum OperationsMask
80   {
81     NO_OPERATION       = 0x0000,
82     CONVERT_TO_UTF32   = 0x0001,
83     GET_SCRIPTS        = 0x0002,
84     VALIDATE_FONTS     = 0x0004,
85     GET_LINE_BREAKS    = 0x0008,
86     BIDI_INFO          = 0x0010,
87     SHAPE_TEXT         = 0x0020,
88     GET_GLYPH_METRICS  = 0x0040,
89     LAYOUT             = 0x0080,
90     UPDATE_LAYOUT_SIZE = 0x0100,
91     REORDER            = 0x0200,
92     ALIGN              = 0x0400,
93     COLOR              = 0x0800,
94     UPDATE_DIRECTION   = 0x1000,
95     ALL_OPERATIONS     = 0xFFFF
96   };
97
98   /**
99    * @brief Used to distinguish between regular key events and InputMethodContext events
100    */
101   enum InsertType
102   {
103     COMMIT,
104     PRE_EDIT
105   };
106
107   /**
108    * @brief Used to specify whether to update the input style.
109    */
110   enum UpdateInputStyleType
111   {
112     UPDATE_INPUT_STYLE,
113     DONT_UPDATE_INPUT_STYLE
114   };
115
116   /**
117    * @brief Used to specify what has been updated after the Relayout() method has been called.
118    */
119   enum UpdateTextType
120   {
121     NONE_UPDATED      = 0x0, ///< Nothing has been updated.
122     MODEL_UPDATED     = 0x1, ///< The text's model has been updated.
123     DECORATOR_UPDATED = 0x2  ///< The decoration has been updated.
124   };
125
126   /**
127    * @brief Different placeholder-text can be shown when the control is active/inactive.
128    */
129   enum PlaceholderType
130   {
131     PLACEHOLDER_TYPE_ACTIVE,
132     PLACEHOLDER_TYPE_INACTIVE,
133   };
134
135   /**
136    * @brief Enumeration for Font Size Type.
137    */
138   enum FontSizeType
139   {
140     POINT_SIZE, // The size of font in points.
141     PIXEL_SIZE  // The size of font in pixels.
142   };
143
144   struct NoTextTap
145   {
146     enum Action
147     {
148       NO_ACTION,           ///< Does no action if there is a tap on top of an area with no text.
149       HIGHLIGHT,           ///< Highlights the nearest text (at the beginning or end of the text) and shows the text's selection popup.
150       SHOW_SELECTION_POPUP ///< Shows the text's selection popup.
151     };
152   };
153
154   struct TextFitInfo
155   {
156     enum Property
157     {
158       TEXT_FIT_ENABLE,
159       TEXT_FIT_MIN_SIZE,
160       TEXT_FIT_MAX_SIZE,
161       TEXT_FIT_STEP_SIZE,
162       TEXT_FIT_FONT_SIZE_TYPE
163     };
164   };
165
166 public: // Constructor.
167   /**
168    * @brief Create a new instance of a Controller.
169    *
170    * @return A pointer to a new Controller.
171    */
172   static ControllerPtr New();
173
174   /**
175    * @brief Create a new instance of a Controller.
176    *
177    * @param[in] controlInterface The control's interface.
178    *
179    * @return A pointer to a new Controller.
180    */
181   static ControllerPtr New(ControlInterface* controlInterface);
182
183   /**
184    * @brief Create a new instance of a Controller.
185    *
186    * @param[in] controlInterface The control's interface.
187    * @param[in] editableControlInterface The editable control's interface.
188    * @param[in] selectableControlInterface The selectable control's interface.
189    * @param[in] anchorControlInterface The anchor control's interface.
190    *
191    * @return A pointer to a new Controller.
192    */
193   static ControllerPtr New(ControlInterface*           controlInterface,
194                            EditableControlInterface*   editableControlInterface,
195                            SelectableControlInterface* selectableControlInterface,
196                            AnchorControlInterface*     anchorControlInterface);
197
198 public: // Configure the text controller.
199   /**
200    * @brief Called to enable text input.
201    *
202    * @note Selectable or editable controls should call this once after Controller::New().
203    * @param[in] decorator Used to create cursor, selection handle decorations etc.
204    * @param[in] inputMethodContext Used to manager ime.
205    */
206   void EnableTextInput(DecoratorPtr decorator, InputMethodContext& inputMethodContext);
207
208   /**
209    * @brief Used to switch between bitmap & vector based glyphs
210    *
211    * @param[in] glyphType The type of glyph; note that metrics for bitmap & vector based glyphs are different.
212    */
213   void SetGlyphType(TextAbstraction::GlyphType glyphType);
214
215   /**
216    * @brief Enables/disables the mark-up processor.
217    *
218    * By default is disabled.
219    *
220    * @param[in] enable Whether to enable the mark-up processor.
221    */
222   void SetMarkupProcessorEnabled(bool enable);
223
224   /**
225    * @brief Retrieves whether the mark-up processor is enabled.
226    *
227    * By default is disabled.
228    *
229    * @return @e true if the mark-up processor is enabled, otherwise returns @e false.
230    */
231   bool IsMarkupProcessorEnabled() const;
232
233   /**
234    * @brief Enables/disables the auto text scrolling
235    *
236    * By default is disabled.
237    *
238    * @param[in] enable Whether to enable the auto scrolling
239    */
240   void SetAutoScrollEnabled(bool enable);
241
242   /**
243    * @brief Retrieves whether auto text scrolling is enabled.
244    *
245    * By default is disabled.
246    *
247    * @return @e true if auto scrolling is enabled, otherwise returns @e false.
248    */
249   bool IsAutoScrollEnabled() const;
250
251   /**
252    * @brief Get direction of the text from the first line of text,
253    * @return bool rtl (right to left) is true
254    */
255   CharacterDirection GetAutoScrollDirection() const;
256
257   /**
258    * @brief Get the alignment offset of the first line of text.
259    *
260    * @return The alignment offset.
261    */
262   float GetAutoScrollLineAlignment() const;
263
264   /**
265    * @brief Enables the horizontal scrolling.
266    *
267    * @param[in] enable Whether to enable the horizontal scrolling.
268    */
269   void SetHorizontalScrollEnabled(bool enable);
270
271   /**
272    * @brief Retrieves whether the horizontal scrolling is enabled.
273    *
274    * @return @e true if the horizontal scrolling is enabled, otherwise it returns @e false.
275    */
276   bool IsHorizontalScrollEnabled() const;
277
278   /**
279    * @brief Enables the vertical scrolling.
280    *
281    * @param[in] enable Whether to enable the vertical scrolling.
282    */
283   void SetVerticalScrollEnabled(bool enable);
284
285   /**
286    * @brief Retrieves whether the verticall scrolling is enabled.
287    *
288    * @return @e true if the vertical scrolling is enabled, otherwise it returns @e false.
289    */
290   bool IsVerticalScrollEnabled() const;
291
292   /**
293    * @brief Enables the smooth handle panning.
294    *
295    * @param[in] enable Whether to enable the smooth handle panning.
296    */
297   void SetSmoothHandlePanEnabled(bool enable);
298
299   /**
300    * @brief Retrieves whether the smooth handle panning is enabled.
301    *
302    * @return @e true if the smooth handle panning is enabled.
303    */
304   bool IsSmoothHandlePanEnabled() const;
305
306   /**
307    * @brief Sets the maximum number of characters that can be inserted into the TextModel
308    *
309    * @param[in] maxCharacters maximum number of characters to be accepted
310    */
311   void SetMaximumNumberOfCharacters(Length maxCharacters);
312
313   /**
314    * @brief Sets the maximum number of characters that can be inserted into the TextModel
315    *
316    * @param[in] maxCharacters maximum number of characters to be accepted
317    */
318   int GetMaximumNumberOfCharacters();
319
320   /**
321    * @brief Called to enable/disable cursor blink.
322    *
323    * @note Only editable controls should calls this.
324    * @param[in] enabled Whether the cursor should blink or not.
325    */
326   void SetEnableCursorBlink(bool enable);
327
328   /**
329    * @brief Query whether cursor blink is enabled.
330    *
331    * @return Whether the cursor should blink or not.
332    */
333   bool GetEnableCursorBlink() const;
334
335   /**
336    * @brief Whether to enable the multi-line layout.
337    *
338    * @param[in] enable \e true enables the multi-line (by default)
339    */
340   void SetMultiLineEnabled(bool enable);
341
342   /**
343    * @return Whether the multi-line layout is enabled.
344    */
345   bool IsMultiLineEnabled() const;
346
347   /**
348    * @brief Sets the text's horizontal alignment.
349    *
350    * @param[in] alignment The horizontal alignment.
351    */
352   void SetHorizontalAlignment(HorizontalAlignment::Type alignment);
353
354   /**
355    * @copydoc ModelInterface::GetHorizontalAlignment()
356    */
357   HorizontalAlignment::Type GetHorizontalAlignment() const;
358
359   /**
360    * @brief Sets the text's vertical alignment.
361    *
362    * @param[in] alignment The vertical alignment.
363    */
364   void SetVerticalAlignment(VerticalAlignment::Type alignment);
365
366   /**
367    * @copydoc ModelInterface::GetVerticalAlignment()
368    */
369   VerticalAlignment::Type GetVerticalAlignment() const;
370
371   /**
372    * @brief Sets the text's wrap mode
373    * @param[in] text wrap mode The unit of wrapping
374    */
375   void SetLineWrapMode(Text::LineWrap::Mode textWarpMode);
376
377   /**
378    * @brief Retrieve text wrap mode previously set.
379    * @return text wrap mode
380    */
381   Text::LineWrap::Mode GetLineWrapMode() const;
382
383   /**
384    * @brief Enable or disable the text elide.
385    *
386    * @param[in] enabled Whether to enable the text elide.
387    */
388   void SetTextElideEnabled(bool enabled);
389
390   /**
391    * @copydoc ModelInterface::IsTextElideEnabled()
392    */
393   bool IsTextElideEnabled() const;
394
395   /**
396    * @brief Enable or disable the text fit.
397    *
398    * @param[in] enabled Whether to enable the text fit.
399    */
400   void SetTextFitEnabled(bool enabled);
401
402   /**
403    * @brief Whether the text fit is enabled or not.
404    *
405    * @return True if the text fit is enabled
406    */
407   bool IsTextFitEnabled() const;
408
409   /**
410    * @brief Sets minimum size valid for text fit.
411    *
412    * @param[in] minimum size value.
413    * @param[in] type The font size type is point size or pixel size
414    */
415   void SetTextFitMinSize(float pointSize, FontSizeType type);
416
417   /**
418    * @brief Retrieves the minimum point size valid for text fit.
419    *
420    * @return The minimum point size valid for text fit
421    */
422   float GetTextFitMinSize() const;
423
424   /**
425    * @brief Sets maximum size valid for text fit.
426    *
427    * @param[in] maximum size value.
428    * @param[in] type The font size type is point size or pixel size
429    */
430   void SetTextFitMaxSize(float pointSize, FontSizeType type);
431
432   /**
433    * @brief Retrieves the maximum point size valid for text fit.
434    *
435    * @return The maximum point size valid for text fit
436    */
437   float GetTextFitMaxSize() const;
438
439   /**
440    * @brief Sets step size for font increase valid for text fit.
441    *
442    * @param[in] step size value.
443    * @param[in] type The font size type is point size or pixel size
444    */
445   void SetTextFitStepSize(float step, FontSizeType type);
446
447   /**
448    * @brief Retrieves the step point size valid for text fit.
449    *
450    * @return The step point size valid for text fit
451    */
452   float GetTextFitStepSize() const;
453
454   /**
455    * @brief Sets content size valid for text fit.
456    *
457    * @param[in] Content size value.
458    */
459   void SetTextFitContentSize(Vector2 size);
460
461   /**
462    * @brief Retrieves the content size valid for text fit.
463    *
464    * @return The content size valid for text fit
465    */
466   Vector2 GetTextFitContentSize() const;
467
468   /**
469    * @brief Enable or disable the placeholder text elide.
470    * @param enabled Whether to enable the placeholder text elide.
471    */
472   void SetPlaceholderTextElideEnabled(bool enabled);
473
474   /**
475    * @brief Whether the placeholder text elide property is enabled.
476    * @return True if the placeholder text elide property is enabled, false otherwise.
477    */
478   bool IsPlaceholderTextElideEnabled() const;
479
480   /**
481    * @brief Enable or disable the text selection.
482    * @param[in] enabled Whether to enable the text selection.
483    */
484   void SetSelectionEnabled(bool enabled);
485
486   /**
487    * @brief Whether the text selection is enabled or not.
488    * @return True if the text selection is enabled
489    */
490   bool IsSelectionEnabled() const;
491
492   /**
493    * @brief Enable or disable the text selection using Shift key.
494    * @param enabled Whether to enable the text selection using Shift key
495    */
496   void SetShiftSelectionEnabled(bool enabled);
497
498   /**
499    * @brief Whether the text selection using Shift key is enabled or not.
500    * @return True if the text selection using Shift key is enabled
501    */
502   bool IsShiftSelectionEnabled() const;
503
504   /**
505    * @brief Enable or disable the grab handles for text selection.
506    *
507    * @param[in] enabled Whether to enable the grab handles
508    */
509   void SetGrabHandleEnabled(bool enabled);
510
511   /**
512    * @brief Returns whether the grab handles are enabled.
513    *
514    * @return True if the grab handles are enabled
515    */
516   bool IsGrabHandleEnabled() const;
517
518   /**
519    * @brief Enable or disable the grab handles for text selection.
520    *
521    * @param[in] enabled Whether to enable the grab handles
522    */
523   void SetGrabHandlePopupEnabled(bool enabled);
524
525   /**
526    * @brief Returns whether the grab handles are enabled.
527    *
528    * @return True if the grab handles are enabled
529    */
530   bool IsGrabHandlePopupEnabled() const;
531
532   /**
533    * @brief Sets input type to password
534    *
535    * @note The string is displayed hidden character
536    *
537    * @param[in] passwordInput True if password input is enabled.
538    */
539   void SetInputModePassword(bool passwordInput);
540
541   /**
542    * @brief Returns whether the input mode type is set as password.
543    *
544    * @return True if input mode type is password
545    */
546   bool IsInputModePassword();
547
548   /**
549    * @brief Sets the action when there is a double tap event on top of a text area with no text.
550    *
551    * @param[in] action The action to do.
552    */
553   void SetNoTextDoubleTapAction(NoTextTap::Action action);
554
555   /**
556    * @brief Retrieves the action when there is a double tap event on top of a text area with no text.
557    *
558    * @return The action to do.
559    */
560   NoTextTap::Action GetNoTextDoubleTapAction() const;
561
562   /**
563    * @briefSets the action when there is a long press event on top of a text area with no text.
564    *
565    * @param[in] action The action to do.
566    */
567   void SetNoTextLongPressAction(NoTextTap::Action action);
568
569   /**
570    * @brief Retrieves the action when there is a long press event on top of a text area with no text.
571    *
572    * @return The action to do.
573    */
574   NoTextTap::Action GetNoTextLongPressAction() const;
575
576   /**
577    * @brief Query if Underline settings were provided by string or map
578    * @return bool true if set by string
579    */
580   bool IsUnderlineSetByString();
581
582   /**
583    * Set method underline setting were set by
584    * @param[in] bool, true if set by string
585    */
586   void UnderlineSetByString(bool setByString);
587
588   /**
589    * @brief Query if shadow settings were provided by string or map
590    * @return bool true if set by string
591    */
592   bool IsShadowSetByString();
593
594   /**
595    * Set method shadow setting were set by
596    * @param[in] bool, true if set by string
597    */
598   void ShadowSetByString(bool setByString);
599
600   /**
601    * @brief Query if outline settings were provided by string or map
602    * @return bool true if set by string
603    */
604   bool IsOutlineSetByString();
605
606   /**
607    * Set method outline setting were set by
608    * @param[in] bool, true if set by string
609    */
610   void OutlineSetByString(bool setByString);
611
612   /**
613    * @brief Query if font style settings were provided by string or map
614    * @return bool true if set by string
615    */
616   bool IsFontStyleSetByString();
617
618   /**
619    * Set method font style setting were set by
620    * @param[in] bool, true if set by string
621    */
622   void FontStyleSetByString(bool setByString);
623
624 public: // Update.
625   /**
626    * @brief Replaces any text previously set.
627    *
628    * @note This will be converted into UTF-32 when stored in the text model.
629    * @param[in] text A string of UTF-8 characters.
630    */
631   void SetText(const std::string& text);
632
633   /**
634    * @brief Retrieve any text previously set.
635    *
636    * @param[out] text A string of UTF-8 characters.
637    */
638   void GetText(std::string& text) const;
639
640   /**
641    * @brief Replaces any placeholder text previously set.
642    *
643    * @param[in] type Different placeholder-text can be shown when the control is active/inactive.
644    * @param[in] text A string of UTF-8 characters.
645    */
646   void SetPlaceholderText(PlaceholderType type, const std::string& text);
647
648   /**
649    * @brief Retrieve any placeholder text previously set.
650    *
651    * @param[in] type Different placeholder-text can be shown when the control is active/inactive.
652    * @param[out] A string of UTF-8 characters.
653    */
654   void GetPlaceholderText(PlaceholderType type, std::string& text) const;
655
656   /**
657    * @ brief Update the text after a font change
658    * @param[in] newDefaultFont The new font to change to
659    */
660   void UpdateAfterFontChange(const std::string& newDefaultFont);
661
662   /**
663    * @brief The method acquires currently selected text
664    * @param selectedText variable to place selected text in
665    */
666   void RetrieveSelection(std::string& selectedText) const;
667
668   /**
669    * @brief The method sets selection in given range
670    * @param start index of first character
671    * @param end   index of first character after selection
672    */
673   void SetSelection(int start, int end);
674
675   /**
676    * @brief This method retrieve indexes of current selection
677    *
678    * @return a pair, where first element is left index of selection and second is the right one
679    */
680   std::pair<int, int> GetSelectionIndexes() const;
681
682   /**
683    * Place string in system clipboard
684    * @param source std::string
685    */
686   void CopyStringToClipboard(const std::string& source);
687
688   /**
689    * Place currently selected text in system clipboard
690    * @param deleteAfterSending flag pointing if text should be deleted after sending to clipboard
691    */
692   void SendSelectionToClipboard(bool deleteAfterSending);
693
694 public: // Default style & Input style
695   /**
696    * @brief Set the default font family.
697    *
698    * @param[in] defaultFontFamily The default font family.
699    */
700   void SetDefaultFontFamily(const std::string& defaultFontFamily);
701
702   /**
703    * @brief Retrieve the default font family.
704    *
705    * @return The default font family.
706    */
707   const std::string& GetDefaultFontFamily() const;
708
709   /**
710    * @brief Sets the placeholder text font family.
711    * @param[in] placeholderTextFontFamily The placeholder text font family.
712    */
713   void SetPlaceholderFontFamily(const std::string& placeholderTextFontFamily);
714
715   /**
716    * @brief Retrieves the placeholder text font family.
717    *
718    * @return The placeholder text font family
719    */
720   const std::string& GetPlaceholderFontFamily() const;
721
722   /**
723    * @brief Sets the default font weight.
724    *
725    * @param[in] weight The font weight.
726    */
727   void SetDefaultFontWeight(FontWeight weight);
728
729   /**
730    * @brief Whether the font's weight has been defined.
731    */
732   bool IsDefaultFontWeightDefined() const;
733
734   /**
735    * @brief Retrieves the default font weight.
736    *
737    * @return The default font weight.
738    */
739   FontWeight GetDefaultFontWeight() const;
740
741   /**
742    * @brief Sets the placeholder text font weight.
743    *
744    * @param[in] weight The font weight
745    */
746   void SetPlaceholderTextFontWeight(FontWeight weight);
747
748   /**
749    * @brief Whether the font's weight has been defined.
750    *
751    * @return True if the placeholder text font weight is defined
752    */
753   bool IsPlaceholderTextFontWeightDefined() const;
754
755   /**
756    * @brief Retrieves the placeholder text font weight.
757    *
758    * @return The placeholder text font weight
759    */
760   FontWeight GetPlaceholderTextFontWeight() const;
761
762   /**
763    * @brief Sets the default font width.
764    *
765    * @param[in] width The font width.
766    */
767   void SetDefaultFontWidth(FontWidth width);
768
769   /**
770    * @brief Whether the font's width has been defined.
771    */
772   bool IsDefaultFontWidthDefined() const;
773
774   /**
775    * @brief Retrieves the default font width.
776    *
777    * @return The default font width.
778    */
779   FontWidth GetDefaultFontWidth() const;
780
781   /**
782    * @brief Sets the placeholder text font width.
783    *
784    * @param[in] width The font width
785    */
786   void SetPlaceholderTextFontWidth(FontWidth width);
787
788   /**
789    * @brief Whether the font's width has been defined.
790    *
791    * @return True if the placeholder text font width is defined
792    */
793   bool IsPlaceholderTextFontWidthDefined() const;
794
795   /**
796    * @brief Retrieves the placeholder text font width.
797    *
798    * @return The placeholder text font width
799    */
800   FontWidth GetPlaceholderTextFontWidth() const;
801
802   /**
803    * @brief Sets the default font slant.
804    *
805    * @param[in] slant The font slant.
806    */
807   void SetDefaultFontSlant(FontSlant slant);
808
809   /**
810    * @brief Whether the font's slant has been defined.
811    */
812   bool IsDefaultFontSlantDefined() const;
813
814   /**
815    * @brief Retrieves the default font slant.
816    *
817    * @return The default font slant.
818    */
819   FontSlant GetDefaultFontSlant() const;
820
821   /**
822    * @brief Sets the placeholder text font slant.
823    *
824    * @param[in] slant The font slant
825    */
826   void SetPlaceholderTextFontSlant(FontSlant slant);
827
828   /**
829    * @brief Whether the font's slant has been defined.
830    *
831    * @return True if the placeholder text font slant is defined
832    */
833   bool IsPlaceholderTextFontSlantDefined() const;
834
835   /**
836    * @brief Retrieves the placeholder text font slant.
837    *
838    * @return The placeholder text font slant
839    */
840   FontSlant GetPlaceholderTextFontSlant() const;
841
842   /**
843    * @brief Set the default font size.
844    *
845    * @param[in] fontSize The default font size
846    * @param[in] type The font size type is point size or pixel size
847    */
848   void SetDefaultFontSize(float fontSize, FontSizeType type);
849
850   /**
851    * @brief Retrieve the default point size.
852    *
853    * @param[in] type The font size type
854    * @return The default point size.
855    */
856   float GetDefaultFontSize(FontSizeType type) const;
857
858   /**
859    * @brief Set the font size scale.
860    *
861    * @param[in] scale The font size scale
862    */
863   void SetFontSizeScale(float scale);
864
865   /**
866    * @brief Get the font size scale.
867    *
868    * @return The font size scale.
869    */
870   float GetFontSizeScale() const;
871
872   /**
873    * @brief Sets the Placeholder text font size.
874    * @param[in] fontSize The placeholder text font size
875    * @param[in] type The font size type is point size or pixel size
876    */
877   void SetPlaceholderTextFontSize(float fontSize, FontSizeType type);
878
879   /**
880    * @brief Retrieves the Placeholder text font size.
881    * @param[in] type The font size type
882    * @return The placeholder font size
883    */
884   float GetPlaceholderTextFontSize(FontSizeType type) const;
885
886   /**
887    * @brief Sets the text's default color.
888    *
889    * @param color The default color.
890    */
891   void SetDefaultColor(const Vector4& color);
892
893   /**
894    * @brief Retrieves the text's default color.
895    *
896    * @return The default color.
897    */
898   const Vector4& GetDefaultColor() const;
899
900   /**
901    * @brief Set the text color
902    *
903    * @param textColor The text color
904    */
905   void SetPlaceholderTextColor(const Vector4& textColor);
906
907   /**
908    * @brief Retrieve the text color
909    *
910    * @return The text color
911    */
912   const Vector4& GetPlaceholderTextColor() const;
913
914   /**
915    * @brief Set the shadow offset.
916    *
917    * @param[in] shadowOffset The shadow offset, 0,0 indicates no shadow.
918    */
919   void SetShadowOffset(const Vector2& shadowOffset);
920
921   /**
922    * @brief Retrieve the shadow offset.
923    *
924    * @return The shadow offset.
925    */
926   const Vector2& GetShadowOffset() const;
927
928   /**
929    * @brief Set the shadow color.
930    *
931    * @param[in] shadowColor The shadow color.
932    */
933   void SetShadowColor(const Vector4& shadowColor);
934
935   /**
936    * @brief Retrieve the shadow color.
937    *
938    * @return The shadow color.
939    */
940   const Vector4& GetShadowColor() const;
941
942   /**
943    * @brief Set the shadow blur radius.
944    *
945    * @param[in] shadowBlurRadius The shadow blur radius, 0,0 indicates no blur.
946    */
947   void SetShadowBlurRadius(const float& shadowBlurRadius);
948
949   /**
950    * @brief Retrieve the shadow blur radius.
951    *
952    * @return The shadow blur radius.
953    */
954   const float& GetShadowBlurRadius() const;
955
956   /**
957    * @brief Set the underline color.
958    *
959    * @param[in] color color of underline.
960    */
961   void SetUnderlineColor(const Vector4& color);
962
963   /**
964    * @brief Retrieve the underline color.
965    *
966    * @return The underline color.
967    */
968   const Vector4& GetUnderlineColor() const;
969
970   /**
971    * @brief Set the underline enabled flag.
972    *
973    * @param[in] enabled The underline enabled flag.
974    */
975   void SetUnderlineEnabled(bool enabled);
976
977   /**
978    * @brief Returns whether the text is underlined or not.
979    *
980    * @return The underline state.
981    */
982   bool IsUnderlineEnabled() const;
983
984   /**
985    * @brief Set the override used for underline height, 0 indicates height will be supplied by font metrics
986    *
987    * @param[in] height The height in pixels of the underline
988    */
989   void SetUnderlineHeight(float height);
990
991   /**
992    * @brief Retrieves the override height of an underline, 0 indicates height is supplied by font metrics
993    *
994    * @return The height of the underline, or 0 if height is not overrided.
995    */
996   float GetUnderlineHeight() const;
997
998   /**
999    * @brief Set the outline color.
1000    *
1001    * @param[in] color color of outline.
1002    */
1003   void SetOutlineColor(const Vector4& color);
1004
1005   /**
1006    * @brief Retrieve the outline color.
1007    *
1008    * @return The outline color.
1009    */
1010   const Vector4& GetOutlineColor() const;
1011
1012   /**
1013    * @brief Set the outline width
1014    *
1015    * @param[in] width The width in pixels of the outline, 0 indicates no outline
1016    */
1017   void SetOutlineWidth(uint16_t width);
1018
1019   /**
1020    * @brief Retrieves the width of an outline
1021    *
1022    * @return The width of the outline.
1023    */
1024   uint16_t GetOutlineWidth() const;
1025
1026   /**
1027    * @brief Set the background color.
1028    *
1029    * @param[in] color color of background.
1030    */
1031   void SetBackgroundColor(const Vector4& color);
1032
1033   /**
1034    * @brief Retrieve the background color.
1035    *
1036    * @return The background color.
1037    */
1038   const Vector4& GetBackgroundColor() const;
1039
1040   /**
1041    * @brief Set the background enabled flag.
1042    *
1043    * @param[in] enabled The background enabled flag.
1044    */
1045   void SetBackgroundEnabled(bool enabled);
1046
1047   /**
1048    * @brief Returns whether to enable text background or not.
1049    *
1050    * @return Whether text background is enabled.
1051    */
1052   bool IsBackgroundEnabled() const;
1053
1054   /**
1055    * @brief Sets the emboss's properties string.
1056    *
1057    * @note The string is stored to be recovered.
1058    *
1059    * @param[in] embossProperties The emboss's properties string.
1060    */
1061   void SetDefaultEmbossProperties(const std::string& embossProperties);
1062
1063   /**
1064    * @brief Retrieves the emboss's properties string.
1065    *
1066    * @return The emboss's properties string.
1067    */
1068   const std::string& GetDefaultEmbossProperties() const;
1069
1070   /**
1071    * @brief Sets the outline's properties string.
1072    *
1073    * @note The string is stored to be recovered.
1074    *
1075    * @param[in] outlineProperties The outline's properties string.
1076    */
1077   void SetDefaultOutlineProperties(const std::string& outlineProperties);
1078
1079   /**
1080    * @brief Retrieves the outline's properties string.
1081    *
1082    * @return The outline's properties string.
1083    */
1084   const std::string& GetDefaultOutlineProperties() const;
1085
1086   /**
1087    * @brief Sets the default line spacing.
1088    *
1089    * @param[in] lineSpacing The line spacing.
1090    *
1091    * @return True if lineSpacing has been updated, false otherwise
1092    */
1093   bool SetDefaultLineSpacing(float lineSpacing);
1094
1095   /**
1096    * @brief Retrieves the default line spacing.
1097    *
1098    * @return The line spacing.
1099    */
1100   float GetDefaultLineSpacing() const;
1101
1102   /**
1103    * @brief Sets the default line size.
1104    *
1105    * @param[in] lineSize The line size.
1106    *
1107    * @return True if lineSize has been updated, false otherwise
1108    */
1109   bool SetDefaultLineSize(float lineSize);
1110
1111   /**
1112    * @brief Retrieves the default line size.
1113    *
1114    * @return The line size.
1115    */
1116   float GetDefaultLineSize() const;
1117
1118   /**
1119    * @brief Sets the input text's color.
1120    *
1121    * @param[in] color The input text's color.
1122    */
1123   void SetInputColor(const Vector4& color);
1124
1125   /**
1126    * @brief Retrieves the input text's color.
1127    *
1128    * @return The input text's color.
1129    */
1130   const Vector4& GetInputColor() const;
1131
1132   /**
1133    * @brief Sets the input text's font family name.
1134    *
1135    * @param[in] fontFamily The text's font family name.
1136    */
1137   void SetInputFontFamily(const std::string& fontFamily);
1138
1139   /**
1140    * @brief Retrieves the input text's font family name.
1141    *
1142    * @return The input text's font family name.
1143    */
1144   const std::string& GetInputFontFamily() const;
1145
1146   /**
1147    * @brief Sets the input font's weight.
1148    *
1149    * @param[in] weight The input font's weight.
1150    */
1151   void SetInputFontWeight(FontWeight weight);
1152
1153   /**
1154    * @return Whether the font's weight has been defined.
1155    */
1156   bool IsInputFontWeightDefined() const;
1157
1158   /**
1159    * @brief Retrieves the input font's weight.
1160    *
1161    * @return The input font's weight.
1162    */
1163   FontWeight GetInputFontWeight() const;
1164
1165   /**
1166    * @brief Sets the input font's width.
1167    *
1168    * @param[in] width The input font's width.
1169    */
1170   void SetInputFontWidth(FontWidth width);
1171
1172   /**
1173    * @return Whether the font's width has been defined.
1174    */
1175   bool IsInputFontWidthDefined() const;
1176
1177   /**
1178    * @brief Retrieves the input font's width.
1179    *
1180    * @return The input font's width.
1181    */
1182   FontWidth GetInputFontWidth() const;
1183
1184   /**
1185    * @brief Sets the input font's slant.
1186    *
1187    * @param[in] slant The input font's slant.
1188    */
1189   void SetInputFontSlant(FontSlant slant);
1190
1191   /**
1192    * @return Whether the font's slant has been defined.
1193    */
1194   bool IsInputFontSlantDefined() const;
1195
1196   /**
1197    * @brief Retrieves the input font's slant.
1198    *
1199    * @return The input font's slant.
1200    */
1201   FontSlant GetInputFontSlant() const;
1202
1203   /**
1204    * @brief Sets the input font's point size.
1205    *
1206    * @param[in] size The input font's point size.
1207    */
1208   void SetInputFontPointSize(float size);
1209
1210   /**
1211    * @brief Retrieves the input font's point size.
1212    *
1213    * @return The input font's point size.
1214    */
1215   float GetInputFontPointSize() const;
1216
1217   /**
1218    * @brief Sets the input line spacing.
1219    *
1220    * @param[in] lineSpacing The line spacing.
1221    */
1222   void SetInputLineSpacing(float lineSpacing);
1223
1224   /**
1225    * @brief Retrieves the input line spacing.
1226    *
1227    * @return The line spacing.
1228    */
1229   float GetInputLineSpacing() const;
1230
1231   /**
1232    * @brief Sets the input shadow's properties string.
1233    *
1234    * @note The string is stored to be recovered.
1235    *
1236    * @param[in] shadowProperties The shadow's properties string.
1237    */
1238   void SetInputShadowProperties(const std::string& shadowProperties);
1239
1240   /**
1241    * @brief Retrieves the input shadow's properties string.
1242    *
1243    * @return The shadow's properties string.
1244    */
1245   const std::string& GetInputShadowProperties() const;
1246
1247   /**
1248    * @brief Sets the input underline's properties string.
1249    *
1250    * @note The string is stored to be recovered.
1251    *
1252    * @param[in] underlineProperties The underline's properties string.
1253    */
1254   void SetInputUnderlineProperties(const std::string& underlineProperties);
1255
1256   /**
1257    * @brief Retrieves the input underline's properties string.
1258    *
1259    * @return The underline's properties string.
1260    */
1261   const std::string& GetInputUnderlineProperties() const;
1262
1263   /**
1264    * @brief Sets the input emboss's properties string.
1265    *
1266    * @note The string is stored to be recovered.
1267    *
1268    * @param[in] embossProperties The emboss's properties string.
1269    */
1270   void SetInputEmbossProperties(const std::string& embossProperties);
1271
1272   /**
1273    * @brief Retrieves the input emboss's properties string.
1274    *
1275    * @return The emboss's properties string.
1276    */
1277   const std::string& GetInputEmbossProperties() const;
1278
1279   /**
1280    * @brief Sets input the outline's properties string.
1281    *
1282    * @note The string is stored to be recovered.
1283    *
1284    * @param[in] outlineProperties The outline's properties string.
1285    */
1286   void SetInputOutlineProperties(const std::string& outlineProperties);
1287
1288   /**
1289    * @brief Retrieves the input outline's properties string.
1290    *
1291    * @return The outline's properties string.
1292    */
1293   const std::string& GetInputOutlineProperties() const;
1294
1295   /**
1296    * @brief Set the control's interface.
1297    *
1298    * @param[in] controlInterface The control's interface.
1299    */
1300   void SetControlInterface(ControlInterface* controlInterface);
1301
1302   /**
1303    * @brief Set the anchor control's interface.
1304    *
1305    * @param[in] anchorControlInterface The control's interface.
1306    */
1307   void SetAnchorControlInterface(AnchorControlInterface* anchorControlInterface);
1308
1309 public: // Queries & retrieves.
1310   /**
1311    * @brief Return the layout engine.
1312    *
1313    * @return A reference to the layout engine.
1314    */
1315   Layout::Engine& GetLayoutEngine();
1316
1317   /**
1318    * @brief Return a view of the text.
1319    *
1320    * @return A reference to the view.
1321    */
1322   View& GetView();
1323
1324   /**
1325    * @copydoc Control::GetNaturalSize()
1326    */
1327   Vector3 GetNaturalSize();
1328
1329   /**
1330    * @copydoc Control::GetHeightForWidth()
1331    */
1332   float GetHeightForWidth(float width);
1333
1334   /**
1335    * @brief Calculates the point size for text for given layout()
1336    */
1337   void FitPointSizeforLayout(Size layoutSize);
1338
1339   /**
1340    * @brief Checks if the point size fits within the layout size.
1341    *
1342    * @return Whether the point size fits within the layout size.
1343    */
1344   bool CheckForTextFit(float pointSize, Size& layoutSize);
1345
1346   /**
1347    * @brief Retrieves the text's number of lines for a given width.
1348    * @param[in] width The width of the text's area.
1349    * @ return The number of lines.
1350    */
1351   int GetLineCount(float width);
1352
1353   /**
1354    * @brief Retrieves the text's model.
1355    *
1356    * @return A pointer to the text's model.
1357    */
1358   const ModelInterface* const GetTextModel() const;
1359
1360   /**
1361    * @brief Used to get scrolled distance by user input
1362    *
1363    * @return Distance from last scroll offset to new scroll offset
1364    */
1365   float GetScrollAmountByUserInput();
1366
1367   /**
1368    * @brief Get latest scroll amount, control size and layout size
1369    *
1370    * This method is used to get information of control's scroll
1371    * @param[out] scrollPosition The current scrolled position
1372    * @param[out] controlHeight The size of a UI control
1373    * @param[out] layoutHeight The size of a bounding box to layout text within.
1374    *
1375    * @return Whether the text scroll position is changed or not after last update.
1376    */
1377   bool GetTextScrollInfo(float& scrollPosition, float& controlHeight, float& layoutHeight);
1378
1379   /**
1380    * @brief Used to set the hidden input option
1381    */
1382   void SetHiddenInputOption(const Property::Map& options);
1383
1384   /**
1385    * @brief Used to get the hidden input option
1386    */
1387   void GetHiddenInputOption(Property::Map& options);
1388
1389   /**
1390    * @brief Used to set the input filter option
1391    */
1392   void SetInputFilterOption(const Property::Map& options);
1393
1394   /**
1395    * @brief Used to get the input filter option
1396    */
1397   void GetInputFilterOption(Property::Map& options);
1398
1399   /**
1400    * @brief Sets the Placeholder Properties.
1401    *
1402    * @param[in] map The placeholder property map
1403    */
1404   void SetPlaceholderProperty(const Property::Map& map);
1405
1406   /**
1407    * @brief Retrieves the Placeholder Property map.
1408    *
1409    * @param[out] map The property map
1410    */
1411   void GetPlaceholderProperty(Property::Map& map);
1412
1413   /**
1414    * @brief Checks text direction.
1415    * @return The text direction.
1416    */
1417   Toolkit::DevelText::TextDirection::Type GetTextDirection();
1418
1419   /**
1420    * @brief Retrieves vertical line alignment
1421    * @return The vertical line alignment
1422    */
1423   Toolkit::DevelText::VerticalLineAlignment::Type GetVerticalLineAlignment() const;
1424
1425   /**
1426    * @brief Sets vertical line alignment
1427    * @param[in] alignment The vertical line alignment for the text
1428    */
1429   void SetVerticalLineAlignment(Toolkit::DevelText::VerticalLineAlignment::Type alignment);
1430
1431   /**
1432    * @brief Retrieves ellipsis position
1433    * @return The ellipsis position
1434    */
1435   Toolkit::DevelText::EllipsisPosition::Type GetEllipsisPosition() const;
1436
1437   /**
1438    * @brief Sets ellipsis position
1439    * @param[in] ellipsisPosition The ellipsis position for the text
1440    */
1441   void SetEllipsisPosition(Toolkit::DevelText::EllipsisPosition::Type ellipsisPosition);
1442
1443   /**
1444    * @brief Retrieves ignoreSpaceAfterText value from model
1445    * @return The value of ignoreSpaceAfterText
1446    */
1447   bool IsIgnoreSpacesAfterText() const;
1448
1449   /**
1450    * @brief Sets ignoreSpaceAfterText value to model
1451    * @param[in] ignore The value of ignoreSpacesAfterText for the text
1452    */
1453   void SetIgnoreSpacesAfterText(bool ignore);
1454
1455   /**
1456    * @brief Sets SetMatchLayoutDirection value to model
1457    * @param[in] match The value of matchLayoutDirection for the text
1458    */
1459   void SetMatchLayoutDirection(DevelText::MatchLayoutDirection type);
1460
1461   /**
1462    * @brief Retrieves matchLayoutDirection value from model
1463    * @return The value of matchLayoutDirection
1464    */
1465   DevelText::MatchLayoutDirection GetMatchLayoutDirection() const;
1466
1467   /**
1468    * @brief Sets layoutDirection type value.
1469    * @param[in] layoutDirection The value of the layout direction type.
1470    */
1471   void SetLayoutDirection(Dali::LayoutDirection::Type layoutDirection);
1472
1473   /**
1474    * @brief Gets layoutDirection type value.
1475    * @param[in] actor The actor which will get the layout direction type.
1476    * @return The value of the layout direction type.
1477    */
1478   Dali::LayoutDirection::Type GetLayoutDirection(Dali::Actor& actor) const;
1479
1480   /**
1481    * @brief Sets the layout direction changed.
1482    */
1483   void ChangedLayoutDirection();
1484
1485   /**
1486    * @brief Retrieves if showing real text or not.
1487    * @return The value of showing real text.
1488    */
1489   bool IsShowingRealText() const;
1490
1491 public: // Relayout.
1492   /**
1493    * @brief Triggers a relayout which updates View (if necessary).
1494    *
1495    * @note UI Controls are expected to minimize calls to this method e.g. call once after size negotiation.
1496    * @param[in] size A the size of a bounding box to layout text within.
1497    * @param[in] layoutDirection The direction of the system language.
1498    *
1499    * @return Whether the text model or decorations were updated.
1500    */
1501   UpdateTextType Relayout(const Size& size, Dali::LayoutDirection::Type layoutDirection = Dali::LayoutDirection::LEFT_TO_RIGHT);
1502
1503   /**
1504    * @brief Request a relayout using the ControlInterface.
1505    */
1506   void RequestRelayout();
1507
1508 public: // Input style change signals.
1509   /**
1510    * @return Whether the queue of input style changed signals is empty.
1511    */
1512   bool IsInputStyleChangedSignalsQueueEmpty();
1513
1514   /**
1515    * @brief Process all pending input style changed signals.
1516    *
1517    * Calls the Text::ControlInterface::InputStyleChanged() method which is overriden by the
1518    * text controls. Text controls may send signals to state the input style has changed.
1519    */
1520   void ProcessInputStyleChangedSignals();
1521
1522 public: // Text-input Event Queuing.
1523   /**
1524    * @brief Called by editable UI controls when keyboard focus is gained.
1525    */
1526   void KeyboardFocusGainEvent();
1527
1528   /**
1529    * @brief Called by editable UI controls when focus is lost.
1530    */
1531   void KeyboardFocusLostEvent();
1532
1533   /**
1534    * @brief Called by editable UI controls when key events are received.
1535    *
1536    * @param[in] event The key event.
1537    * @param[in] type Used to distinguish between regular key events and InputMethodContext events.
1538    */
1539   bool KeyEvent(const Dali::KeyEvent& event);
1540
1541   /**
1542    * @brief Called by anchor when a tap gesture occurs.
1543    * @param[in] x The x position relative to the top-left of the parent control.
1544    * @param[in] y The y position relative to the top-left of the parent control.
1545    */
1546   void AnchorEvent(float x, float y);
1547
1548   /**
1549    * @brief Called by editable UI controls when a tap gesture occurs.
1550    * @param[in] tapCount The number of taps.
1551    * @param[in] x The x position relative to the top-left of the parent control.
1552    * @param[in] y The y position relative to the top-left of the parent control.
1553    */
1554   void TapEvent(unsigned int tapCount, float x, float y);
1555
1556   /**
1557    * @brief Called by editable UI controls when a pan gesture occurs.
1558    *
1559    * @param[in] state The state of the gesture.
1560    * @param[in] displacement This distance panned since the last pan gesture.
1561    */
1562   void PanEvent(GestureState state, const Vector2& displacement);
1563
1564   /**
1565    * @brief Called by editable UI controls when a long press gesture occurs.
1566    *
1567    * @param[in] state The state of the gesture.
1568    * @param[in] x The x position relative to the top-left of the parent control.
1569    * @param[in] y The y position relative to the top-left of the parent control.
1570    */
1571   void LongPressEvent(GestureState state, float x, float y);
1572
1573   /**
1574    * @brief Used to get the Primary cursor position.
1575    *
1576    * @return Primary cursor position.
1577    */
1578   CharacterIndex GetPrimaryCursorPosition() const;
1579
1580   /**
1581    * @brief Used to set the Primary cursor position.
1582    *
1583    * @param[in] index for the Primary cursor position.
1584    * @return[in] true if cursor position changed, false otherwise.
1585    */
1586   bool SetPrimaryCursorPosition(CharacterIndex index);
1587
1588   /**
1589    * @brief Creates a selection event.
1590    *
1591    * It could be called from the TapEvent (double tap) or when the text selection popup's sellect all button is pressed.
1592    *
1593    * @param[in] x The x position relative to the top-left of the parent control.
1594    * @param[in] y The y position relative to the top-left of the parent control.
1595    * @param[in] selection type like the whole text is selected or unselected.
1596    */
1597   void SelectEvent(float x, float y, SelectionType selection);
1598
1599   /**
1600    * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
1601    */
1602   void SetTextSelectionRange(const uint32_t* start, const uint32_t* end);
1603
1604   /**
1605    * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
1606    */
1607   Uint32Pair GetTextSelectionRange() const;
1608
1609   /**
1610    * @copydoc Text::SelectableControlInterface::SelectWholeText()
1611    */
1612   void SelectWholeText();
1613
1614   /**
1615    * @copydoc Text::SelectableControlInterface::SelectNone()
1616    */
1617   void SelectNone();
1618
1619   /**
1620    * @copydoc Text::SelectableControlInterface::GetSelectedText()
1621    */
1622   string GetSelectedText() const;
1623
1624   /**
1625    * @copydoc Text::EditableControlInterface::IsEditable()
1626    */
1627   virtual bool IsEditable() const;
1628
1629   /**
1630    * @copydoc Text::EditableControlInterface::SetEditable()
1631    */
1632   virtual void SetEditable(bool editable);
1633
1634   /**
1635    * @copydoc Dali::Toolkit::Internal::TextEditor::ScrollBy()
1636    */
1637   virtual void ScrollBy(Vector2 scroll);
1638
1639   /**
1640    * @copydoc Dali::Toolkit::Internal::TextEditor::GetHorizontalScrollPosition()
1641    */
1642   float GetHorizontalScrollPosition();
1643
1644   /**
1645    * @copydoc Dali::Toolkit::Internal::TextEditor::GetVerticalScrollPosition()
1646    */
1647   float GetVerticalScrollPosition();
1648
1649   /**
1650    * @brief Event received from input method context
1651    *
1652    * @param[in] inputMethodContext The input method context.
1653    * @param[in] inputMethodContextEvent The event received.
1654    * @return A data struture indicating if update is needed, cursor position and current text.
1655    */
1656   InputMethodContext::CallbackData OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent);
1657
1658   /**
1659    * @brief Event from Clipboard notifying an Item has been selected for pasting
1660    */
1661   void PasteClipboardItemEvent();
1662
1663   /**
1664    * @brief Return true when text control should clear key input focus when escape key is pressed.
1665    *
1666    * @return Whether text control should clear key input focus or not when escape key is pressed.
1667    */
1668   bool ShouldClearFocusOnEscape() const;
1669
1670   /**
1671    * @brief Create an actor that renders the text background color
1672    *
1673    * @return the created actor or an empty handle if no background color needs to be rendered.
1674    */
1675   Actor CreateBackgroundActor();
1676
1677   /**
1678    * @brief Used to reset the cursor position after setting a new text.
1679    *
1680    * @param[in] cursorIndex Where to place the cursor.
1681    */
1682   void ResetCursorPosition(CharacterIndex cursorIndex);
1683
1684   /**
1685    * @brief The method acquires current position of cursor
1686    * @return unsigned value with cursor position
1687    */
1688   CharacterIndex GetCursorPosition();
1689
1690 protected: // Inherit from Text::Decorator::ControllerInterface.
1691   /**
1692    * @copydoc Dali::Toolkit::Text::Decorator::ControllerInterface::GetTargetSize()
1693    */
1694   void GetTargetSize(Vector2& targetSize) override;
1695
1696   /**
1697    * @copydoc Dali::Toolkit::Text::Decorator::ControllerInterface::AddDecoration()
1698    */
1699   void AddDecoration(Actor& actor, bool needsClipping) override;
1700
1701   /**
1702    * @copydoc Dali::Toolkit::Text::Decorator::ControllerInterface::DecorationEvent()
1703    */
1704   void DecorationEvent(HandleType handle, HandleState state, float x, float y) override;
1705
1706 protected: // Inherit from TextSelectionPopup::TextPopupButtonCallbackInterface.
1707   /**
1708    * @copydoc Dali::Toolkit::TextSelectionPopup::TextPopupButtonCallbackInterface::TextPopupButtonTouched()
1709    */
1710   void TextPopupButtonTouched(Dali::Toolkit::TextSelectionPopup::Buttons button) override;
1711
1712 protected: // Inherit from HiddenText.
1713   /**
1714    * @brief Invoked from HiddenText when showing time of the last character was expired
1715    */
1716   void DisplayTimeExpired() override;
1717
1718 private: // Update.
1719   /**
1720    * @brief Called by editable UI controls when key events are received.
1721    *
1722    * @param[in] text The text to insert.
1723    * @param[in] type Used to distinguish between regular key events and InputMethodContext events.
1724    */
1725   void InsertText(const std::string& text, InsertType type);
1726
1727   /**
1728    * @brief Paste given string into Text model
1729    * @param[in] stringToPaste this string will be inserted into the text model
1730    */
1731   void PasteText(const std::string& stringToPaste);
1732
1733   /**
1734    * @brief Remove a given number of characters
1735    *
1736    * When predictve text is used the pre-edit text is removed and inserted again with the new characters.
1737    * The UpdateInputStyleType @type parameter if set to DONT_UPDATE_INPUT_STYLE avoids to update the input
1738    * style when pre-edit text is removed.
1739    *
1740    * @param[in] cursorOffset Start position from the current cursor position to start deleting characters.
1741    * @param[in] numberOfCharacters The number of characters to delete from the cursorOffset.
1742    * @param[in] type Whether to update the input style.
1743    * @return True if the remove was successful.
1744    */
1745   bool RemoveText(int                  cursorOffset,
1746                   int                  numberOfCharacters,
1747                   UpdateInputStyleType type);
1748
1749   /**
1750    * @brief Checks if text is selected and if so removes it.
1751    * @return true if text was removed
1752    */
1753   bool RemoveSelectedText();
1754
1755   /**
1756    * @brief Update anchor position from given number of inserted characters.
1757    *
1758    * @param[in] numberOfCharacters The number of inserted characters.
1759    * @param[in] previousCursorIndex A cursor position before event occurs.
1760    */
1761   void InsertTextAnchor(int            numberOfCharacters,
1762                         CharacterIndex previousCursorIndex);
1763
1764   /**
1765    * @brief Update anchor position from given number of removed characters.
1766    *
1767    * @param[in] cursorOffset Start position from the current cursor position to start deleting characters.
1768    * @param[in] numberOfCharacters The number of removed characters.
1769    * @param[in] previousCursorIndex A cursor position before event occurs.
1770    */
1771   void RemoveTextAnchor(int            cursorOffset,
1772                         int            numberOfCharacters,
1773                         CharacterIndex previousCursorIndex);
1774
1775 private: // Relayout.
1776   /**
1777    * @brief Lays-out the text.
1778    *
1779    * GetNaturalSize(), GetHeightForWidth() and Relayout() calls this method.
1780    *
1781    * @param[in] size A the size of a bounding box to layout text within.
1782    * @param[in] operations The layout operations which need to be done.
1783    * @param[out] layoutSize The size of the laid-out text.
1784    */
1785   bool DoRelayout(const Size&    size,
1786                   OperationsMask operations,
1787                   Size&          layoutSize);
1788
1789   /**
1790    * @brief Calulates the vertical offset to align the text inside the bounding box.
1791    *
1792    * @param[in] size The size of the bounding box.
1793    */
1794   void CalculateVerticalOffset(const Size& size);
1795
1796 private: // Events.
1797   /**
1798    * @brief Process queued events which modify the model.
1799    */
1800   void ProcessModifyEvents();
1801
1802   /**
1803    * @brief Used to process an event queued from SetText()
1804    */
1805   void TextReplacedEvent();
1806
1807   /**
1808    * @brief Used to process an event queued from key events etc.
1809    */
1810   void TextInsertedEvent();
1811
1812   /**
1813    * @brief Used to process an event queued from backspace key etc.
1814    */
1815   void TextDeletedEvent();
1816
1817   /**
1818    * @brief Helper to KeyEvent() to handle the backspace or delete key case.
1819    *
1820    * @param[in] keyCode The keycode for the key pressed
1821    * @return True if a character was deleted.
1822    */
1823   bool DeleteEvent(int keyCode);
1824
1825 private: // Helpers.
1826   /**
1827    * @brief Used to remove the text included the placeholder text.
1828    */
1829   void ResetText();
1830
1831   /**
1832    * @brief Helper to show the place holder text..
1833    */
1834   void ShowPlaceholderText();
1835
1836   /**
1837    * @brief Helper to clear font-specific data (only).
1838    */
1839   void ClearFontData();
1840
1841   /**
1842    * @brief Helper to clear text's style data.
1843    */
1844   void ClearStyleData();
1845
1846   /**
1847    * @brief Used to reset the scroll position after setting a new text.
1848    */
1849   void ResetScrollPosition();
1850
1851 private: // Private contructors & copy operator.
1852   /**
1853    * @brief Private constructor.
1854    */
1855   Controller();
1856
1857   /**
1858    * @brief Private constructor.
1859    */
1860   Controller(ControlInterface* controlInterface);
1861
1862   /**
1863    * @brief Private constructor.
1864    */
1865   Controller(ControlInterface*           controlInterface,
1866              EditableControlInterface*   editableControlInterface,
1867              SelectableControlInterface* selectableControlInterface,
1868              AnchorControlInterface*     anchorControlInterface);
1869
1870   // Undefined
1871   Controller(const Controller& handle);
1872
1873   // Undefined
1874   Controller& operator=(const Controller& handle);
1875
1876 protected: // Destructor.
1877   /**
1878    * @brief A reference counted object may only be deleted by calling Unreference().
1879    */
1880   virtual ~Controller();
1881
1882 public:
1883   struct Impl; ///< Made public for testing purposes
1884
1885 private:
1886   struct EventHandler;
1887   struct InputFontHandler;
1888   struct PlaceholderHandler;
1889   struct Relayouter;
1890   struct TextUpdater;
1891
1892   Impl* mImpl;
1893 };
1894
1895 } // namespace Text
1896
1897 } // namespace Toolkit
1898
1899 } // namespace Dali
1900
1901 #endif // DALI_TOOLKIT_TEXT_CONTROLLER_H