using System.Globalization;
using System.ComponentModel;
using Tizen.NUI.Text;
+using Tizen.NUI.Binding;
namespace Tizen.NUI.BaseComponents
{
/// <since_tizen> 3 </since_tizen>
public partial class TextEditor : View
{
+ static private string defaultStyleName = "Tizen.NUI.BaseComponents.TextEditor";
+ static private string defaultFontFamily = "TizenSans";
+ private static SystemFontTypeChanged systemFontTypeChanged = new SystemFontTypeChanged();
+ private static SystemLocaleLanguageChanged systemLocaleLanguageChanged = new SystemLocaleLanguageChanged();
private string textEditorTextSid = null;
private string textEditorPlaceHolderTextSid = null;
- private bool systemlangTextFlag = false;
private InputMethodContext inputMethodContext = null;
+ private string fontFamily = defaultFontFamily;
private float fontSizeScale = 1.0f;
- private bool hasFontSizeChangedCallback = false;
+ private bool hasSystemLanguageChanged = false;
+ private bool hasSystemFontSizeChanged = false;
+ private bool hasSystemFontTypeChanged = false;
+ private bool isSettingTextInCSharp = false;
+
+ private Color internalPlaceholderTextColor = null;
+ private Vector4 internalPrimaryCursorColor = null;
+ private Vector4 internalSecondaryCursorColor = null;
+ private Vector4 internalSelectionHighlightColor = null;
+ private Vector4 internalInputColor = null;
+ private Vector4 internalTextColor = null;
+ private Color internalGrabHandleColor = null;
+
static TextEditor() { }
/// Creates the TextEditor control.
/// </summary>
/// <since_tizen> 3 </since_tizen>
- public TextEditor() : this(Interop.TextEditor.New(), true)
+ public TextEditor() : this(Interop.TextEditor.New(ThemeManager.GetStyle(defaultStyleName) == null ? false : true), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
}
/// Creates the TextEditor with specified style.
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
- public TextEditor(TextEditorStyle style) : this(Interop.TextLabel.New(), true, style: style)
+ public TextEditor(TextEditorStyle style) : this(Interop.TextEditor.New(ThemeManager.GetStyle(defaultStyleName) == null ? false : true), true, style: style)
{
}
/// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
/// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
[EditorBrowsable(EditorBrowsableState.Never)]
- public TextEditor(bool shown) : this(Interop.TextEditor.New(), true)
+ public TextEditor(bool shown) : this(Interop.TextEditor.New(ThemeManager.GetStyle(defaultStyleName) == null ? false : true), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
SetVisible(shown);
internal TextEditor(TextEditor handle, bool shown = true) : this(Interop.TextEditor.NewTextEditor(TextEditor.getCPtr(handle)), true)
{
if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
-
- if (!shown)
- {
- SetVisible(false);
- }
}
internal TextEditor(global::System.IntPtr cPtr, bool cMemoryOwn, bool shown = true, TextEditorStyle style = null) : base(cPtr, cMemoryOwn, style)
{
SetVisible(false);
}
+ Focusable = true;
+ TextChanged += TextEditorTextChanged;
+ }
+
+ private bool HasStyle()
+ {
+ return ThemeManager.GetStyle(this.GetType()) == null ? false : true;
}
/// <summary>
}
/// <summary>
- /// The Text property.
+ /// The Text property.<br />
+ /// The text to display in the UTF-8 format.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string Text
}
set
{
- SetValueAndForceSendChangeSignal(TextProperty, value);
+ SetValue(TextProperty, value);
NotifyPropertyChanged();
}
}
/// <summary>
- /// The TextColor property.
+ /// The TextColor property.<br />
+ /// The color of the text.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.TextColor.X = 0.1f;) is possible.
}
/// <summary>
- /// The FontFamily property.
+ /// The FontFamily property.<br />
+ /// The requested font family to use.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string FontFamily
}
}
+ private string InternalFontFamily
+ {
+ get
+ {
+ if (HasStyle())
+ return fontFamily;
+ else
+ return Object.InternalGetPropertyString(this.SwigCPtr, TextEditor.Property.FontFamily);
+ }
+ set
+ {
+ string newFontFamily;
+
+ if (string.Equals(fontFamily, value)) return;
+
+ fontFamily = value;
+ if (fontFamily == Tizen.NUI.FontFamily.UseSystemSetting)
+ {
+ try
+ {
+ newFontFamily = SystemSettings.FontType;
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("{0} Exception caught.", e);
+ newFontFamily = defaultFontFamily;
+ }
+ AddSystemSettingsFontTypeChanged();
+ }
+ else
+ {
+ newFontFamily = fontFamily;
+ RemoveSystemSettingsFontTypeChanged();
+ }
+
+ SetInternalFontFamily(newFontFamily);
+ }
+ }
+
+ private void SetInternalFontFamily(string fontFamily)
+ {
+ Object.InternalSetPropertyString(this.SwigCPtr, TextEditor.Property.FontFamily, (string)fontFamily);
+ }
+
/// <summary>
- /// The FontStyle property.
+ /// The FontStyle property.<br />
+ /// The requested font style to use.<br />
/// The fontStyle map contains the following keys :<br />
/// <list type="table">
/// <item><term>width (string)</term><description>The width key defines occupied by each glyph. (values: ultraCondensed, extraCondensed, condensed, semiCondensed, normal, semiExpanded, expanded, extraExpanded, ultraExpanded)</description></item>
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetFontStyle(FontStyle fontStyle)
{
- SetValue(FontStyleProperty, TextUtils.GetFontStyleMap(fontStyle));
+ using (var fontStyleMap = TextMapHelper.GetFontStyleMap(fontStyle))
+ {
+ SetValue(FontStyleProperty, fontStyleMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public FontStyle GetFontStyle()
{
- return TextUtils.GetFontStyleStruct((PropertyMap)GetValue(FontStyleProperty));
+ FontStyle fontStyle;
+ using (var fontStyleMap = (PropertyMap)GetValue(FontStyleProperty))
+ {
+ fontStyle = TextMapHelper.GetFontStyleStruct(fontStyleMap);
+ }
+ return fontStyle;
}
/// <summary>
- /// The PointSize property.
+ /// The PointSize property.<br />
+ /// The size of font in points.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
+ [Binding.TypeConverter(typeof(PointSizeTypeConverter))]
public float PointSize
{
get
}
/// <summary>
- /// The HorizontalAlignment property.
+ /// The HorizontalAlignment property.<br />
+ /// The line horizontal alignment.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public HorizontalAlignment HorizontalAlignment
}
/// <summary>
- /// The ScrollThreshold property.
+ /// The VerticalAlignment property.<br />
+ /// The line vertical alignment.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public VerticalAlignment VerticalAlignment
+ {
+ get
+ {
+ return (VerticalAlignment)GetValue(VerticalAlignmentProperty);
+ }
+ set
+ {
+ SetValue(VerticalAlignmentProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+
+ /// <summary>
+ /// The ScrollThreshold property.<br />
+ /// Horizontal scrolling will occur if the cursor is this close to the control border.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float ScrollThreshold
}
/// <summary>
- /// The ScrollSpeed property.
+ /// The ScrollSpeed property.<br />
+ /// The scroll speed in pixels per second.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float ScrollSpeed
}
/// <summary>
- /// The PrimaryCursorColor property.
+ /// The PrimaryCursorColor property.<br />
+ /// The color to apply to the primary cursor.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.PrimaryCursorColor.X = 0.1f;) is possible.
}
/// <summary>
- /// The SecondaryCursorColor property.
+ /// The SecondaryCursorColor property.<br />
+ /// The color to apply to the secondary cursor.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.SecondaryCursorColor.X = 0.1f;) is possible.
}
/// <summary>
- /// The EnableCursorBlink property.
+ /// The EnableCursorBlink property.<br />
+ /// Whether the cursor should blink or not.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool EnableCursorBlink
}
/// <summary>
- /// The CursorBlinkInterval property.
+ /// The CursorBlinkInterval property.<br />
+ /// The time interval in seconds between cursor on/off states.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float CursorBlinkInterval
}
/// <summary>
- /// The CursorBlinkDuration property.
+ /// The CursorBlinkDuration property.<br />
+ /// The cursor will stop blinking after this number of seconds (if non-zero).<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float CursorBlinkDuration
}
/// <summary>
- /// The GrabHandleImage property.
+ /// The GrabHandleImage property.<br />
+ /// The image to display for the grab handle.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string GrabHandleImage
}
/// <summary>
- /// The GrabHandlePressedImage property.
+ /// The GrabHandlePressedImage property.<br />
+ /// The image to display when the grab handle is pressed.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string GrabHandlePressedImage
}
/// <summary>
- /// The SelectionHandleImageLeft property.
+ /// The SelectionPopupStyle property.<br />
+ /// The style of the text selection popup can be set through SelectionPopupStyle property.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public PropertyMap SelectionPopupStyle
+ {
+ get
+ {
+ return (PropertyMap)GetValue(SelectionPopupStyleProperty);
+ }
+ set
+ {
+ SetValue(SelectionPopupStyleProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+
+ /// <summary>
+ /// The SelectionHandleImageLeft property.<br />
+ /// The image to display for the left selection handle.<br />
/// The selectionHandleImageLeft map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
}
/// <summary>
- /// The SelectionHandleImageRight property.
+ /// The SelectionHandleImageRight property.<br />
+ /// The image to display for the right selection handle.<br />
/// The selectionHandleImageRight map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
{
if (!String.IsNullOrEmpty(selectionHandleImage.LeftImageUrl))
{
- SetValue(SelectionHandleImageLeftProperty, TextUtils.GetFileNameMap(selectionHandleImage.LeftImageUrl));
+ using (var leftImageMap = TextMapHelper.GetFileNameMap(selectionHandleImage.LeftImageUrl))
+ {
+ SetValue(SelectionHandleImageLeftProperty, leftImageMap);
+ }
}
if (!String.IsNullOrEmpty(selectionHandleImage.RightImageUrl))
{
- SetValue(SelectionHandleImageRightProperty, TextUtils.GetFileNameMap(selectionHandleImage.RightImageUrl));
+ using (var rightImageMap = TextMapHelper.GetFileNameMap(selectionHandleImage.RightImageUrl))
+ {
+ SetValue(SelectionHandleImageRightProperty, rightImageMap);
+ }
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public SelectionHandleImage GetSelectionHandleImage()
{
- return TextUtils.GetSelectionHandleImageStruct((PropertyMap)GetValue(SelectionHandleImageLeftProperty), (PropertyMap)GetValue(SelectionHandleImageRightProperty));
+ SelectionHandleImage selectionHandleImage;
+ using (var leftImageMap = (PropertyMap)GetValue(SelectionHandleImageLeftProperty))
+ using (var rightImageMap = (PropertyMap)GetValue(SelectionHandleImageRightProperty))
+ {
+ selectionHandleImage = TextMapHelper.GetSelectionHandleImageStruct(leftImageMap, rightImageMap);
+ }
+ return selectionHandleImage;
}
/// <summary>
- /// The SelectionHandlePressedImageLeft property.
+ /// The SelectionHandlePressedImageLeft property.<br />
+ /// The image to display when the left selection handle is pressed.<br />
/// The selectionHandlePressedImageLeft map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
}
/// <summary>
- /// The SelectionHandlePressedImageRight property.
+ /// The SelectionHandlePressedImageRight property.<br />
+ /// The image to display when the right selection handle is pressed.<br />
/// The selectionHandlePressedImageRight map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
{
if (!String.IsNullOrEmpty(selectionHandlePressedImage.LeftImageUrl))
{
- SetValue(SelectionHandlePressedImageLeftProperty, TextUtils.GetFileNameMap(selectionHandlePressedImage.LeftImageUrl));
+ using (var leftImageMap = TextMapHelper.GetFileNameMap(selectionHandlePressedImage.LeftImageUrl))
+ {
+ SetValue(SelectionHandlePressedImageLeftProperty, leftImageMap);
+ }
}
if (!String.IsNullOrEmpty(selectionHandlePressedImage.RightImageUrl))
{
- SetValue(SelectionHandlePressedImageRightProperty, TextUtils.GetFileNameMap(selectionHandlePressedImage.RightImageUrl));
+ using (var rightImageMap = TextMapHelper.GetFileNameMap(selectionHandlePressedImage.RightImageUrl))
+ {
+ SetValue(SelectionHandlePressedImageRightProperty, rightImageMap);
+ }
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public SelectionHandleImage GetSelectionHandlePressedImage()
{
- return TextUtils.GetSelectionHandleImageStruct((PropertyMap)GetValue(SelectionHandlePressedImageLeftProperty), (PropertyMap)GetValue(SelectionHandlePressedImageRightProperty));
+ SelectionHandleImage selectionHandleImage;
+ using (var leftImageMap = (PropertyMap)GetValue(SelectionHandlePressedImageLeftProperty))
+ using (var rightImageMap = (PropertyMap)GetValue(SelectionHandlePressedImageRightProperty))
+ {
+ selectionHandleImage = TextMapHelper.GetSelectionHandleImageStruct(leftImageMap, rightImageMap);
+ }
+ return selectionHandleImage;
}
/// <summary>
- /// The SelectionHandleMarkerImageLeft property.
+ /// The SelectionHandleMarkerImageLeft property.<br />
+ /// The image to display for the left selection handle marker.<br />
/// The selectionHandleMarkerImageLeft map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
}
/// <summary>
- /// The SelectionHandleMarkerImageRight property.
+ /// The SelectionHandleMarkerImageRight property.<br />
+ /// The image to display for the right selection handle marker.<br />
/// The selectionHandleMarkerImageRight map contains the following key :<br />
/// <list type="table">
/// <item><term>filename (string)</term><description>The path of image file</description></item>
{
if (!String.IsNullOrEmpty(selectionHandleMarkerImage.LeftImageUrl))
{
- SetValue(SelectionHandleMarkerImageLeftProperty, TextUtils.GetFileNameMap(selectionHandleMarkerImage.LeftImageUrl));
+ using (var leftImageMap = TextMapHelper.GetFileNameMap(selectionHandleMarkerImage.LeftImageUrl))
+ {
+ SetValue(SelectionHandleMarkerImageLeftProperty, leftImageMap);
+ }
}
if (!String.IsNullOrEmpty(selectionHandleMarkerImage.RightImageUrl))
{
- SetValue(SelectionHandleMarkerImageRightProperty, TextUtils.GetFileNameMap(selectionHandleMarkerImage.RightImageUrl));
+ using (var rightImageMap = TextMapHelper.GetFileNameMap(selectionHandleMarkerImage.RightImageUrl))
+ {
+ SetValue(SelectionHandleMarkerImageRightProperty, rightImageMap);
+ }
}
}
[EditorBrowsable(EditorBrowsableState.Never)]
public SelectionHandleImage GetSelectionHandleMarkerImage()
{
- return TextUtils.GetSelectionHandleImageStruct((PropertyMap)GetValue(SelectionHandleMarkerImageLeftProperty), (PropertyMap)GetValue(SelectionHandleMarkerImageRightProperty));
+ SelectionHandleImage selectionHandleImage;
+ using (var leftImageMap = (PropertyMap)GetValue(SelectionHandleMarkerImageLeftProperty))
+ using (var rightImageMap = (PropertyMap)GetValue(SelectionHandleMarkerImageRightProperty))
+ {
+ selectionHandleImage = TextMapHelper.GetSelectionHandleImageStruct(leftImageMap, rightImageMap);
+ }
+ return selectionHandleImage;
}
/// <summary>
- /// The SelectionHighlightColor property.
+ /// The SelectionHighlightColor property.<br />
+ /// The color of the selection highlight.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.SelectionHighlightColor.X = 0.1f;) is possible.
}
/// <summary>
- /// The DecorationBoundingBox property.
+ /// The DecorationBoundingBox property.<br />
+ /// The decorations (handles etc) will positioned within this area on-screen.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.DecorationBoundingBox.X = 1;) is possible.
}
/// <summary>
- /// The EnableMarkup property.
+ /// The EnableMarkup property.<br />
+ /// Whether the mark-up processing is enabled.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool EnableMarkup
}
/// <summary>
- /// The InputColor property.
+ /// The InputColor property.<br />
+ /// The color of the new input text.<br />
/// </summary>
/// <remarks>
/// The property cascade chaining set is possible. For example, this (textEditor.InputColor.X = 0.1f;) is possible.
}
/// <summary>
- /// The InputFontFamily property.
+ /// The InputFontFamily property.<br />
+ /// The font's family of the new input text.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string InputFontFamily
}
/// <summary>
- /// The InputFontStyle property.
+ /// The InputFontStyle property.<br />
+ /// The font's style of the new input text.<br />
/// The inputFontStyle map contains the following keys :<br />
/// <list type="table">
/// <item><term>width (string)</term><description>The width key defines occupied by each glyph. (values: ultraCondensed, extraCondensed, condensed, semiCondensed, normal, semiExpanded, expanded, extraExpanded, ultraExpanded)</description></item>
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetInputFontStyle(FontStyle fontStyle)
{
- SetValue(InputFontStyleProperty, TextUtils.GetFontStyleMap(fontStyle));
+ using (var fontStyleMap = TextMapHelper.GetFontStyleMap(fontStyle))
+ {
+ SetValue(InputFontStyleProperty, fontStyleMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public FontStyle GetInputFontStyle()
{
- return TextUtils.GetFontStyleStruct((PropertyMap)GetValue(InputFontStyleProperty));
+ FontStyle fontStyle;
+ using (var fontStyleMap = (PropertyMap)GetValue(InputFontStyleProperty))
+ {
+ fontStyle = TextMapHelper.GetFontStyleStruct(fontStyleMap);
+ }
+ return fontStyle;
}
/// <summary>
- /// The InputPointSize property.
+ /// The InputPointSize property.<br />
+ /// The font's size of the new input text in points.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
+ [Binding.TypeConverter(typeof(PointSizeTypeConverter))]
public float InputPointSize
{
get
}
/// <summary>
- /// The LineSpacing property.
+ /// The LineSpacing property.<br />
+ /// The default extra space between lines in points.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float LineSpacing
}
/// <summary>
- /// The InputLineSpacing property.
+ /// The InputLineSpacing property.<br />
+ /// The extra space between lines in points.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float InputLineSpacing
}
/// <summary>
- /// The Underline property.
+ /// The relative height of the line (a factor that will be multiplied by text height). <br />
+ /// If the value is less than 1, the lines could to be overlapped.
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public float RelativeLineHeight
+ {
+ get
+ {
+ return (float)GetValue(RelativeLineHeightProperty);
+ }
+ set
+ {
+ SetValue(RelativeLineHeightProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+
+ /// <summary>
+ /// The Underline property.<br />
+ /// The default underline parameters.<br />
/// The underline map contains the following keys :<br />
/// <list type="table">
/// <item><term>enable (bool)</term><description>Whether the underline is enabled (the default value is false)</description></item>
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetUnderline(Underline underline)
{
- SetValue(UnderlineProperty, TextUtils.GetUnderlineMap(underline));
+ using (var underlineMap = TextMapHelper.GetUnderlineMap(underline))
+ {
+ SetValue(UnderlineProperty, underlineMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public Underline GetUnderline()
{
- return TextUtils.GetUnderlineStruct((PropertyMap)GetValue(UnderlineProperty));
+ Underline underline;
+ using (var underlineMap = (PropertyMap)GetValue(UnderlineProperty))
+ {
+ underline = TextMapHelper.GetUnderlineStruct(underlineMap);
+ }
+ return underline;
}
/// <summary>
- /// The InputUnderline property.
+ /// The InputUnderline property.<br />
+ /// The underline parameters of the new input text.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string InputUnderline
}
/// <summary>
- /// The Shadow property.
+ /// The Shadow property.<br />
+ /// The default shadow parameters.<br />
/// The shadow map contains the following keys :<br />
/// <list type="table">
/// <item><term>color (Color)</term><description>The color of the shadow (the default color is Color.Black)</description></item>
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetShadow(Tizen.NUI.Text.Shadow shadow)
{
- SetValue(ShadowProperty, TextUtils.GetShadowMap(shadow));
+ using (var shadowMap = TextMapHelper.GetShadowMap(shadow))
+ {
+ SetValue(ShadowProperty, shadowMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public Tizen.NUI.Text.Shadow GetShadow()
{
- return TextUtils.GetShadowStruct((PropertyMap)GetValue(ShadowProperty));
+ Tizen.NUI.Text.Shadow shadow;
+ using (var shadowMap = (PropertyMap)GetValue(ShadowProperty))
+ {
+ shadow = TextMapHelper.GetShadowStruct(shadowMap);
+ }
+ return shadow;
}
/// <summary>
- /// The InputShadow property.
+ /// The InputShadow property.<br />
+ /// The shadow parameters of the new input text.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string InputShadow
}
/// <summary>
- /// The Emboss property.
+ /// The Emboss property.<br />
+ /// The default emboss parameters.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string Emboss
}
/// <summary>
- /// The InputEmboss property.
+ /// The InputEmboss property.<br />
+ /// The emboss parameters of the new input text.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string InputEmboss
}
/// <summary>
- /// The Outline property.
+ /// The Outline property.<br />
+ /// The default outline parameters.<br />
/// The outline map contains the following keys :<br />
/// <list type="table">
/// <item><term>color (Color)</term><description>The color of the outline (the default color is Color.White)</description></item>
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetOutline(Outline outline)
{
- SetValue(OutlineProperty, TextUtils.GetOutlineMap(outline));
+ using (var outlineMap = TextMapHelper.GetOutlineMap(outline))
+ {
+ SetValue(OutlineProperty, outlineMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public Outline GetOutline()
{
- return TextUtils.GetOutlineStruct((PropertyMap)GetValue(OutlineProperty));
+ Outline outline;
+ using (var outlineMap = (PropertyMap)GetValue(OutlineProperty))
+ {
+ outline = TextMapHelper.GetOutlineStruct(outlineMap);
+ }
+ return outline;
}
/// <summary>
- /// The InputOutline property.
+ /// The InputOutline property.<br />
+ /// The outline parameters of the new input text.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public string InputOutline
}
/// <summary>
- /// The SmoothScroll property.
+ /// The SmoothScroll property.<br />
+ /// Enable or disable the smooth scroll animation.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool SmoothScroll
}
/// <summary>
- /// The SmoothScrollDuration property.
+ /// The SmoothScrollDuration property.<br />
+ /// Sets the duration of smooth scroll animation.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float SmoothScrollDuration
}
/// <summary>
- /// The EnableScrollBar property.
+ /// The EnableScrollBar property.<br />
+ /// Enable or disable the scroll bar.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool EnableScrollBar
}
/// <summary>
- /// The ScrollBarShowDuration property.
+ /// The ScrollBarShowDuration property.<br />
+ /// Sets the duration of scroll bar to show.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float ScrollBarShowDuration
}
/// <summary>
- /// The ScrollBarFadeDuration property.
+ /// The ScrollBarFadeDuration property.<br />
+ /// Sets the duration of scroll bar to fade out.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public float ScrollBarFadeDuration
}
/// <summary>
- /// The PixelSize property.
+ /// The PixelSize property.<br />
+ /// The size of font in pixels.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
+ [Binding.TypeConverter(typeof(FloatGraphicsTypeConverter))]
public float PixelSize
{
get
{
get
{
- int temp = 0;
- GetProperty(TextEditor.Property.LineCount).Get(out temp);
- return temp;
+ int lineCount = 0;
+ using (var propertyValue = GetProperty(TextEditor.Property.LineCount))
+ {
+ propertyValue.Get(out lineCount);
+ }
+ return lineCount;
}
}
}
/// <summary>
- /// The Selected Text property (read-only).
+ /// The portion of the text that has been selected by the user.
/// </summary>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <remarks>
+ /// Empty string when nothing is selected.
+ /// </remarks>
+ /// <since_tizen> 9 </since_tizen>
public string SelectedText
{
get
{
- string temp;
- GetProperty(TextEditor.Property.SelectedText).Get(out temp);
- return temp;
+ string selectedText;
+ using (var propertyValue = GetProperty(TextEditor.Property.SelectedText))
+ {
+ propertyValue.Get(out selectedText);
+ }
+ return selectedText;
}
}
}
/// <summary>
- /// The EnableSelection property.
+ /// The Enable selection property.<br />
+ /// Enables Text selection, such as the cursor, handle, clipboard, and highlight color.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
public bool EnableSelection
/// <summary>
/// The start index for selection.
/// </summary>
- /// <since_tizen> 8 </since_tizen>
- /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <remarks>
+ /// When there is no selection, the index is current cursor position.
+ /// </remarks>
+ /// <since_tizen> 9 </since_tizen>
public int SelectedTextStart
{
get
{
- int temp;
- GetProperty(TextEditor.Property.SelectedTextStart).Get(out temp);
- return temp;
+ int selectedTextStart;
+ using (var propertyValue = GetProperty(TextEditor.Property.SelectedTextStart))
+ {
+ propertyValue.Get(out selectedTextStart);
+ }
+ return selectedTextStart;
}
}
/// <summary>
/// The end index for selection.
/// </summary>
- /// <since_tizen> 8 </since_tizen>
- /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <remarks>
+ /// When there is no selection, the index is current cursor position.
+ /// </remarks>
+ /// <since_tizen> 9 </since_tizen>
public int SelectedTextEnd
{
get
{
- int temp;
- GetProperty(TextEditor.Property.SelectedTextEnd).Get(out temp);
- return temp;
+ int selectedTextEnd;
+ using (var propertyValue = GetProperty(TextEditor.Property.SelectedTextEnd))
+ {
+ propertyValue.Get(out selectedTextEnd);
+ }
+ return selectedTextEnd;
}
}
/// <summary>
/// Enable editing in text control.
/// </summary>
- /// <since_tizen> 8 </since_tizen>
- /// This will be public opened in tizen_6.0 after ACR done, Before ACR, need to be hidden as inhouse API.
+ /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
[EditorBrowsable(EditorBrowsableState.Never)]
public bool EnableEditing
{
{
get
{
- bool temp;
- GetProperty(TextEditor.Property.EnableEditing).Get(out temp);
- return temp;
+ bool enableEditing;
+ using (var propertyValue = GetProperty(TextEditor.Property.EnableEditing))
+ {
+ propertyValue.Get(out enableEditing);
+ }
+ return enableEditing;
}
set
{
- SetProperty(TextEditor.Property.EnableEditing, new PropertyValue(value));
- NotifyPropertyChanged();
+ using (var propertyValue = new PropertyValue(value))
+ {
+ SetProperty(TextEditor.Property.EnableEditing, propertyValue);
+ NotifyPropertyChanged();
+ }
}
}
{
get
{
- int temp;
- using (PropertyValue propertyValue = GetProperty(TextEditor.Property.HorizontalScrollPosition))
+ int horizontalScrollPosition;
+ using (var propertyValue = GetProperty(TextEditor.Property.HorizontalScrollPosition))
{
- propertyValue.Get(out temp);
+ propertyValue.Get(out horizontalScrollPosition);
}
- return temp;
+ return horizontalScrollPosition;
}
set
{
- using (PropertyValue propertyValue = new PropertyValue(value))
+ using (var propertyValue = new PropertyValue(value))
{
SetProperty(TextEditor.Property.HorizontalScrollPosition, propertyValue);
NotifyPropertyChanged();
{
get
{
- int temp;
- using (PropertyValue propertyValue = GetProperty(TextEditor.Property.VerticalScrollPosition))
+ int verticalScrollPosition;
+ using (var propertyValue = GetProperty(TextEditor.Property.VerticalScrollPosition))
{
- propertyValue.Get(out temp);
+ propertyValue.Get(out verticalScrollPosition);
}
- return temp;
+ return verticalScrollPosition;
}
set
{
- using (PropertyValue propertyValue = new PropertyValue(value))
+ using (var propertyValue = new PropertyValue(value))
{
SetProperty(TextEditor.Property.VerticalScrollPosition, propertyValue);
NotifyPropertyChanged();
}
/// <summary>
- /// Specify primary cursor (caret) position in text control.
+ /// PrimaryCursorPosition property.<br />
+ /// Specify the position of the primary cursor (caret) in text control.
/// </summary>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <remarks>
+ /// If the value set is out of range (negative or greater than or equal the number of characters in Text) then the PrimaryCursorPosition is moved to the end of Text (the number of characters in Text).
+ /// </remarks>
+ /// <since_tizen> 10 </since_tizen>
public int PrimaryCursorPosition
{
get
{
get
{
- int temp;
- using (PropertyValue propertyValue = GetProperty(TextEditor.Property.PrimaryCursorPosition))
+ int primaryCursorPosition;
+ using (var propertyValue = GetProperty(TextEditor.Property.PrimaryCursorPosition))
{
- propertyValue.Get(out temp);
+ propertyValue.Get(out primaryCursorPosition);
}
- return temp;
+ return primaryCursorPosition;
}
set
{
- using (PropertyValue propertyValue = new PropertyValue(value))
+ using (var propertyValue = new PropertyValue(value))
{
SetProperty(TextEditor.Property.PrimaryCursorPosition, propertyValue);
NotifyPropertyChanged();
}
/// <summary>
- /// Set InputFilter to TextEditor. <br />
+ /// Set InputFilter to TextEditor.
/// </summary>
/// <param name="inputFilter">The InputFilter</param>
/// <remarks>
/// <see cref="Tizen.NUI.Text.InputFilter"/> filters input based on regular expressions. <br />
- /// Users can set the Accepted or Rejected regular expression set, or both. <br />
- /// If both are used, Rejected has higher priority. <br />
- /// The character set must follow the regular expression rules. <br />
- /// Behaviour can not be guaranteed for incorrect grammars. <br />
- /// Refer the link below for detailed rules. <br />
- /// The functions in std::regex library use the ECMAScript grammar: <br />
- /// http://cplusplus.com/reference/regex/ECMAScript/ <br />
/// InputFiltered signal is emitted when the input is filtered by InputFilter <br />
- /// See <see cref="InputFiltered"/>, <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description. <br />
+ /// See <see cref="InputFiltered"/>, <see cref="InputFilterType"/> and <see cref="InputFilteredEventArgs"/> for a detailed description.
/// </remarks>
/// <example>
/// The following example demonstrates how to use the SetInputFilter method.
/// editor.SetInputFilter(inputFilter); // acceptable inputs are 4, 5, 6, 7, 8, 9
/// </code>
/// </example>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <since_tizen> 9 </since_tizen>
public void SetInputFilter(InputFilter inputFilter)
{
- SetProperty(TextEditor.Property.InputFilter, new PropertyValue(TextUtils.GetInputFilterMap(inputFilter)));
+ using (var map = TextMapHelper.GetInputFilterMap(inputFilter))
+ using (var propertyValue = new PropertyValue(map))
+ {
+ SetProperty(TextEditor.Property.InputFilter, propertyValue);
+ }
}
/// <summary>
/// <remarks>
/// <see cref="Tizen.NUI.Text.InputFilter"/>
/// </remarks>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <since_tizen> 9 </since_tizen>
public InputFilter GetInputFilter()
{
- var map = new PropertyMap();
- GetProperty(TextEditor.Property.InputFilter).Get(map);
- return TextUtils.GetInputFilterStruct(map);
+ InputFilter inputFilter;
+ using (var propertyValue = GetProperty(TextEditor.Property.InputFilter))
+ using (var map = new PropertyMap())
+ {
+ propertyValue.Get(map);
+ inputFilter = TextMapHelper.GetInputFilterStruct(map);
+ }
+ return inputFilter;
+ }
+
+ /// <summary>
+ /// Set Strikethrough to TextEditor. <br />
+ /// </summary>
+ /// <param name="strikethrough">The Strikethrough</param>
+ /// <remarks>
+ /// SetStrikethrough specifies the strikethrough of the text through <see cref="Tizen.NUI.Text.Strikethrough"/>. <br />
+ /// </remarks>
+ /// <example>
+ /// The following example demonstrates how to use the SetStrikethrough method.
+ /// <code>
+ /// var strikethrough = new Tizen.NUI.Text.Strikethrough();
+ /// strikethrough.Enable = true;
+ /// strikethrough.Color = new Color("#3498DB");
+ /// strikethrough.Height = 2.0f;
+ /// editor.SetStrikethrough(strikethrough);
+ /// </code>
+ /// </example>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public void SetStrikethrough(Strikethrough strikethrough)
+ {
+ using (var map = TextMapHelper.GetStrikethroughMap(strikethrough))
+ using (var propertyValue = new PropertyValue(map))
+ {
+ SetProperty(TextEditor.Property.Strikethrough, propertyValue);
+ }
+ }
+
+ /// <summary>
+ /// Get Strikethrough from TextEditor. <br />
+ /// </summary>
+ /// <returns>The Strikethrough</returns>
+ /// <remarks>
+ /// <see cref="Tizen.NUI.Text.Strikethrough"/>
+ /// </remarks>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public Strikethrough GetStrikethrough()
+ {
+ Strikethrough strikethrough;
+ using (var propertyValue = GetProperty(TextEditor.Property.Strikethrough))
+ using (var map = new PropertyMap())
+ {
+ propertyValue.Get(map);
+ strikethrough = TextMapHelper.GetStrikethroughStruct(map);
+ }
+ return strikethrough;
}
/// <summary>
get
{
PropertyMap map = (PropertyMap)GetValue(PlaceholderProperty);
- PropertyValue value = null;
+ string defalutText = "";
- // text
- value = map.Find(0);
- if (null != value)
- {
- value.Get(out string text);
- map.Add("text", new PropertyValue(text));
- }
+ if (TextMapHelper.IsValue(map, 0))
+ map.Add("text", TextMapHelper.GetStringFromMap(map, 0, defalutText));
- // textFocused
- value = map.Find(1);
- if (null != value)
- {
- value.Get(out string textFocused);
- map.Add("textFocused", new PropertyValue(textFocused));
- }
+ if (TextMapHelper.IsValue(map, 1))
+ map.Add("textFocused", TextMapHelper.GetStringFromMap(map, 1, defalutText));
- // color
- value = map.Find(2);
- if (null != value)
+ if (TextMapHelper.IsValue(map, 2))
{
- Color color = new Color();
- value.Get(color);
- map.Add("color", new PropertyValue(color));
+ using (var color = TextMapHelper.GetColorFromMap(map, 2))
+ {
+ map.Add("color", color);
+ }
}
- // fontFamily
- value = map.Find(3);
- if (null != value)
- {
- value.Get(out string fontFamily);
- map.Add("fontFamily", new PropertyValue(fontFamily));
- }
+ if (TextMapHelper.IsValue(map, 3))
+ map.Add("fontFamily", TextMapHelper.GetStringFromMap(map, 3, defalutText));
- // fontStyle
- value = map.Find(4);
- if (null != value)
+ if (TextMapHelper.IsValue(map, 4))
{
- PropertyMap fontStyle = new PropertyMap();
- value.Get(fontStyle);
- map.Add("fontStyle", new PropertyValue(fontStyle));
+ using (var properyValue = map.Find(4))
+ using (var fontStyle = new PropertyMap())
+ {
+ properyValue.Get(fontStyle);
+ using (var fontStyleValue = new PropertyValue(fontStyle))
+ {
+ map.Add("fontStyle", fontStyleValue);
+ }
+ }
}
- // pointSize
- value = map.Find(5);
- if (null != value)
- {
- value.Get(out float pointSize);
- map.Add("pointSize", new PropertyValue(pointSize));
- }
+ if (TextMapHelper.IsValue(map, 5))
+ map.Add("pointSize", TextMapHelper.GetNullableFloatFromMap(map, 5));
- // pixelSize
- value = map.Find(6);
- if (null != value)
- {
- value.Get(out float pixelSize);
- map.Add("pixelSize", new PropertyValue(pixelSize));
- }
+ if (TextMapHelper.IsValue(map, 6))
+ map.Add("pixelSize", TextMapHelper.GetNullableFloatFromMap(map, 6));
- // ellipsis
- value = map.Find(7);
- if (null != value)
- {
- value.Get(out bool ellipsis);
- map.Add("ellipsis", new PropertyValue(ellipsis));
- }
+ if (TextMapHelper.IsValue(map, 7))
+ map.Add("ellipsis", TextMapHelper.GetBoolFromMap(map, 7, false));
return map;
}
[EditorBrowsable(EditorBrowsableState.Never)]
public void SetPlaceholder(Placeholder placeholder)
{
- SetValue(PlaceholderProperty, TextUtils.GetPlaceholderMap(placeholder));
+ using (var placeholderMap = TextMapHelper.GetPlaceholderMap(placeholder))
+ {
+ SetValue(PlaceholderProperty, placeholderMap);
+ }
}
/// <summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public Placeholder GetPlaceholder()
{
- return TextUtils.GetPlaceholderStruct((PropertyMap)GetValue(PlaceholderProperty));
+ Placeholder placeholder;
+ using (var placeholderMap = (PropertyMap)GetValue(PlaceholderProperty))
+ {
+ placeholder = TextMapHelper.GetPlaceholderStruct(placeholderMap);
+ }
+ return placeholder;
}
/// <summary>
/// <summary>
/// Enables Text selection using Shift key.
/// </summary>
- /// <since_tizen> 5 </since_tizen>
- /// This will be released at Tizen.NET API Level 5, so currently this would be used as inhouse API.
+ /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
[EditorBrowsable(EditorBrowsableState.Never)]
public bool EnableShiftSelection
{
}
/// <summary>
- /// The MaxLength property.
+ /// The MaxLength property.<br />
+ /// The maximum number of characters that can be inserted.<br />
/// </summary>
- /// This will be public opened in tizen_6.5 after ACR done. Before ACR, need to be hidden as inhouse API.
+ /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
[EditorBrowsable(EditorBrowsableState.Never)]
public int MaxLength
{
}
}
- /// Only used by the IL of xaml, will never changed to not hidden.
- [EditorBrowsable(EditorBrowsableState.Never)]
- public override bool IsCreateByXaml
+ /// <summary>
+ /// The FontSizeScale property. <br />
+ /// The default value is 1.0. <br />
+ /// The given font size scale value is used for multiplying the specified font size before querying fonts. <br />
+ /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
+ /// </summary>
+ /// <since_tizen> 9 </since_tizen>
+ public float FontSizeScale
{
get
{
- return base.IsCreateByXaml;
+ return (float)GetValue(FontSizeScaleProperty);
}
set
{
- base.IsCreateByXaml = value;
-
- if (value == true)
- {
- this.TextChanged += (obj, e) =>
- {
- this.Text = e.TextEditor.Text;
- };
- }
+ SetValue(FontSizeScaleProperty, value);
+ NotifyPropertyChanged();
}
}
- /// <summary>
- /// The FontSizeScale property. <br />
- /// The default value is 1.0. <br />
- /// If FontSizeScale.UseSystemSetting, will use the SystemSettings.FontSize internally. <br />
- /// </summary>
- /// <since_tizen> 9 </since_tizen>
- public float FontSizeScale
+ private float InternalFontSizeScale
{
get
{
systemSettingsFontSize = SystemSettingsFontSize.Normal;
}
newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
- addFontSizeChangedCallback();
+ AddSystemSettingsFontSizeChanged();
}
else
{
newFontSizeScale = fontSizeScale;
- removeFontSizeChangedCallback();
+ RemoveSystemSettingsFontSizeChanged();
}
- SetValue(FontSizeScaleProperty, newFontSizeScale);
+ SetInternalFontSizeScale(newFontSizeScale);
+ }
+ }
+
+ private void SetInternalFontSizeScale(float fontSizeScale)
+ {
+
+ Object.InternalSetPropertyFloat(this.SwigCPtr, TextEditor.Property.FontSizeScale, (float)fontSizeScale);
+ }
+
+ /// <summary>
+ /// The EnableFontSizeScale property.<br />
+ /// Whether the font size scale is enabled. (The default value is true)
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public bool EnableFontSizeScale
+ {
+ get
+ {
+ return (bool)GetValue(EnableFontSizeScaleProperty);
+ }
+ set
+ {
+ SetValue(EnableFontSizeScaleProperty, value);
NotifyPropertyChanged();
}
}
/// <summary>
- /// The InputMethodSettings property.
+ /// The InputMethodSettings property.<br />
+ /// The settings to relating to the System's Input Method, Key and Value.<br />
/// </summary>
/// <remarks>
- /// <see cref="InputMethod"/> is a class encapsulating the input method map. Please use the <see cref="InputMethod"/> class for this property.
+ /// <see cref="InputMethod"/> is a class encapsulating the input method map. Use the <see cref="InputMethod"/> class for this property.
/// </remarks>
/// <example>
/// The following example demonstrates how to set the InputMethodSettings property.
/// <summary>
/// Select the whole text.
/// </summary>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <since_tizen> 9 </since_tizen>
public void SelectWholeText()
{
Interop.TextEditor.SelectWholeText(SwigCPtr);
/// <summary>
/// Select text from start to end index. <br />
- /// The index is valid when 0 or positive. <br />
+ /// The index is valid when 0 or positive.
/// </summary>
/// <param name="start">The start index for selection.</param>
/// <param name="end">The end index for selection.</param>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <remarks>
+ /// If the end index exceeds the maximum value, it is set to the length of the text.
+ /// </remarks>
+ /// <since_tizen> 9 </since_tizen>
public void SelectText(int start, int end)
{
if (start < 0)
}
/// <summary>
- /// Clear selection of the text.
+ /// Clear selection of the text. <br />
+ /// Valid when selection is activate.
/// </summary>
- [EditorBrowsable(EditorBrowsableState.Never)]
+ /// <since_tizen> 9 </since_tizen>
public void SelectNone()
{
_ = Interop.TextEditor.SelectNone(SwigCPtr);
}
/// <summary>
- /// Enable grab handle property.
+ /// The Enable grab handle property.<br />
+ /// Enables the grab handles for text selection.<br />
+ /// The default value is true, which means the grab handles are enabled by default.<br />
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public bool EnableGrabHandle
}
/// <summary>
- /// Enable grab handle popup property.
+ /// The Enable grab handle popup property.<br />
+ /// Enables the grab handle popup for text selection.<br />
+ /// The default value is true, which means the grab handle popup is enabled by default.<br />
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public bool EnableGrabHandlePopup
}
/// <summary>
- /// Minimum line size to be used.
+ /// Minimum line size to be used.<br />
+ /// The height of the line in points. <br />
+ /// If the font size is larger than the line size, it works with the font size. <br />
/// </summary>
[EditorBrowsable(EditorBrowsableState.Never)]
public float MinLineSize
}
/// <summary>
+ /// The spaces between characters in Pixels.
+ /// <remarks>
+ /// A positive value will make the characters far apart (expanded) and a negative value will bring them closer (condensed).<br />
+ /// The default value is 0.f which does nothing.
+ ///</remarks>
+ /// </summary>
+ [EditorBrowsable(EditorBrowsableState.Never)]
+ public float CharacterSpacing
+ {
+ get
+ {
+ return (float)GetValue(CharacterSpacingProperty);
+ }
+ set
+ {
+ SetValue(CharacterSpacingProperty, value);
+ NotifyPropertyChanged();
+ }
+ }
+
+ /// <summary>
/// Dispose.
/// </summary>
/// <since_tizen> 3 </since_tizen>
return;
}
- if (systemlangTextFlag)
+ internalPlaceholderTextColor?.Dispose();
+ internalPrimaryCursorColor?.Dispose();
+ internalSecondaryCursorColor?.Dispose();
+ internalSelectionHighlightColor?.Dispose();
+ internalInputColor?.Dispose();
+ internalTextColor?.Dispose();
+ internalGrabHandleColor?.Dispose();
+
+ if (hasSystemLanguageChanged)
{
- SystemSettings.LocaleLanguageChanged -= SystemSettings_LocaleLanguageChanged;
+ systemLocaleLanguageChanged.Remove(SystemSettings_LocaleLanguageChanged);
}
- removeFontSizeChangedCallback();
+ RemoveSystemSettingsFontTypeChanged();
+ RemoveSystemSettingsFontSizeChanged();
//Release your own unmanaged resources here.
//You should not access any managed member here except static instance.
this.MaxLengthReachedSignal().Disconnect(textEditorMaxLengthReachedCallbackDelegate);
}
+ if (textEditorSelectionStartedCallbackDelegate != null)
+ {
+ this.SelectionStartedSignal().Disconnect(textEditorSelectionStartedCallbackDelegate);
+ }
+
if (textEditorSelectionClearedCallbackDelegate != null)
{
this.SelectionClearedSignal().Disconnect(textEditorSelectionClearedCallbackDelegate);
}
}
+ TextChanged -= TextEditorTextChanged;
+ GetInputMethodContext()?.DestroyContext();
+
base.Dispose(type);
}
[EditorBrowsable(EditorBrowsableState.Never)]
protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
{
- // In order to speed up IME hide, temporarily add
- GetInputMethodContext()?.DestroyContext();
Interop.TextEditor.DeleteTextEditor(swigCPtr);
}
+ internal override LayoutItem CreateDefaultLayout()
+ {
+ return new TextEditorLayout();
+ }
+
+ internal void SetTextWithoutTextChanged(string text)
+ {
+ invokeTextChanged = false;
+ Tizen.NUI.Object.SetProperty((System.Runtime.InteropServices.HandleRef)SwigCPtr, TextEditor.Property.TEXT, new Tizen.NUI.PropertyValue(text));
+ invokeTextChanged = true;
+ }
+
private string SetTranslatable(string textEditorSid)
{
string translatableText = null;
translatableText = NUIApplication.MultilingualResourceManager?.GetString(textEditorSid, new CultureInfo(SystemSettings.LocaleLanguage.Replace("_", "-")));
if (translatableText != null)
{
- if (systemlangTextFlag == false)
+ if (hasSystemLanguageChanged == false)
{
- SystemSettings.LocaleLanguageChanged += SystemSettings_LocaleLanguageChanged;
- systemlangTextFlag = true;
+ systemLocaleLanguageChanged.Add(SystemSettings_LocaleLanguageChanged);
+ hasSystemLanguageChanged = true;
}
return translatableText;
}
private void SystemSettingsFontSizeChanged(object sender, FontSizeChangedEventArgs e)
{
float newFontSizeScale = TextUtils.GetFontSizeScale(e.Value);
- SetValue(FontSizeScaleProperty, newFontSizeScale);
- NotifyPropertyChanged();
+ SetInternalFontSizeScale(newFontSizeScale);
}
- private void addFontSizeChangedCallback()
+ private void AddSystemSettingsFontSizeChanged()
{
- if (hasFontSizeChangedCallback != true)
+ if (hasSystemFontSizeChanged != true)
{
try
{
- SystemSettings.FontSizeChanged += SystemSettingsFontSizeChanged;
- hasFontSizeChangedCallback = true;
+ SystemFontSizeChangedManager.Add(SystemSettingsFontSizeChanged);
+ hasSystemFontSizeChanged = true;
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
- hasFontSizeChangedCallback = false;
+ hasSystemFontSizeChanged = false;
}
}
}
- private void removeFontSizeChangedCallback()
+ private void RemoveSystemSettingsFontSizeChanged()
{
- if (hasFontSizeChangedCallback == true)
+ if (hasSystemFontSizeChanged == true)
{
try
{
- SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
- hasFontSizeChangedCallback = false;
+ SystemFontSizeChangedManager.Remove(SystemSettingsFontSizeChanged);
+ hasSystemFontSizeChanged = false;
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
- hasFontSizeChangedCallback = true;
+ hasSystemFontSizeChanged = true;
}
}
}
+ private void SystemSettingsFontTypeChanged(object sender, FontTypeChangedEventArgs e)
+ {
+ SetInternalFontFamily(e.Value);
+ }
+
+ private void AddSystemSettingsFontTypeChanged()
+ {
+ if (HasStyle() && !hasSystemFontTypeChanged)
+ {
+ try
+ {
+ systemFontTypeChanged.Add(SystemSettingsFontTypeChanged);
+ hasSystemFontTypeChanged = true;
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("{0} Exception caught.", e);
+ hasSystemFontTypeChanged = false;
+ }
+ }
+ }
+
+ private void RemoveSystemSettingsFontTypeChanged()
+ {
+ if (hasSystemFontTypeChanged)
+ {
+ try
+ {
+ systemFontTypeChanged.Remove(SystemSettingsFontTypeChanged);
+ hasSystemFontTypeChanged = false;
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("{0} Exception caught.", e);
+ hasSystemFontTypeChanged = true;
+ }
+ }
+ }
+
+ private void TextEditorTextChanged(object sender, TextChangedEventArgs e)
+ {
+ if (!isSettingTextInCSharp)
+ {
+ EnforceNotifyBindedInstance(TextProperty);
+ }
+ }
+
internal new class Property
{
internal static readonly int TEXT = Interop.TextEditor.TextGet();
internal static readonly int FontStyle = Interop.TextEditor.FontStyleGet();
internal static readonly int PointSize = Interop.TextEditor.PointSizeGet();
internal static readonly int HorizontalAlignment = Interop.TextEditor.HorizontalAlignmentGet();
+ internal static readonly int VerticalAlignment = Interop.TextEditor.VerticalAlignmentGet();
internal static readonly int ScrollThreshold = Interop.TextEditor.ScrollThresholdGet();
internal static readonly int ScrollSpeed = Interop.TextEditor.ScrollSpeedGet();
internal static readonly int PrimaryCursorColor = Interop.TextEditor.PrimaryCursorColorGet();
internal static readonly int CursorWidth = Interop.TextEditor.CursorWidthGet();
internal static readonly int GrabHandleImage = Interop.TextEditor.GrabHandleImageGet();
internal static readonly int GrabHandlePressedImage = Interop.TextEditor.GrabHandlePressedImageGet();
+ internal static readonly int SelectionPopupStyle = Interop.TextEditor.SelectionPopupStyleGet();
internal static readonly int SelectionHandleImageLeft = Interop.TextEditor.SelectionHandleImageLeftGet();
internal static readonly int SelectionHandleImageRight = Interop.TextEditor.SelectionHandleImageRightGet();
internal static readonly int SelectionHandlePressedImageLeft = Interop.TextEditor.SelectionHandlePressedImageLeftGet();
internal static readonly int InputPointSize = Interop.TextEditor.InputPointSizeGet();
internal static readonly int LineSpacing = Interop.TextEditor.LineSpacingGet();
internal static readonly int InputLineSpacing = Interop.TextEditor.InputLineSpacingGet();
+ internal static readonly int RelativeLineHeight = Interop.TextEditor.RelativeLineHeightGet();
internal static readonly int UNDERLINE = Interop.TextEditor.UnderlineGet();
internal static readonly int InputUnderline = Interop.TextEditor.InputUnderlineGet();
internal static readonly int SHADOW = Interop.TextEditor.ShadowGet();
internal static readonly int VerticalScrollPosition = Interop.TextEditor.VerticalScrollPositionGet();
internal static readonly int PrimaryCursorPosition = Interop.TextEditor.PrimaryCursorPositionGet();
internal static readonly int FontSizeScale = Interop.TextEditor.FontSizeScaleGet();
+ internal static readonly int EnableFontSizeScale = Interop.TextEditor.EnableFontSizeScaleGet();
internal static readonly int GrabHandleColor = Interop.TextEditor.GrabHandleColorGet();
internal static readonly int EnableGrabHandle = Interop.TextEditor.EnableGrabHandleGet();
internal static readonly int EnableGrabHandlePopup = Interop.TextEditor.EnableGrabHandlePopupGet();
internal static readonly int EllipsisPosition = Interop.TextEditor.EllipsisPositionGet();
internal static readonly int MinLineSize = Interop.TextEditor.MinLineSizeGet();
internal static readonly int InputFilter = Interop.TextEditor.InputFilterGet();
+ internal static readonly int Strikethrough = Interop.TextEditor.StrikethroughGet();
+ internal static readonly int CharacterSpacing = Interop.TextEditor.CharacterSpacingGet();
}
internal class InputStyle
{
GrabHandleColor = new Color(r, g, b, a);
}
+
+ private class TextEditorLayout : LayoutItem
+ {
+ protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
+ {
+ // Padding will be automatically applied by DALi TextEditor.
+ var totalWidth = widthMeasureSpec.Size.AsDecimal();
+ var totalHeight = heightMeasureSpec.Size.AsDecimal();
+ var minSize = Owner.MinimumSize;
+ var maxSize = Owner.MaximumSize;
+ var naturalSize = Owner.GetNaturalSize();
+
+ if (((TextEditor)Owner).Text.Length == 0)
+ {
+ // Calculate height of TextEditor by setting Text with " ".
+ // By calling SetTextWithoutTextChanged, TextChanged callback is not called for this.
+ ((TextEditor)Owner).SetTextWithoutTextChanged(" ");
+
+ // Store original WidthSpecification to restore it after setting ResizePolicy.
+ var widthSpecification = Owner.WidthSpecification;
+
+ // In DALi's Size logic, if Width or Height is set to be 0, then
+ // ResizePolicy is not changed to Fixed.
+ // This causes Size changes after NUI Layout's OnMeasure is finished.
+ // e.g. TextEditor's Width fills to its parent although Text is null and
+ // WidthSpecification is WrapContent.
+ // To prevent the Size changes, WidthResizePolicy is set to be Fixed
+ // in advance if Text is null.
+ Owner.WidthResizePolicy = ResizePolicyType.Fixed;
+
+ // Restore WidthSpecification because ResizePolicy changes WidthSpecification.
+ Owner.WidthSpecification = widthSpecification;
+
+ naturalSize = Owner.GetNaturalSize();
+
+ // Restore TextEditor's Text after calculating height of TextEditor.
+ // By calling SetTextWithoutTextChanged, TextChanged callback is not called for this.
+ ((TextEditor)Owner).SetTextWithoutTextChanged("");
+ }
+
+ if (widthMeasureSpec.Mode != MeasureSpecification.ModeType.Exactly)
+ {
+ float width = naturalSize != null ? naturalSize.Width : 0;
+ totalWidth = Math.Min(Math.Max(width, minSize.Width), maxSize.Width);
+ }
+
+ if (heightMeasureSpec.Mode != MeasureSpecification.ModeType.Exactly)
+ {
+ float height = naturalSize != null ? naturalSize.Height : 0;
+ totalHeight = Math.Min(Math.Max(height, minSize.Height), maxSize.Height);
+ }
+
+ widthMeasureSpec = new MeasureSpecification(new LayoutLength(totalWidth), MeasureSpecification.ModeType.Exactly);
+ heightMeasureSpec = new MeasureSpecification(new LayoutLength(totalHeight), MeasureSpecification.ModeType.Exactly);
+
+ MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK;
+ MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK;
+
+ SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, childWidthState),
+ ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, childHeightState));
+ }
+ }
}
}
projects / platform / core / csapi / tizenfx.git / blobdiff