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<MaxLengthReachedEventArgs> textFieldMaxLengthReachedEventHandler;
  33         private MaxLengthReachedCallbackDelegate textFieldMaxLengthReachedCallbackDelegate;
  34         private EventHandler<AnchorClickedEventArgs> textFieldAnchorClickedEventHandler;
  35         private AnchorClickedCallbackDelegate textFieldAnchorClickedCallbackDelegate;
  36
  37         private EventHandler<SelectionChangedEventArgs> textFieldSelectionChangedEventHandler;
  38         private SelectionChangedCallbackDelegate textFieldSelectionChangedCallbackDelegate;
  39
  40         private EventHandler<InputFilteredEventArgs> textFieldInputFilteredEventHandler;
  41         private InputFilteredCallbackDelegate textFieldInputFilteredCallbackDelegate;
  42
  43         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  44         private delegate void TextChangedCallbackDelegate(IntPtr textField);
  45
  46         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  47         private delegate void MaxLengthReachedCallbackDelegate(IntPtr textField);
  48
  49         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  50         private delegate void AnchorClickedCallbackDelegate(IntPtr textField, IntPtr href, uint hrefLength);
  51
  52         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  53         private delegate void SelectionChangedCallbackDelegate(IntPtr textField, uint oldStart, uint oldEnd);
  54
  55         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  56         private delegate void InputFilteredCallbackDelegate(IntPtr textField, InputFilterType type);
  57
  58         /// <summary>
  59         /// The TextChanged event.
  60         /// </summary>
  61         /// <since_tizen> 3 </since_tizen>
  62         public event EventHandler<TextChangedEventArgs> TextChanged
  63         {
  64             add
  65             {
  66                 if (textFieldTextChangedEventHandler == null)
  67                 {
  68                     textFieldTextChangedCallbackDelegate = (OnTextChanged);
  69                     TextChangedSignal().Connect(textFieldTextChangedCallbackDelegate);
  70                 }
  71                 textFieldTextChangedEventHandler += value;
  72             }
  73             remove
  74             {
  75                 textFieldTextChangedEventHandler -= value;
  76                 if (textFieldTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
  77                 {
  78                     TextChangedSignal().Disconnect(textFieldTextChangedCallbackDelegate);
  79                 }
  80             }
  81         }
  82
  83         /// <summary>
  84         /// The MaxLengthReached event.
  85         /// </summary>
  86         /// <since_tizen> 3 </since_tizen>
  87         public event EventHandler<MaxLengthReachedEventArgs> MaxLengthReached
  88         {
  89             add
  90             {
  91                 if (textFieldMaxLengthReachedEventHandler == null)
  92                 {
  93                     textFieldMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
  94                     MaxLengthReachedSignal().Connect(textFieldMaxLengthReachedCallbackDelegate);
  95                 }
  96                 textFieldMaxLengthReachedEventHandler += value;
  97             }
  98             remove
  99             {
 100                 if (textFieldMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
 101                 {
 102                     this.MaxLengthReachedSignal().Disconnect(textFieldMaxLengthReachedCallbackDelegate);
 103                 }
 104                 textFieldMaxLengthReachedEventHandler -= value;
 105             }
 106         }
 107
 108         /// <summary>
 109         /// The AnchorClicked signal is emitted when the anchor is clicked.
 110         /// </summary>
 111         /// <since_tizen> 9 </since_tizen>
 112         public event EventHandler<AnchorClickedEventArgs> AnchorClicked
 113         {
 114             add
 115             {
 116                 if (textFieldAnchorClickedEventHandler == null)
 117                 {
 118                     textFieldAnchorClickedCallbackDelegate = (OnAnchorClicked);
 119                     AnchorClickedSignal().Connect(textFieldAnchorClickedCallbackDelegate);
 120                 }
 121                 textFieldAnchorClickedEventHandler += value;
 122             }
 123             remove
 124             {
 125                 textFieldAnchorClickedEventHandler -= value;
 126                 if (textFieldAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
 127                 {
 128                     AnchorClickedSignal().Disconnect(textFieldAnchorClickedCallbackDelegate);
 129                 }
 130             }
 131         }
 132
 133         /// <summary>
 134         /// The SelectionChanged event.
 135         /// </summary>
 136         /// This will be public opened after ACR done. Before ACR, need to be hidden as inhouse API.
 137         [EditorBrowsable(EditorBrowsableState.Never)]
 138         public event EventHandler<SelectionChangedEventArgs> SelectionChanged
 139         {
 140             add
 141             {
 142                 if (textFieldSelectionChangedEventHandler == null)
 143                 {
 144                     textFieldSelectionChangedCallbackDelegate = (OnSelectionChanged);
 145                     SelectionChangedSignal().Connect(textFieldSelectionChangedCallbackDelegate);
 146                 }
 147                 textFieldSelectionChangedEventHandler += value;
 148             }
 149             remove
 150             {
 151                 if (textFieldSelectionChangedEventHandler == null && SelectionChangedSignal().Empty() == false)
 152                 {
 153                     this.SelectionChangedSignal().Disconnect(textFieldSelectionChangedCallbackDelegate);
 154                 }
 155                 textFieldSelectionChangedEventHandler -= value;
 156             }
 157         }
 158
 159         /// <summary>
 160         /// The InputFiltered signal is emitted when the input is filtered by InputFilter. <br />
 161         /// </summary>
 162         /// <remarks>
 163         /// See <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description. <br />
 164         /// </remarks>
 165         /// <example>
 166         /// The following example demonstrates how to use the InputFiltered event.
 167         /// <code>
 168         /// field.InputFiltered += (s, e) =>
 169         /// {
 170         ///     if (e.Type == InputFilterType.Accept)
 171         ///     {
 172         ///         // If input is filtered by InputFilter of Accept type.
 173         ///     }
 174         ///     else if (e.Type == InputFilterType.Reject)
 175         ///     {
 176         ///         // If input is filtered by InputFilter of Reject type.
 177         ///     }
 178         /// };
 179         /// </code>
 180         /// </example>
 181         [EditorBrowsable(EditorBrowsableState.Never)]
 182         public event EventHandler<InputFilteredEventArgs> InputFiltered
 183         {
 184             add
 185             {
 186                 if (textFieldInputFilteredEventHandler == null)
 187                 {
 188                     textFieldInputFilteredCallbackDelegate = (OnInputFiltered);
 189                     InputFilteredSignal().Connect(textFieldInputFilteredCallbackDelegate);
 190                 }
 191                 textFieldInputFilteredEventHandler += value;
 192             }
 193             remove
 194             {
 195                 textFieldInputFilteredEventHandler -= value;
 196                 if (textFieldInputFilteredEventHandler == null && InputFilteredSignal().Empty() == false)
 197                 {
 198                     InputFilteredSignal().Disconnect(textFieldInputFilteredCallbackDelegate);
 199                 }
 200             }
 201         }
 202
 203         internal TextFieldSignal TextChangedSignal()
 204         {
 205             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.TextChangedSignal(SwigCPtr), false);
 206             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 207             return ret;
 208         }
 209
 210         internal TextFieldSignal MaxLengthReachedSignal()
 211         {
 212             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.MaxLengthReachedSignal(SwigCPtr), false);
 213             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 214             return ret;
 215         }
 216
 217         internal TextFieldSignal AnchorClickedSignal()
 218         {
 219             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.AnchorClickedSignal(SwigCPtr), false);
 220             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 221             return ret;
 222         }
 223
 224         internal TextFieldSignal SelectionChangedSignal()
 225         {
 226             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.SelectionChangedSignal(SwigCPtr), false);
 227             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 228             return ret;
 229         }
 230
 231         internal TextFieldSignal InputFilteredSignal()
 232         {
 233             TextFieldSignal ret = new TextFieldSignal(Interop.TextField.InputFilteredSignal(SwigCPtr), false);
 234             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 235             return ret;
 236         }
 237
 238         private void OnTextChanged(IntPtr textField)
 239         {
 240             if (textFieldTextChangedEventHandler != null)
 241             {
 242                 TextChangedEventArgs e = new TextChangedEventArgs();
 243
 244                 // Populate all members of "e" (TextChangedEventArgs) with real data
 245                 e.TextField = Registry.GetManagedBaseHandleFromNativePtr(textField) as TextField;
 246                 //here we send all data to user event handlers
 247                 textFieldTextChangedEventHandler(this, e);
 248             }
 249         }
 250
 251         private void OnMaxLengthReached(IntPtr textField)
 252         {
 253             if (textFieldMaxLengthReachedEventHandler != null)
 254             {
 255                 MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
 256
 257                 // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
 258                 e.TextField = Registry.GetManagedBaseHandleFromNativePtr(textField) as TextField;
 259                 //here we send all data to user event handlers
 260                 textFieldMaxLengthReachedEventHandler(this, e);
 261             }
 262         }
 263
 264         private void OnAnchorClicked(IntPtr textField, IntPtr href, uint hrefLength)
 265         {
 266             // Note: hrefLength is useful for get the length of a const char* (href) in dali-toolkit.
 267             // But NUI can get the length of string (href), so hrefLength is not necessary in NUI.
 268             AnchorClickedEventArgs e = new AnchorClickedEventArgs();
 269
 270             // Populate all members of "e" (AnchorClickedEventArgs) with real data
 271             e.Href = Marshal.PtrToStringAnsi(href);
 272             //here we send all data to user event handlers
 273             textFieldAnchorClickedEventHandler?.Invoke(this, e);
 274         }
 275
 276         private void OnSelectionChanged(IntPtr textField, uint oldStart, uint oldEnd)
 277         {
 278             if (textFieldSelectionChangedEventHandler != null)
 279             {
 280                 SelectionChangedEventArgs e = new SelectionChangedEventArgs();
 281
 282                 // Populate all members of "e" (SelectionChangedEventArgs) with real data
 283                 e.OldSelectionStart = oldStart;
 284                 e.OldSelectionEnd = oldEnd;
 285
 286                 //here we send all data to user event handlers
 287                 textFieldSelectionChangedEventHandler?.Invoke(this, e);
 288             }
 289         }
 290
 291         private void OnInputFiltered(IntPtr textField, InputFilterType type)
 292         {
 293             InputFilteredEventArgs e = new InputFilteredEventArgs();
 294
 295             // Populate all members of "e" (InputFilteredEventArgs) with real data
 296             e.Type = type;
 297             //here we send all data to user event handlers
 298             textFieldInputFilteredEventHandler?.Invoke(this, e);
 299         }
 300
 301         /// <summary>
 302         /// The TextChanged event arguments.
 303         /// </summary>
 304         /// <since_tizen> 3 </since_tizen>
 305         public class TextChangedEventArgs : EventArgs
 306         {
 307             private TextField textField;
 308
 309             /// <summary>
 310             /// TextField.
 311             /// </summary>
 312             /// <since_tizen> 3 </since_tizen>
 313             public TextField TextField
 314             {
 315                 get
 316                 {
 317                     return textField;
 318                 }
 319                 set
 320                 {
 321                     textField = value;
 322                 }
 323             }
 324         }
 325
 326         /// <summary>
 327         /// The MaxLengthReached event arguments.
 328         /// </summary>
 329         /// <since_tizen> 3 </since_tizen>
 330         public class MaxLengthReachedEventArgs : EventArgs
 331         {
 332             private TextField textField;
 333
 334             /// <summary>
 335             /// TextField.
 336             /// </summary>
 337             /// <since_tizen> 3 </since_tizen>
 338             public TextField TextField
 339             {
 340                 get
 341                 {
 342                     return textField;
 343                 }
 344                 set
 345                 {
 346                     textField = value;
 347                 }
 348             }
 349         }
 350     }
 351 }