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>
}
set
{
- SetValueAndForceSendChangeSignal(TextProperty, value);
+ SetValue(TextProperty, value);
NotifyPropertyChanged();
}
}
}
}
+ 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.<br />
/// The requested font style to use.<br />
/// The size of font in points.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
+ [Binding.TypeConverter(typeof(PointSizeTypeConverter))]
public float PointSize
{
get
}
/// <summary>
+ /// 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>
}
/// <summary>
+ /// 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 />
/// 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 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 />
/// The size of font in pixels.<br />
/// </summary>
/// <since_tizen> 3 </since_tizen>
+ [Binding.TypeConverter(typeof(FloatGraphicsTypeConverter))]
public float PixelSize
{
get
using (var propertyValue = GetProperty(TextEditor.Property.SelectedText))
{
propertyValue.Get(out selectedText);
- }
+ }
return selectedText;
}
}
using (var propertyValue = GetProperty(TextEditor.Property.SelectedTextStart))
{
propertyValue.Get(out selectedTextStart);
- }
+ }
return selectedTextStart;
}
}
using (var propertyValue = GetProperty(TextEditor.Property.SelectedTextEnd))
{
propertyValue.Get(out selectedTextEnd);
- }
+ }
return selectedTextEnd;
}
}
}
/// <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
}
/// <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>
/// The Placeholder property.
/// The placeholder map contains the following keys :<br />
/// <list type="table">
if (TextMapHelper.IsValue(map, 1))
map.Add("textFocused", TextMapHelper.GetStringFromMap(map, 1, defalutText));
-
+
if (TextMapHelper.IsValue(map, 2))
{
using (var color = TextMapHelper.GetColorFromMap(map, 2))
map.Add("color", color);
}
}
-
+
if (TextMapHelper.IsValue(map, 3))
map.Add("fontFamily", TextMapHelper.GetStringFromMap(map, 3, defalutText));
if (TextMapHelper.IsValue(map, 5))
map.Add("pointSize", TextMapHelper.GetNullableFloatFromMap(map, 5));
-
+
if (TextMapHelper.IsValue(map, 6))
map.Add("pixelSize", TextMapHelper.GetNullableFloatFromMap(map, 6));
-
+
if (TextMapHelper.IsValue(map, 7))
map.Add("ellipsis", TextMapHelper.GetBoolFromMap(map, 7, false));
}
}
- /// 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 />
- /// 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
+ private float InternalFontSizeScale
{
get
{
systemSettingsFontSize = SystemSettingsFontSize.Normal;
}
newFontSizeScale = TextUtils.GetFontSizeScale(systemSettingsFontSize);
- addFontSizeChangedCallback();
+ AddSystemSettingsFontSizeChanged();
}
else
{
newFontSizeScale = fontSizeScale;
- removeFontSizeChangedCallback();
+ RemoveSystemSettingsFontSizeChanged();
}
- SetValue(FontSizeScaleProperty, newFontSizeScale);
- NotifyPropertyChanged();
+ 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)
/// 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>
+ /// 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 (hasSystemFontSizeChanged == true)
+ {
+ try
+ {
+ SystemFontSizeChangedManager.Remove(SystemSettingsFontSizeChanged);
+ hasSystemFontSizeChanged = false;
+ }
+ catch (Exception e)
+ {
+ Console.WriteLine("{0} Exception caught.", e);
+ 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 (hasFontSizeChangedCallback == true)
+ if (hasSystemFontTypeChanged)
{
try
{
- SystemSettings.FontSizeChanged -= SystemSettingsFontSizeChanged;
- hasFontSizeChangedCallback = false;
+ systemFontTypeChanged.Remove(SystemSettingsFontTypeChanged);
+ hasSystemFontTypeChanged = false;
}
catch (Exception e)
{
Console.WriteLine("{0} Exception caught.", e);
- hasFontSizeChangedCallback = true;
+ 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 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