src/Tizen.NUI/src/public/BaseComponents/TextFieldEvent.cs

   1 /*
   2  * Copyright(c) 2021 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 using System;
  19 using System.ComponentModel;
  20 using System.Runtime.InteropServices;
  21
  22 namespace Tizen.NUI.BaseComponents
  23 {
  24     /// <summary>
  25     /// A control which provides a single line editable text field.
  26     /// </summary>
  27     /// <since_tizen> 3 </since_tizen>
  28     public partial class TextField
  29     {
  30         private EventHandler<TextChangedEventArgs> textFieldTextChangedEventHandler;
  31         private TextChangedCallbackDelegate textFieldTextChangedCallbackDelegate;
  32         private EventHandler textFieldCursorPositionChangedEventHandler;
  33         private CursorPositionChangedCallbackDelegate textFieldCursorPositionChangedCallbackDelegate;
  34         private EventHandler<MaxLengthReachedEventArgs> textFieldMaxLengthReachedEventHandler;
  35         private MaxLengthReachedCallbackDelegate textFieldMaxLengthReachedCallbackDelegate;
  36         private EventHandler<AnchorClickedEventArgs> textFieldAnchorClickedEventHandler;
  37         private AnchorClickedCallbackDelegate textFieldAnchorClickedCallbackDelegate;
  38
  39         private EventHandler textFieldSelectionChangedEventHandler;
  40         private SelectionChangedCallbackDelegate textFieldSelectionChangedCallbackDelegate;
  41
  42         private EventHandler<InputFilteredEventArgs> textFieldInputFilteredEventHandler;
  43         private InputFilteredCallbackDelegate textFieldInputFilteredCallbackDelegate;
  44         private EventHandler textFieldSelectionClearedEventHandler;
  45         private SelectionClearedCallbackDelegate textFieldSelectionClearedCallbackDelegate;
  46
  47         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  48         private delegate void TextChangedCallbackDelegate(IntPtr textField);
  49
  50         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  51         private delegate void CursorPositionChangedCallbackDelegate(IntPtr textField, uint oldPosition);
  52
  53         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  54         private delegate void MaxLengthReachedCallbackDelegate(IntPtr textField);
  55
  56         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  57         private delegate void AnchorClickedCallbackDelegate(IntPtr textField, IntPtr href, uint hrefLength);
  58
  59         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  60         private delegate void SelectionChangedCallbackDelegate(IntPtr textField, uint oldStart, uint oldEnd);
  61
  62         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  63         private delegate void InputFilteredCallbackDelegate(IntPtr textField, InputFilterType type);
  64
  65         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  66         private delegate void SelectionClearedCallbackDelegate(IntPtr textField);
  67
  68         /// <summary>
  69         /// The TextChanged event.
  70         /// </summary>
  71         /// <since_tizen> 3 </since_tizen>
  72         public event EventHandler<TextChangedEventArgs> TextChanged
  73         {
  74             add
  75             {
  76                 if (textFieldTextChangedEventHandler == null)
  77                 {
  78                     textFieldTextChangedCallbackDelegate = (OnTextChanged);
  79                     TextChangedSignal().Connect(textFieldTextChangedCallbackDelegate);
  80                 }
  81                 textFieldTextChangedEventHandler += value;
  82             }
  83             remove
  84             {
  85                 textFieldTextChangedEventHandler -= value;
  86                 if (textFieldTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
  87                 {
  88                     TextChangedSignal().Disconnect(textFieldTextChangedCallbackDelegate);
  89                 }
  90             }
  91         }
  92
  93         /// <summary>
  94         /// The CursorPositionChanged event is emitted whenever the primary cursor position changed.
  95         /// </summary>
  96         /// <since_tizen> 9 </since_tizen>
  97         public event EventHandler CursorPositionChanged
  98         {
  99             add
 100             {
 101                 if (textFieldCursorPositionChangedEventHandler == null)
 102                 {
 103                     textFieldCursorPositionChangedCallbackDelegate = (OnCursorPositionChanged);
 104                     CursorPositionChangedSignal().Connect(textFieldCursorPositionChangedCallbackDelegate);
 105                 }
 106                 textFieldCursorPositionChangedEventHandler += value;
 107             }
 108             remove
 109             {
 110                 if (textFieldCursorPositionChangedEventHandler == null && CursorPositionChangedSignal().Empty() == false)
 111                 {
 112                     this.CursorPositionChangedSignal().Disconnect(textFieldCursorPositionChangedCallbackDelegate);
 113                 }
 114                 textFieldCursorPositionChangedEventHandler -= value;
 115             }
 116         }
 117
 118         /// <summary>
 119         /// The MaxLengthReached event.
 120         /// </summary>
 121         /// <since_tizen> 3 </since_tizen>
 122         public event EventHandler<MaxLengthReachedEventArgs> MaxLengthReached
 123         {
 124             add
 125             {
 126                 if (textFieldMaxLengthReachedEventHandler == null)
 127                 {
 128                     textFieldMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
 129                     MaxLengthReachedSignal().Connect(textFieldMaxLengthReachedCallbackDelegate);
 130                 }
 131                 textFieldMaxLengthReachedEventHandler += value;
 132             }
 133             remove
 134             {
 135                 if (textFieldMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
 136                 {
 137                     this.MaxLengthReachedSignal().Disconnect(textFieldMaxLengthReachedCallbackDelegate);
 138                 }
 139                 textFieldMaxLengthReachedEventHandler -= value;
 140             }
 141         }
 142
 143         /// <summary>
 144         /// The SelectionCleared signal is emitted when selection is cleared.
 145         /// </summary>
 146         /// This will be public opened after ACR done. Before ACR, need to be hidden as inhouse API.
 147         [EditorBrowsable(EditorBrowsableState.Never)]
 148         public event EventHandler SelectionCleared
 149         {
 150             add
 151             {
 152                 if (textFieldSelectionClearedEventHandler == null)
 153                 {
 154                     textFieldSelectionClearedCallbackDelegate = (OnSelectionCleared);
 155                     SelectionClearedSignal().Connect(textFieldSelectionClearedCallbackDelegate);
 156                 }
 157                 textFieldSelectionClearedEventHandler += value;
 158             }
 159             remove
 160             {
 161                 if (textFieldSelectionClearedEventHandler == null && SelectionClearedSignal().Empty() == false)
 162                 {
 163                     this.SelectionClearedSignal().Disconnect(textFieldSelectionClearedCallbackDelegate);
 164                 }
 165                 textFieldSelectionClearedEventHandler -= value;
 166             }
 167         }
 168
 169         /// <summary>
 170         /// The AnchorClicked signal is emitted when the anchor is clicked.
 171         /// </summary>
 172         /// <since_tizen> 9 </since_tizen>
 173         public event EventHandler<AnchorClickedEventArgs> AnchorClicked
 174         {
 175             add
 176             {
 177                 if (textFieldAnchorClickedEventHandler == null)
 178                 {
 179                     textFieldAnchorClickedCallbackDelegate = (OnAnchorClicked);
 180                     AnchorClickedSignal().Connect(textFieldAnchorClickedCallbackDelegate);
 181                 }
 182                 textFieldAnchorClickedEventHandler += value;
 183             }
 184             remove
 185             {
 186                 textFieldAnchorClickedEventHandler -= value;
 187                 if (textFieldAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
 188                 {
 189                     AnchorClickedSignal().Disconnect(textFieldAnchorClickedCallbackDelegate);
 190                 }
 191             }
 192         }
 193
 194         /// <summary>
 195         /// The SelectionChanged signal is emitted whenever the selected text changed.
 196         /// </summary>
 197         /// <since_tizen> 9 </since_tizen>
 198         public event EventHandler SelectionChanged
 199         {
 200             add
 201             {
 202                 if (textFieldSelectionChangedEventHandler == null)
 203                 {
 204                     textFieldSelectionChangedCallbackDelegate = (OnSelectionChanged);
 205                     SelectionChangedSignal().Connect(textFieldSelectionChangedCallbackDelegate);
 206                 }
 207                 textFieldSelectionChangedEventHandler += value;
 208             }
 209             remove
 210             {
 211                 if (textFieldSelectionChangedEventHandler == null && SelectionChangedSignal().Empty() == false)
 212                 {
 213                     this.SelectionChangedSignal().Disconnect(textFieldSelectionChangedCallbackDelegate);
 214                 }
 215                 textFieldSelectionChangedEventHandler -= value;
 216             }
 217         }
 218
 219         /// <summary>
 220         /// The InputFiltered signal is emitted when the input is filtered by InputFilter. <br />
 221         /// </summary>
 222         /// <remarks>
 223         /// See <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description. <br />
 224         /// </remarks>
 225         /// <example>
 226         /// The following example demonstrates how to use the InputFiltered event.
 227         /// <code>
 228         /// field.InputFiltered += (s, e) =>
 229         /// {
 230         ///     if (e.Type == InputFilterType.Accept)
 231         ///     {
 232         ///         // If input is filtered by InputFilter of Accept type.
 233         ///     }
 234         ///     else if (e.Type == InputFilterType.Reject)
 235         ///     {
 236         ///         // If input is filtered by InputFilter of Reject type.
 237         ///     }
 238         /// };
 239         /// </code>
 240         /// </example>
 241         [EditorBrowsable(EditorBrowsableState.Never)]
 242         public event EventHandler<InputFilteredEventArgs> InputFiltered
 243         {
 244             add
 245             {
 246                 if (textFieldInputFilteredEventHandler == null)
 247                 {
 248                     textFieldInputFilteredCallbackDelegate = (OnInputFiltered);
 249                     InputFilteredSignal().Connect(textFieldInputFilteredCallbackDelegate);
 250                 }
 251                 textFieldInputFilteredEventHandler += value;
 252             }
 253             remove
 254             {
 255                 textFieldInputFilteredEventHandler -= value;
 256                 if (textFieldInputFilteredEventHandler == null && InputFilteredSignal().Empty() == false)
 257                 {
 258                     InputFilteredSignal().Disconnect(textFieldInputFilteredCallbackDelegate);
 259                 }
 260             }
 261         }
 262
 263         internal TextFieldSignal SelectionClearedSignal()
 264         {
 265             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.SelectionClearedSignal(SwigCPtr), false);
 266             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 267             return ret;
 268         }
 269
 270         internal TextFieldSignal TextChangedSignal()
 271         {
 272             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.TextChangedSignal(SwigCPtr), false);
 273             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 274             return ret;
 275         }
 276
 277         internal TextFieldSignal CursorPositionChangedSignal()
 278         {
 279             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.CursorPositionChangedSignal(SwigCPtr), false);
 280             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 281             return ret;
 282         }
 283
 284         internal TextFieldSignal MaxLengthReachedSignal()
 285         {
 286             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.MaxLengthReachedSignal(SwigCPtr), false);
 287             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 288             return ret;
 289         }
 290
 291         internal TextFieldSignal AnchorClickedSignal()
 292         {
 293             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.AnchorClickedSignal(SwigCPtr), false);
 294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 295             return ret;
 296         }
 297
 298         internal TextFieldSignal SelectionChangedSignal()
 299         {
 300             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.SelectionChangedSignal(SwigCPtr), false);
 301             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 302             return ret;
 303         }
 304
 305         internal TextFieldSignal InputFilteredSignal()
 306         {
 307             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.InputFilteredSignal(SwigCPtr), false);
 308             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 309             return ret;
 310         }
 311
 312         private void OnSelectionCleared(IntPtr textField)
 313         {
 314             //no data to be sent to the user
 315             textFieldSelectionClearedEventHandler?.Invoke(this, EventArgs.Empty);
 316         }
 317
 318         private void OnTextChanged(IntPtr textField)
 319         {
 320             if (textFieldTextChangedEventHandler != null)
 321             {
 322                 TextChangedEventArgs e = new TextChangedEventArgs();
 323
 324                 // Populate all members of "e" (TextChangedEventArgs) with real data
 325                 e.TextField = Registry.GetManagedBaseHandleFromNativePtr(textField) as TextField;
 326                 //here we send all data to user event handlers
 327                 textFieldTextChangedEventHandler(this, e);
 328             }
 329         }
 330
 331         private void OnCursorPositionChanged(IntPtr textField, uint oldPosition)
 332         {
 333             // no data to be sent to the user, as in NUI there is no event provide old values.
 334             textFieldCursorPositionChangedEventHandler?.Invoke(this, EventArgs.Empty);
 335         }
 336
 337         private void OnMaxLengthReached(IntPtr textField)
 338         {
 339             if (textFieldMaxLengthReachedEventHandler != null)
 340             {
 341                 MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
 342
 343                 // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
 344                 e.TextField = Registry.GetManagedBaseHandleFromNativePtr(textField) as TextField;
 345                 //here we send all data to user event handlers
 346                 textFieldMaxLengthReachedEventHandler(this, e);
 347             }
 348         }
 349
 350         private void OnAnchorClicked(IntPtr textField, IntPtr href, uint hrefLength)
 351         {
 352             // Note: hrefLength is useful for get the length of a const char* (href) in dali-toolkit.
 353             // But NUI can get the length of string (href), so hrefLength is not necessary in NUI.
 354             AnchorClickedEventArgs e = new AnchorClickedEventArgs();
 355
 356             // Populate all members of "e" (AnchorClickedEventArgs) with real data
 357             e.Href = Marshal.PtrToStringAnsi(href);
 358             //here we send all data to user event handlers
 359             textFieldAnchorClickedEventHandler?.Invoke(this, e);
 360         }
 361
 362         private void OnSelectionChanged(IntPtr textField, uint oldStart, uint oldEnd)
 363         {
 364             // no data to be sent to the user, as in NUI there is no event provide old values.
 365             textFieldSelectionChangedEventHandler?.Invoke(this, EventArgs.Empty);
 366         }
 367
 368         private void OnInputFiltered(IntPtr textField, InputFilterType type)
 369         {
 370             InputFilteredEventArgs e = new InputFilteredEventArgs();
 371
 372             // Populate all members of "e" (InputFilteredEventArgs) with real data
 373             e.Type = type;
 374             //here we send all data to user event handlers
 375             textFieldInputFilteredEventHandler?.Invoke(this, e);
 376         }
 377
 378         /// <summary>
 379         /// The TextChanged event arguments.
 380         /// </summary>
 381         /// <since_tizen> 3 </since_tizen>
 382         public class TextChangedEventArgs : EventArgs
 383         {
 384             private TextField textField;
 385
 386             /// <summary>
 387             /// TextField.
 388             /// </summary>
 389             /// <since_tizen> 3 </since_tizen>
 390             public TextField TextField
 391             {
 392                 get
 393                 {
 394                     return textField;
 395                 }
 396                 set
 397                 {
 398                     textField = value;
 399                 }
 400             }
 401         }
 402
 403         /// <summary>
 404         /// The MaxLengthReached event arguments.
 405         /// </summary>
 406         /// <since_tizen> 3 </since_tizen>
 407         public class MaxLengthReachedEventArgs : EventArgs
 408         {
 409             private TextField textField;
 410
 411             /// <summary>
 412             /// TextField.
 413             /// </summary>
 414             /// <since_tizen> 3 </since_tizen>
 415             public TextField TextField
 416             {
 417                 get
 418                 {
 419                     return textField;
 420                 }
 421                 set
 422                 {
 423                     textField = value;
 424                 }
 425             }
 426         }
 427     }
 428 }