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         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  43         private delegate void TextChangedCallbackDelegate(IntPtr textEditor);
  44
  45         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  46         private delegate void ScrollStateChangedCallbackDelegate(IntPtr textEditor, ScrollState state);
  47
  48         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  49         private delegate void MaxLengthReachedCallbackDelegate(IntPtr textEditor);
  50
  51         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
  52         private delegate void AnchorClickedCallbackDelegate(IntPtr textEditor, IntPtr href, uint hrefLength);
  53
  54         /// <summary>
  55         /// An event for the TextChanged signal which can be used to subscribe or unsubscribe the event handler
  56         /// provided by the user. The TextChanged signal is emitted when the text changes.<br />
  57         /// </summary>
  58         /// <since_tizen> 3 </since_tizen>
  59         public event EventHandler<TextChangedEventArgs> TextChanged
  60         {
  61             add
  62             {
  63                 if (textEditorTextChangedEventHandler == null)
  64                 {
  65                     textEditorTextChangedCallbackDelegate = (OnTextChanged);
  66                     TextChangedSignal().Connect(textEditorTextChangedCallbackDelegate);
  67                 }
  68                 textEditorTextChangedEventHandler += value;
  69             }
  70             remove
  71             {
  72                 textEditorTextChangedEventHandler -= value;
  73                 if (textEditorTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
  74                 {
  75                     TextChangedSignal().Disconnect(textEditorTextChangedCallbackDelegate);
  76                 }
  77             }
  78         }
  79
  80         /// <summary>
  81         /// Event for the ScrollStateChanged signal which can be used to subscribe or unsubscribe the event handler
  82         /// provided by the user. The ScrollStateChanged signal is emitted when the scroll state changes.<br />
  83         /// </summary>
  84         /// <since_tizen> 3 </since_tizen>
  85         public event EventHandler<ScrollStateChangedEventArgs> ScrollStateChanged
  86         {
  87             add
  88             {
  89                 if (textEditorScrollStateChangedEventHandler == null)
  90                 {
  91                     textEditorScrollStateChangedCallbackDelegate = OnScrollStateChanged;
  92                     ScrollStateChangedSignal(this).Connect(textEditorScrollStateChangedCallbackDelegate);
  93                 }
  94                 textEditorScrollStateChangedEventHandler += value;
  95             }
  96             remove
  97             {
  98                 textEditorScrollStateChangedEventHandler -= value;
  99                 if (textEditorScrollStateChangedEventHandler == null && ScrollStateChangedSignal(this).Empty() == false)
 100                 {
 101                     ScrollStateChangedSignal(this).Disconnect(textEditorScrollStateChangedCallbackDelegate);
 102                 }
 103             }
 104         }
 105
 106         /// <summary>
 107         /// The MaxLengthReached event.
 108         /// </summary>
 109         /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 110         [EditorBrowsable(EditorBrowsableState.Never)]
 111         public event EventHandler<MaxLengthReachedEventArgs> MaxLengthReached
 112         {
 113             add
 114             {
 115                 if (textEditorMaxLengthReachedEventHandler == null)
 116                 {
 117                     textEditorMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
 118                     MaxLengthReachedSignal().Connect(textEditorMaxLengthReachedCallbackDelegate);
 119                 }
 120                 textEditorMaxLengthReachedEventHandler += value;
 121             }
 122             remove
 123             {
 124                 if (textEditorMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
 125                 {
 126                     this.MaxLengthReachedSignal().Disconnect(textEditorMaxLengthReachedCallbackDelegate);
 127                 }
 128                 textEditorMaxLengthReachedEventHandler -= value;
 129             }
 130         }
 131
 132         /// <summary>
 133         /// The AnchorClicked signal is emitted when the anchor is clicked.
 134         /// </summary>
 135         /// <since_tizen> 9 </since_tizen>
 136         public event EventHandler<AnchorClickedEventArgs> AnchorClicked
 137         {
 138             add
 139             {
 140                 if (textEditorAnchorClickedEventHandler == null)
 141                 {
 142                     textEditorAnchorClickedCallbackDelegate = (OnAnchorClicked);
 143                     AnchorClickedSignal().Connect(textEditorAnchorClickedCallbackDelegate);
 144                 }
 145                 textEditorAnchorClickedEventHandler += value;
 146             }
 147             remove
 148             {
 149                 textEditorAnchorClickedEventHandler -= value;
 150                 if (textEditorAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
 151                 {
 152                     AnchorClickedSignal().Disconnect(textEditorAnchorClickedCallbackDelegate);
 153                 }
 154             }
 155         }
 156
 157         internal TextEditorSignal TextChangedSignal()
 158         {
 159             TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.TextChangedSignal(SwigCPtr), false);
 160             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 161             return ret;
 162         }
 163
 164         internal ScrollStateChangedSignal ScrollStateChangedSignal(TextEditor textEditor)
 165         {
 166             ScrollStateChangedSignal ret = new ScrollStateChangedSignal(Interop.TextEditor.ScrollStateChangedSignal(TextEditor.getCPtr(textEditor)), false);
 167             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 168             return ret;
 169         }
 170
 171         internal TextEditorSignal MaxLengthReachedSignal()
 172         {
 173             TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.MaxLengthReachedSignal(SwigCPtr), false);
 174             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 175             return ret;
 176         }
 177
 178         internal TextEditorSignal AnchorClickedSignal()
 179         {
 180             TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.AnchorClickedSignal(SwigCPtr), false);
 181             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 182             return ret;
 183         }
 184
 185         private void OnTextChanged(IntPtr textEditor)
 186         {
 187             if (textEditorTextChangedEventHandler != null)
 188             {
 189                 TextChangedEventArgs e = new TextChangedEventArgs();
 190
 191                 // Populate all members of "e" (TextChangedEventArgs) with real data
 192                 e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
 193                 //here we send all data to user event handlers
 194                 textEditorTextChangedEventHandler(this, e);
 195             }
 196         }
 197
 198         private void OnScrollStateChanged(IntPtr textEditor, ScrollState state)
 199         {
 200             if (textEditorScrollStateChangedEventHandler != null)
 201             {
 202                 ScrollStateChangedEventArgs e = new ScrollStateChangedEventArgs();
 203
 204                 if (textEditor != global::System.IntPtr.Zero)
 205                 {
 206                     // Populate all members of "e" (ScrollStateChangedEventArgs) with real data
 207                     e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
 208                     e.ScrollState = state;
 209                 }
 210                 //here we send all data to user event handlers
 211                 textEditorScrollStateChangedEventHandler(this, e);
 212             }
 213         }
 214
 215         private void OnMaxLengthReached(IntPtr textEditor)
 216         {
 217             if (textEditorMaxLengthReachedEventHandler != null)
 218             {
 219                 MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
 220
 221                 // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
 222                 e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
 223                 //here we send all data to user event handlers
 224                 textEditorMaxLengthReachedEventHandler(this, e);
 225             }
 226         }
 227
 228         private void OnAnchorClicked(IntPtr textEditor, IntPtr href, uint hrefLength)
 229         {
 230             // Note: hrefLength is useful for get the length of a const char* (href) in dali-toolkit.
 231             // But NUI can get the length of string (href), so hrefLength is not necessary in NUI.
 232             AnchorClickedEventArgs e = new AnchorClickedEventArgs();
 233
 234             // Populate all members of "e" (AnchorClickedEventArgs) with real data
 235             e.Href = Marshal.PtrToStringAnsi(href);
 236             //here we send all data to user event handlers
 237             textEditorAnchorClickedEventHandler?.Invoke(this, e);
 238         }
 239
 240         /// <summary>
 241         /// Event arguments that passed via the TextChanged signal.
 242         /// </summary>
 243         /// <since_tizen> 3 </since_tizen>
 244         public class TextChangedEventArgs : EventArgs
 245         {
 246             private TextEditor textEditor;
 247
 248             /// <summary>
 249             /// TextEditor - is the texteditor control which has the text contents changed.
 250             /// </summary>
 251             /// <since_tizen> 3 </since_tizen>
 252             public TextEditor TextEditor
 253             {
 254                 get
 255                 {
 256                     return textEditor;
 257                 }
 258                 set
 259                 {
 260                     textEditor = value;
 261                 }
 262             }
 263         }
 264
 265         /// <summary>
 266         /// Event arguments that passed via the ScrollStateChanged signal.
 267         /// </summary>
 268         /// <since_tizen> 3 </since_tizen>
 269         public class ScrollStateChangedEventArgs : EventArgs
 270         {
 271             private TextEditor textEditor;
 272             private ScrollState scrollState;
 273
 274             /// <summary>
 275             /// TextEditor - is the texteditor control which has the scroll state changed.
 276             /// </summary>
 277             /// <since_tizen> 3 </since_tizen>
 278             public TextEditor TextEditor
 279             {
 280                 get
 281                 {
 282                     return textEditor;
 283                 }
 284                 set
 285                 {
 286                     textEditor = value;
 287                 }
 288             }
 289
 290             /// <summary>
 291             /// ScrollState - is the texteditor control scroll state.
 292             /// </summary>
 293             /// <since_tizen> 3 </since_tizen>
 294             public ScrollState ScrollState
 295             {
 296                 get
 297                 {
 298                     return scrollState;
 299                 }
 300                 set
 301                 {
 302                     scrollState = value;
 303                 }
 304             }
 305         }
 306
 307         /// <summary>
 308         /// The MaxLengthReached event arguments.
 309         /// </summary>
 310         /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 311         [EditorBrowsable(EditorBrowsableState.Never)]
 312         public class MaxLengthReachedEventArgs : EventArgs
 313         {
 314             private TextEditor textEditor;
 315
 316             /// <summary>
 317             /// TextEditor.
 318             /// </summary>
 319             /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 320             [EditorBrowsable(EditorBrowsableState.Never)]
 321             public TextEditor TextEditor
 322             {
 323                 get
 324                 {
 325                     return textEditor;
 326                 }
 327                 set
 328                 {
 329                     textEditor = value;
 330                 }
 331             }
 332         }
 333     }
 334 }