/*
- * Copyright(c) 2019 Samsung Electronics Co., Ltd.
+ * Copyright(c) 2021 Samsung Electronics Co., Ltd.
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
/// <since_tizen> 3 </since_tizen>
public partial class TextEditor
{
- private EventHandler<TextChangedEventArgs> _textEditorTextChangedEventHandler;
- private TextChangedCallbackDelegate _textEditorTextChangedCallbackDelegate;
+ private EventHandler<TextChangedEventArgs> textEditorTextChangedEventHandler;
+ private TextChangedCallbackDelegate textEditorTextChangedCallbackDelegate;
- private EventHandler<ScrollStateChangedEventArgs> _textEditorScrollStateChangedEventHandler;
- private ScrollStateChangedCallbackDelegate _textEditorScrollStateChangedCallbackDelegate;
+ private EventHandler<ScrollStateChangedEventArgs> textEditorScrollStateChangedEventHandler;
+ private ScrollStateChangedCallbackDelegate textEditorScrollStateChangedCallbackDelegate;
- private EventHandler<MaxLengthReachedEventArgs> _textEditorMaxLengthReachedEventHandler;
- private MaxLengthReachedCallbackDelegate _textEditorMaxLengthReachedCallbackDelegate;
+ private EventHandler<CursorPositionChangedEventArgs> textEditorCursorPositionChangedEventHandler;
+ private CursorPositionChangedCallbackDelegate textEditorCursorPositionChangedCallbackDelegate;
+
+ private EventHandler<MaxLengthReachedEventArgs> textEditorMaxLengthReachedEventHandler;
+ private MaxLengthReachedCallbackDelegate textEditorMaxLengthReachedCallbackDelegate;
+
+ private EventHandler<AnchorClickedEventArgs> textEditorAnchorClickedEventHandler;
+ private AnchorClickedCallbackDelegate textEditorAnchorClickedCallbackDelegate;
+
+ private EventHandler<TextSelectionChangedEventArgs> textEditorSelectionChangedEventHandler;
+ private SelectionChangedCallbackDelegate textEditorSelectionChangedCallbackDelegate;
+
+ private EventHandler<InputFilteredEventArgs> textEditorInputFilteredEventHandler;
+ private InputFilteredCallbackDelegate textEditorInputFilteredCallbackDelegate;
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void TextChangedCallbackDelegate(IntPtr textEditor);
private delegate void ScrollStateChangedCallbackDelegate(IntPtr textEditor, ScrollState state);
[UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void CursorPositionChangedCallbackDelegate(IntPtr textEditor, uint oldPosition);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
private delegate void MaxLengthReachedCallbackDelegate(IntPtr textEditor);
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void AnchorClickedCallbackDelegate(IntPtr textEditor, IntPtr href, uint hrefLength);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void SelectionChangedCallbackDelegate(IntPtr textEditor, uint oldStart, uint oldEnd);
+
+ [UnmanagedFunctionPointer(CallingConvention.StdCall)]
+ private delegate void InputFilteredCallbackDelegate(IntPtr textEditor, InputFilterType type);
+
/// <summary>
/// An event for the TextChanged signal which can be used to subscribe or unsubscribe the event handler
/// provided by the user. The TextChanged signal is emitted when the text changes.<br />
{
add
{
- if (_textEditorTextChangedEventHandler == null)
+ if (textEditorTextChangedEventHandler == null)
{
- _textEditorTextChangedCallbackDelegate = (OnTextChanged);
- TextChangedSignal().Connect(_textEditorTextChangedCallbackDelegate);
+ textEditorTextChangedCallbackDelegate = (OnTextChanged);
+ TextChangedSignal().Connect(textEditorTextChangedCallbackDelegate);
}
- _textEditorTextChangedEventHandler += value;
+ textEditorTextChangedEventHandler += value;
}
remove
{
- _textEditorTextChangedEventHandler -= value;
- if (_textEditorTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
+ textEditorTextChangedEventHandler -= value;
+ if (textEditorTextChangedEventHandler == null && TextChangedSignal().Empty() == false)
{
- TextChangedSignal().Disconnect(_textEditorTextChangedCallbackDelegate);
+ TextChangedSignal().Disconnect(textEditorTextChangedCallbackDelegate);
}
}
}
{
add
{
- if (_textEditorScrollStateChangedEventHandler == null)
+ if (textEditorScrollStateChangedEventHandler == null)
{
- _textEditorScrollStateChangedCallbackDelegate = OnScrollStateChanged;
- ScrollStateChangedSignal(this).Connect(_textEditorScrollStateChangedCallbackDelegate);
+ textEditorScrollStateChangedCallbackDelegate = OnScrollStateChanged;
+ ScrollStateChangedSignal(this).Connect(textEditorScrollStateChangedCallbackDelegate);
}
- _textEditorScrollStateChangedEventHandler += value;
+ textEditorScrollStateChangedEventHandler += value;
}
remove
{
- _textEditorScrollStateChangedEventHandler -= value;
- if (_textEditorScrollStateChangedEventHandler == null && ScrollStateChangedSignal(this).Empty() == false)
+ textEditorScrollStateChangedEventHandler -= value;
+ if (textEditorScrollStateChangedEventHandler == null && ScrollStateChangedSignal(this).Empty() == false)
{
- ScrollStateChangedSignal(this).Disconnect(_textEditorScrollStateChangedCallbackDelegate);
+ ScrollStateChangedSignal(this).Disconnect(textEditorScrollStateChangedCallbackDelegate);
}
}
}
/// <summary>
+ /// The CursorPositionChanged event.
+ /// </summary>
+ /// This will be public opened after ACR done. Before ACR, need to be hidden as inhouse API.
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<CursorPositionChangedEventArgs> CursorPositionChanged
+ {
+ add
+ {
+ if (textEditorCursorPositionChangedEventHandler == null)
+ {
+ textEditorCursorPositionChangedCallbackDelegate = (OnCursorPositionChanged);
+ CursorPositionChangedSignal().Connect(textEditorCursorPositionChangedCallbackDelegate);
+ }
+ textEditorCursorPositionChangedEventHandler += value;
+ }
+ remove
+ {
+ if (textEditorCursorPositionChangedEventHandler == null && CursorPositionChangedSignal().Empty() == false)
+ {
+ this.CursorPositionChangedSignal().Disconnect(textEditorCursorPositionChangedCallbackDelegate);
+ }
+ textEditorCursorPositionChangedEventHandler -= value;
+ }
+ }
+
+ /// <summary>
/// The MaxLengthReached event.
/// </summary>
/// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
{
add
{
- if (_textEditorMaxLengthReachedEventHandler == null)
+ if (textEditorMaxLengthReachedEventHandler == null)
+ {
+ textEditorMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
+ MaxLengthReachedSignal().Connect(textEditorMaxLengthReachedCallbackDelegate);
+ }
+ textEditorMaxLengthReachedEventHandler += value;
+ }
+ remove
+ {
+ if (textEditorMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
+ {
+ this.MaxLengthReachedSignal().Disconnect(textEditorMaxLengthReachedCallbackDelegate);
+ }
+ textEditorMaxLengthReachedEventHandler -= value;
+ }
+ }
+
+ /// <summary>
+ /// The AnchorClicked signal is emitted when the anchor is clicked.
+ /// </summary>
+ /// <since_tizen> 9 </since_tizen>
+ public event EventHandler<AnchorClickedEventArgs> AnchorClicked
+ {
+ add
+ {
+ if (textEditorAnchorClickedEventHandler == null)
{
- _textEditorMaxLengthReachedCallbackDelegate = (OnMaxLengthReached);
- MaxLengthReachedSignal().Connect(_textEditorMaxLengthReachedCallbackDelegate);
+ textEditorAnchorClickedCallbackDelegate = (OnAnchorClicked);
+ AnchorClickedSignal().Connect(textEditorAnchorClickedCallbackDelegate);
}
- _textEditorMaxLengthReachedEventHandler += value;
+ textEditorAnchorClickedEventHandler += value;
}
remove
{
- if (_textEditorMaxLengthReachedEventHandler == null && MaxLengthReachedSignal().Empty() == false)
+ textEditorAnchorClickedEventHandler -= value;
+ if (textEditorAnchorClickedEventHandler == null && AnchorClickedSignal().Empty() == false)
{
- this.MaxLengthReachedSignal().Disconnect(_textEditorMaxLengthReachedCallbackDelegate);
+ AnchorClickedSignal().Disconnect(textEditorAnchorClickedCallbackDelegate);
+ }
+ }
+ }
+
+ /// <summary>
+ /// The SelectionChanged event.
+ /// </summary>
+ /// This will be public opened after ACR done. Before ACR, need to be hidden as inhouse API.
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<TextSelectionChangedEventArgs> SelectionChanged
+ {
+ add
+ {
+ if (textEditorSelectionChangedEventHandler == null)
+ {
+ textEditorSelectionChangedCallbackDelegate = (OnSelectionChanged);
+ SelectionChangedSignal().Connect(textEditorSelectionChangedCallbackDelegate);
+ }
+ textEditorSelectionChangedEventHandler += value;
+ }
+ remove
+ {
+ if (textEditorSelectionChangedEventHandler == null && SelectionChangedSignal().Empty() == false)
+ {
+ this.SelectionChangedSignal().Disconnect(textEditorSelectionChangedCallbackDelegate);
+ }
+ textEditorSelectionChangedEventHandler -= value;
+ }
+ }
+
+ /// <summary>
+ /// The InputFiltered signal is emitted when the input is filtered by InputFilter. <br />
+ /// </summary>
+ /// <remarks>
+ /// See <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description. <br />
+ /// </remarks>
+ /// <example>
+ /// The following example demonstrates how to use the InputFiltered event.
+ /// <code>
+ /// editor.InputFiltered += (s, e) =>
+ /// {
+ /// if (e.Type == InputFilterType.Accept)
+ /// {
+ /// // If input is filtered by InputFilter of Accept type.
+ /// }
+ /// else if (e.Type == InputFilterType.Reject)
+ /// {
+ /// // If input is filtered by InputFilter of Reject type.
+ /// }
+ /// };
+ /// </code>
+ /// </example>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public event EventHandler<InputFilteredEventArgs> InputFiltered
+ {
+ add
+ {
+ if (textEditorInputFilteredEventHandler == null)
+ {
+ textEditorInputFilteredCallbackDelegate = (OnInputFiltered);
+ InputFilteredSignal().Connect(textEditorInputFilteredCallbackDelegate);
+ }
+ textEditorInputFilteredEventHandler += value;
+ }
+ remove
+ {
+ textEditorInputFilteredEventHandler -= value;
+ if (textEditorInputFilteredEventHandler == null && InputFilteredSignal().Empty() == false)
+ {
+ InputFilteredSignal().Disconnect(textEditorInputFilteredCallbackDelegate);
}
- _textEditorMaxLengthReachedEventHandler -= value;
}
}
internal TextEditorSignal TextChangedSignal()
{
- TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.TextChangedSignal(swigCPtr), false);
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.TextChangedSignal(SwigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
return ret;
}
+ internal TextEditorSignal CursorPositionChangedSignal()
+ {
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.CursorPositionChangedSignal(SwigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
internal TextEditorSignal MaxLengthReachedSignal()
{
- TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.MaxLengthReachedSignal(swigCPtr), false);
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.MaxLengthReachedSignal(SwigCPtr), false);
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
return ret;
}
- private void OnTextChanged(IntPtr textEditor)
+ internal TextEditorSignal AnchorClickedSignal()
{
- TextChangedEventArgs e = new TextChangedEventArgs();
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.AnchorClickedSignal(SwigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- // Populate all members of "e" (TextChangedEventArgs) with real data
- e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
+ internal TextEditorSignal SelectionChangedSignal()
+ {
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.SelectionChangedSignal(SwigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
+
+ internal TextEditorSignal InputFilteredSignal()
+ {
+ TextEditorSignal ret = new TextEditorSignal(Interop.TextEditor.InputFilteredSignal(SwigCPtr), false);
+ if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
+ return ret;
+ }
- if (_textEditorTextChangedEventHandler != null)
+ private void OnTextChanged(IntPtr textEditor)
+ {
+ if (textEditorTextChangedEventHandler != null)
{
+ TextChangedEventArgs e = new TextChangedEventArgs();
+
+ // Populate all members of "e" (TextChangedEventArgs) with real data
+ e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
//here we send all data to user event handlers
- _textEditorTextChangedEventHandler(this, e);
+ textEditorTextChangedEventHandler(this, e);
}
}
private void OnScrollStateChanged(IntPtr textEditor, ScrollState state)
{
- ScrollStateChangedEventArgs e = new ScrollStateChangedEventArgs();
-
- if (textEditor != global::System.IntPtr.Zero)
+ if (textEditorScrollStateChangedEventHandler != null)
{
- // Populate all members of "e" (ScrollStateChangedEventArgs) with real data
- e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
- e.ScrollState = state;
+ ScrollStateChangedEventArgs e = new ScrollStateChangedEventArgs();
+
+ if (textEditor != global::System.IntPtr.Zero)
+ {
+ // Populate all members of "e" (ScrollStateChangedEventArgs) with real data
+ e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
+ e.ScrollState = state;
+ }
+ //here we send all data to user event handlers
+ textEditorScrollStateChangedEventHandler(this, e);
}
+ }
- if (_textEditorScrollStateChangedEventHandler != null)
+ private void OnCursorPositionChanged(IntPtr textEditor, uint oldPosition)
+ {
+ if (textEditorCursorPositionChangedEventHandler != null)
{
+ CursorPositionChangedEventArgs e = new CursorPositionChangedEventArgs();
+
+ // Populate all members of "e" (CursorPositionChangedEventArgs) with real data
+ e.OldCursorPosition = oldPosition;
+
//here we send all data to user event handlers
- _textEditorScrollStateChangedEventHandler(this, e);
+ textEditorCursorPositionChangedEventHandler?.Invoke(this, e);
}
}
private void OnMaxLengthReached(IntPtr textEditor)
{
- MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
+ if (textEditorMaxLengthReachedEventHandler != null)
+ {
+ MaxLengthReachedEventArgs e = new MaxLengthReachedEventArgs();
+
+ // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
+ e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
+ //here we send all data to user event handlers
+ textEditorMaxLengthReachedEventHandler(this, e);
+ }
+ }
+
+ private void OnAnchorClicked(IntPtr textEditor, IntPtr href, uint hrefLength)
+ {
+ // Note: hrefLength is useful for get the length of a const char* (href) in dali-toolkit.
+ // But NUI can get the length of string (href), so hrefLength is not necessary in NUI.
+ AnchorClickedEventArgs e = new AnchorClickedEventArgs();
- // Populate all members of "e" (MaxLengthReachedEventArgs) with real data
- e.TextEditor = Registry.GetManagedBaseHandleFromNativePtr(textEditor) as TextEditor;
+ // Populate all members of "e" (AnchorClickedEventArgs) with real data
+ e.Href = Marshal.PtrToStringAnsi(href);
+ //here we send all data to user event handlers
+ textEditorAnchorClickedEventHandler?.Invoke(this, e);
+ }
- if (_textEditorMaxLengthReachedEventHandler != null)
+ private void OnSelectionChanged(IntPtr textEditor, uint oldStart, uint oldEnd)
+ {
+ if (textEditorSelectionChangedEventHandler != null)
{
+ TextSelectionChangedEventArgs e = new TextSelectionChangedEventArgs();
+
+ // Populate all members of "e" (TextSelectionChangedEventArgs) with real data
+ e.OldSelectionStart = oldStart;
+ e.OldSelectionEnd = oldEnd;
+
//here we send all data to user event handlers
- _textEditorMaxLengthReachedEventHandler(this, e);
+ textEditorSelectionChangedEventHandler?.Invoke(this, e);
}
}
+ private void OnInputFiltered(IntPtr textEditor, InputFilterType type)
+ {
+ InputFilteredEventArgs e = new InputFilteredEventArgs();
+
+ // Populate all members of "e" (InputFilteredEventArgs) with real data
+ e.Type = type;
+ //here we send all data to user event handlers
+ textEditorInputFilteredEventHandler?.Invoke(this, e);
+ }
+
/// <summary>
/// Event arguments that passed via the TextChanged signal.
/// </summary>
/// <since_tizen> 3 </since_tizen>
public class TextChangedEventArgs : EventArgs
{
- private TextEditor _textEditor;
+ private TextEditor textEditor;
/// <summary>
/// TextEditor - is the texteditor control which has the text contents changed.
{
get
{
- return _textEditor;
+ return textEditor;
}
set
{
- _textEditor = value;
+ textEditor = value;
}
}
}
/// <since_tizen> 3 </since_tizen>
public class ScrollStateChangedEventArgs : EventArgs
{
- private TextEditor _textEditor;
- private ScrollState _scrollState;
+ private TextEditor textEditor;
+ private ScrollState scrollState;
/// <summary>
/// TextEditor - is the texteditor control which has the scroll state changed.
{
get
{
- return _textEditor;
+ return textEditor;
}
set
{
- _textEditor = value;
+ textEditor = value;
}
}
{
get
{
- return _scrollState;
+ return scrollState;
}
set
{
- _scrollState = value;
+ scrollState = value;
}
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public class MaxLengthReachedEventArgs : EventArgs
{
- private TextEditor _textEditor;
+ private TextEditor textEditor;
/// <summary>
/// TextEditor.
{
get
{
- return _textEditor;
+ return textEditor;
}
set
{
- _textEditor = value;
+ textEditor = value;
}
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff