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