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