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