[dali_2.0.24] Merge branch 'devel/master'
[platform/core/uifw/dali-toolkit.git] / dali-toolkit / internal / controls / text-controls / text-field-impl.h
1 #ifndef DALI_TOOLKIT_INTERNAL_TEXT_FIELD_H
2 #define DALI_TOOLKIT_INTERNAL_TEXT_FIELD_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/clipboard-event-notifier.h>
23 #include <dali/devel-api/adaptor-framework/input-method-context.h>
24
25 // INTERNAL INCLUDES
26 #include <dali-toolkit/devel-api/controls/control-devel.h>
27 #include <dali-toolkit/devel-api/controls/text-controls/text-field-devel.h>
28 #include <dali-toolkit/internal/controls/control/control-data-impl.h>
29 #include <dali-toolkit/internal/text/decorator/text-decorator.h>
30 #include <dali-toolkit/internal/text/rendering/text-renderer.h>
31 #include <dali-toolkit/internal/text/text-anchor-control-interface.h>
32 #include <dali-toolkit/internal/text/text-control-interface.h>
33 #include <dali-toolkit/internal/text/text-controller.h>
34 #include <dali-toolkit/internal/text/text-editable-control-interface.h>
35 #include <dali-toolkit/internal/text/text-selectable-control-interface.h>
36 #include <dali-toolkit/public-api/controls/control-impl.h>
37 #include <dali-toolkit/public-api/controls/text-controls/text-field.h>
38
39 namespace Dali
40 {
41 namespace Toolkit
42 {
43 namespace Internal
44 {
45 /**
46  * @brief A control which renders a short text string.
47  */
48 class TextField : public Control, public Text::ControlInterface, public Text::EditableControlInterface, public Text::SelectableControlInterface, public Text::AnchorControlInterface
49 {
50 public:
51   /**
52    * @copydoc Dali::Toollkit::TextField::New()
53    */
54   static Toolkit::TextField New();
55
56   // Properties
57
58   /**
59    * @brief Called when a property of an object of this type is set.
60    *
61    * @param[in] object The object whose property is set.
62    * @param[in] index The property index.
63    * @param[in] value The new property value.
64    */
65   static void SetProperty(BaseObject* object, Property::Index index, const Property::Value& value);
66
67   /**
68    * @brief Called to retrieve a property of an object of this type.
69    *
70    * @param[in] object The object whose property is to be retrieved.
71    * @param[in] index The property index.
72    * @return The current value of the property.
73    */
74   static Property::Value GetProperty(BaseObject* object, Property::Index index);
75
76   /**
77    * @copydoc Dali::Toollkit::TextField::GetInputMethodContext()
78    */
79   InputMethodContext GetInputMethodContext();
80
81   /**
82    * Connects a callback function with the object's signals.
83    * @param[in] object The object providing the signal.
84    * @param[in] tracker Used to disconnect the signal.
85    * @param[in] signalName The signal to connect to.
86    * @param[in] functor A newly allocated FunctorDelegate.
87    * @return True if the signal was connected.
88    * @post If a signal was connected, ownership of functor was passed to CallbackBase. Otherwise the caller is responsible for deleting the unused functor.
89    */
90   static bool DoConnectSignal(BaseObject* object, ConnectionTrackerInterface* tracker, const std::string& signalName, FunctorDelegate* functor);
91
92   /**
93    * @copydoc TextField::TextChangedSignal()
94    */
95   Toolkit::TextField::TextChangedSignalType& TextChangedSignal();
96
97   /**
98    * @copydoc TextField::MaxLengthReachedSignal()
99    */
100   Toolkit::TextField::MaxLengthReachedSignalType& MaxLengthReachedSignal();
101
102   /**
103    * @copydoc TextField::TextChangedSignal()
104    */
105   Toolkit::TextField::InputStyleChangedSignalType& InputStyleChangedSignal();
106
107   /**
108    * @copydoc TextField::AnchorClickedSignal()
109    */
110   DevelTextField::AnchorClickedSignalType& AnchorClickedSignal();
111
112   Text::ControllerPtr getController();
113
114 private: // From Control
115   /**
116    * @copydoc Control::OnInitialize()
117    */
118   void OnInitialize() override;
119
120   /**
121    * @copydoc Control::OnStyleChange()
122    */
123   void OnStyleChange(Toolkit::StyleManager styleManager, StyleChange::Type change) override;
124
125   /**
126    * @copydoc Control::GetNaturalSize()
127    */
128   Vector3 GetNaturalSize() override;
129
130   /**
131    * @copydoc Control::GetHeightForWidth()
132    */
133   float GetHeightForWidth(float width) override;
134
135   /**
136    * @copydoc Control::OnInitialize()
137    */
138   void OnRelayout(const Vector2& size, RelayoutContainer& container) override;
139
140   /**
141    * @copydoc Control::OnKeyInputFocusGained()
142    */
143   void OnKeyInputFocusGained() override;
144
145   /**
146    * @copydoc Control::OnKeyInputFocusLost()
147    */
148   void OnKeyInputFocusLost() override;
149
150   /**
151    * @copydoc Control::OnAccessibilityActivated()
152    */
153   bool OnAccessibilityActivated() override;
154
155   /**
156    * @copydoc Control::OnTap()
157    */
158   void OnTap(const TapGesture& tap) override;
159
160   /**
161    * @copydoc Control::OnPan()
162    */
163   void OnPan(const PanGesture& gesture) override;
164
165   /**
166    * @copydoc Control::OnLongPress()
167    */
168   void OnLongPress(const LongPressGesture& gesture) override;
169
170   /**
171    * @copydoc Control::OnSceneConnection()
172    */
173   void OnSceneConnection(int depth) override;
174
175   /**
176    * @copydoc Dali::CustomActorImpl::OnKeyEvent(const KeyEvent&)
177    */
178   bool OnKeyEvent(const KeyEvent& event) override;
179
180   // From ControlInterface
181
182   /**
183    * @copydoc Text::ControlInterface::RequestTextRelayout()
184    */
185   void RequestTextRelayout() override;
186
187   // From EditableControlInterface
188
189   /**
190    * @copydoc Text::EditableControlInterface::TextChanged()
191    */
192   void TextInserted(unsigned int position, unsigned int length, const std::string& content) override;
193
194   /**
195    * @copydoc Text::EditableControlInterface::TextDeleted()
196    */
197   void TextDeleted(unsigned int position, unsigned int length, const std::string& content) override;
198
199   /**
200    * @copydoc Text::EditableControlInterface::CaretMoved()
201    */
202   void CaretMoved(unsigned int position) override;
203
204   /**
205    * @copydoc Text::EditableControlInterface::TextChanged()
206    */
207   void TextChanged(bool immediate) override;
208
209   /**
210    * @copydoc Text::EditableControlInterface::MaxLengthReached()
211    */
212   void MaxLengthReached() override;
213
214   /**
215    * @copydoc Text::EditableControlInterface::InputStyleChanged()
216    */
217   void InputStyleChanged(Text::InputStyle::Mask inputStyleMask) override;
218
219   /**
220    * @copydoc Text::EditableControlInterface::AddDecoration()
221    */
222   void AddDecoration(Actor& actor, bool needsClipping) override;
223
224   // From SelectableControlInterface
225 public:
226   /**
227    * @copydoc Text::SelectableControlInterface::SetTextSelectionRange()
228    */
229   void SetTextSelectionRange(const uint32_t* start, const uint32_t* end) override;
230
231   /**
232    * @copydoc Text::SelectableControlInterface::GetTextSelectionRange()
233    */
234   Uint32Pair GetTextSelectionRange() const override;
235
236   /**
237    * @copydoc Text::SelectableControlInterface::SelectWholeText()
238    */
239   void SelectWholeText() override;
240
241   /**
242    * @copydoc Text::SelectableControlInterface::SelectNone()
243    */
244   void SelectNone() override;
245
246   /**
247    * @copydoc Text::SelectableControlInterface::GetSelectedText()
248    */
249   string GetSelectedText() const override;
250
251   /**
252    * @copydoc Text::EditableControlInterface::IsEditable()
253    */
254   bool IsEditable() const override;
255
256   /**
257    * @copydoc Text::EditableControlInterface::SetEditable()
258    */
259   void SetEditable(bool editable) override;
260
261   // From AnchorControlInterface
262
263   /**
264    * @copydoc Text::AnchorControlInterface::AnchorClicked()
265    */
266   void AnchorClicked(const std::string& href) override;
267
268 private: // Implementation
269   /**
270    * @copydoc Dali::Toolkit::Text::Controller::(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent)
271    */
272   InputMethodContext::CallbackData OnInputMethodContextEvent(InputMethodContext& inputMethodContext, const InputMethodContext::EventData& inputMethodContextEvent);
273
274   /**
275    * @brief Callback when Clipboard signals an item should be pasted
276    * @param[in] clipboard handle to Clipboard Event Notifier
277    */
278   void OnClipboardTextSelected(ClipboardEventNotifier& clipboard);
279
280   /**
281    * @brief Get a Property Map for the image used for the required Handle Image
282    * @param[out] value the returned image property
283    * @param[in] handleType the type of handle
284    * @param[in] handleImageType the type of image for the given handleType
285    */
286   void GetHandleImagePropertyValue(Property::Value& value, Text::HandleType handleType, Text::HandleImageType handleImageType);
287
288   /**
289    * @brief Enable or disable clipping.
290    */
291   void EnableClipping();
292
293   /**
294    * @brief Callback when keyboard is shown/hidden.
295    *
296    * @param[in] keyboardShown True if keyboard is shown.
297    */
298   void KeyboardStatusChanged(bool keyboardShown);
299
300   /**
301    * @brief Callback when TextField is touched
302    *
303    * @param[in] actor TextField touched
304    * @param[in] touch Touch information
305    */
306   bool OnTouched(Actor actor, const TouchEvent& touch);
307
308   /**
309    * @brief Callbacks called on idle.
310    *
311    * If there are notifications of change of input style on the queue, Toolkit::TextField::InputStyleChangedSignal() are emitted.
312    */
313   void OnIdleSignal();
314
315   /**
316    * @brief Emits TextChanged signal.
317    */
318   void EmitTextChangedSignal();
319
320   /**
321    * Construct a new TextField.
322    */
323   TextField();
324
325   /**
326    * A reference counted object may only be deleted by calling Unreference()
327    */
328   virtual ~TextField();
329
330   // Undefined copy constructor and assignment operators
331   TextField(const TextField&);
332   TextField& operator=(const TextField& rhs);
333
334   /**
335    * @brief Resize actor to the given size.
336    *
337    * @param[in] actor The actor to be resized.
338    * @param[in] size Size to change.
339    */
340   void ResizeActor(Actor& actor, const Vector2& size);
341
342   /**
343    * @brief Render view, create and attach actor(s) to this Text Field.
344    */
345   void RenderText(Text::Controller::UpdateTextType updateTextType);
346
347   // Connection needed to re-render text, when a Text Field returns to the scene.
348   void OnSceneConnect(Dali::Actor actor);
349
350 public: // For UTC only
351   Text::ControllerPtr GetTextController()
352   {
353     return mController;
354   }
355
356 private: // Data
357   // Signals
358   Toolkit::TextField::TextChangedSignalType        mTextChangedSignal;
359   Toolkit::TextField::MaxLengthReachedSignalType   mMaxLengthReachedSignal;
360   Toolkit::TextField::InputStyleChangedSignalType  mInputStyleChangedSignal;
361   Toolkit::DevelTextField::AnchorClickedSignalType mAnchorClickedSignal;
362
363   InputMethodContext       mInputMethodContext;
364   Text::ControllerPtr      mController;
365   Text::RendererPtr        mRenderer;
366   Text::DecoratorPtr       mDecorator;
367   Toolkit::Control         mStencil;                  ///< For EXCEED_POLICY_CLIP
368   std::vector<Actor>       mClippingDecorationActors; ///< Decoration actors which need clipping.
369   Dali::InputMethodOptions mInputMethodOptions;
370
371   Actor         mRenderableActor;
372   Actor         mActiveLayer;
373   Actor         mBackgroundActor;
374   CallbackBase* mIdleCallback;
375
376   float mAlignmentOffset;
377   int   mRenderingBackend;
378   int   mExceedPolicy;
379   bool  mHasBeenStaged : 1;
380   bool  mTextChanged : 1; ///< If true, emits TextChangedSignal in next OnRelayout().
381
382 protected:
383   struct AccessibleImpl : public DevelControl::AccessibleImpl,
384                           public virtual Dali::Accessibility::Text,
385                           public virtual Dali::Accessibility::EditableText
386   {
387     using DevelControl::AccessibleImpl::AccessibleImpl;
388
389     std::string           GetName() override;
390     std::string           GetText(size_t startOffset, size_t endOffset) override;
391     size_t                GetCharacterCount() override;
392     size_t                GetCaretOffset() override;
393     bool                  SetCaretOffset(size_t offset) override;
394     Accessibility::Range  GetTextAtOffset(size_t offset, Accessibility::TextBoundary boundary) override;
395     Accessibility::Range  GetSelection(size_t selectionNum) override;
396     bool                  RemoveSelection(size_t selectionNum) override;
397     bool                  SetSelection(size_t selectionNum, size_t startOffset, size_t endOffset) override;
398     bool                  CopyText(size_t startPosition, size_t endPosition) override;
399     bool                  CutText(size_t startPosition, size_t endPosition) override;
400     Accessibility::States CalculateStates() override;
401   };
402 };
403
404 } // namespace Internal
405
406 // Helpers for public-api forwarding methods
407
408 inline Toolkit::Internal::TextField& GetImpl(Toolkit::TextField& textField)
409 {
410   DALI_ASSERT_ALWAYS(textField);
411
412   Dali::RefObject& handle = textField.GetImplementation();
413
414   return static_cast<Toolkit::Internal::TextField&>(handle);
415 }
416
417 inline const Toolkit::Internal::TextField& GetImpl(const Toolkit::TextField& textField)
418 {
419   DALI_ASSERT_ALWAYS(textField);
420
421   const Dali::RefObject& handle = textField.GetImplementation();
422
423   return static_cast<const Toolkit::Internal::TextField&>(handle);
424 }
425
426 } // namespace Toolkit
427
428 } // namespace Dali
429
430 #endif // DALI_TOOLKIT_INTERNAL_TEXT_FIELD_H