src/Tizen.NUI/src/public/BaseComponents/TextEditorEvent.cs

   1 /*
   2  * Copyright(c) 2019 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.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.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.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             TextChangedEventArgs e = new TextChangedEventArgs();
 150
 151             // Populate all members of "e" (TextChangedEventArgs) with real data
 152             e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
 153
 154             if (_textEditorTextChangedEventHandler != null)
 155             {
 156                 //here we send all data to user event handlers
 157                 _textEditorTextChangedEventHandler(this, e);
 158             }
 159         }
 160
 161         private void OnScrollStateChanged(IntPtr textEditor, ScrollState state)
 162         {
 163             ScrollStateChangedEventArgs e = new ScrollStateChangedEventArgs();
 164
 165             if (textEditor != global::System.IntPtr.Zero)
 166             {
 167                 // Populate all members of "e" (ScrollStateChangedEventArgs) with real data
 168                 e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
 169                 e.ScrollState = state;
 170             }
 171
 172             if (_textEditorScrollStateChangedEventHandler != null)
 173             {
 174                 //here we send all data to user event handlers
 175                 _textEditorScrollStateChangedEventHandler(this, e);
 176             }
 177         }
 178
 179         private void OnMaxLengthReached(IntPtr textEditor)
 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
 186             if (_textEditorMaxLengthReachedEventHandler != null)
 187             {
 188                 //here we send all data to user event handlers
 189                 _textEditorMaxLengthReachedEventHandler(this, e);
 190             }
 191         }
 192
 193         /// <summary>
 194         /// Event arguments that passed via the TextChanged signal.
 195         /// </summary>
 196         /// <since_tizen> 3 </since_tizen>
 197         public class TextChangedEventArgs : EventArgs
 198         {
 199             private TextEditor _textEditor;
 200
 201             /// <summary>
 202             /// TextEditor - is the texteditor control which has the text contents changed.
 203             /// </summary>
 204             /// <since_tizen> 3 </since_tizen>
 205             public TextEditor TextEditor
 206             {
 207                 get
 208                 {
 209                     return _textEditor;
 210                 }
 211                 set
 212                 {
 213                     _textEditor = value;
 214                 }
 215             }
 216         }
 217
 218         /// <summary>
 219         /// Event arguments that passed via the ScrollStateChanged signal.
 220         /// </summary>
 221         /// <since_tizen> 3 </since_tizen>
 222         public class ScrollStateChangedEventArgs : EventArgs
 223         {
 224             private TextEditor _textEditor;
 225             private ScrollState _scrollState;
 226
 227             /// <summary>
 228             /// TextEditor - is the texteditor control which has the scroll state changed.
 229             /// </summary>
 230             /// <since_tizen> 3 </since_tizen>
 231             public TextEditor TextEditor
 232             {
 233                 get
 234                 {
 235                     return _textEditor;
 236                 }
 237                 set
 238                 {
 239                     _textEditor = value;
 240                 }
 241             }
 242
 243             /// <summary>
 244             /// ScrollState - is the texteditor control scroll state.
 245             /// </summary>
 246             /// <since_tizen> 3 </since_tizen>
 247             public ScrollState ScrollState
 248             {
 249                 get
 250                 {
 251                     return _scrollState;
 252                 }
 253                 set
 254                 {
 255                     _scrollState = value;
 256                 }
 257             }
 258         }
 259
 260         /// <summary>
 261         /// The MaxLengthReached event arguments.
 262         /// </summary>
 263         /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 264         [EditorBrowsable(EditorBrowsableState.Never)]
 265         public class MaxLengthReachedEventArgs : EventArgs
 266         {
 267             private TextEditor _textEditor;
 268
 269             /// <summary>
 270             /// TextEditor.
 271             /// </summary>
 272             /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 273             [EditorBrowsable(EditorBrowsableState.Never)]
 274             public TextEditor TextEditor
 275             {
 276                 get
 277                 {
 278                     return _textEditor;
 279                 }
 280                 set
 281                 {
 282                     _textEditor = value;
 283                 }
 284             }
 285         }
 286     }
 287 }