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