/// <summary> /// Measure the layout and its content to determine the measured width and the measured height.<br /> /// </summary> /// <param name="widthMeasureSpec">horizontal space requirements as imposed by the parent.</param> /// <param name="heightMeasureSpec">vertical space requirements as imposed by the parent.</param> /// <since_tizen> 6 </since_tizen> protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec) { // Ensure layout respects it's given minimum size float maxWidth = SuggestedMinimumWidth.AsDecimal(); float maxHeight = SuggestedMinimumHeight.AsDecimal(); MeasuredSize.StateType childWidthState = MeasuredSize.StateType.MeasuredSizeOK; MeasuredSize.StateType childHeightState = MeasuredSize.StateType.MeasuredSizeOK; foreach (LayoutItem childLayout in IterateLayoutChildren()) { // Get size of child with no padding, no margin. we won't support margin, padding for AbsolutLayout. MeasureChildWithoutPadding(childLayout, widthMeasureSpec, heightMeasureSpec); // Determine the width and height needed by the children using their given position and size. // Children could overlap so find the right most child. Position2D childPosition = childLayout.Owner.Position2D; float childRight = childLayout.MeasuredWidth.Size.AsDecimal() + childPosition.X; float childBottom = childLayout.MeasuredHeight.Size.AsDecimal() + childPosition.Y; if (maxWidth < childRight) { maxWidth = childRight; } if (maxHeight < childBottom) { maxHeight = childBottom; } if (childLayout.MeasuredWidth.State == MeasuredSize.StateType.MeasuredSizeTooSmall) { childWidthState = MeasuredSize.StateType.MeasuredSizeTooSmall; } if (childLayout.MeasuredHeight.State == MeasuredSize.StateType.MeasuredSizeTooSmall) { childHeightState = MeasuredSize.StateType.MeasuredSizeTooSmall; } } SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(maxWidth), widthMeasureSpec, childWidthState), ResolveSizeAndState(new LayoutLength(maxHeight), heightMeasureSpec, childHeightState)); }
public NUIApplication(Graphics.BackendType backend, WindowMode windowMode = WindowMode.Opaque, Size2D windowSize = null, Position2D windowPosition = null, string styleSheet = "") : base(new NUICoreBackend(styleSheet, windowMode, windowSize, windowPosition)) { //windowMode and styleSheet will be added later. currenlty it's not working as expected. Graphics.Backend = backend; Tizen.Log.Error("NUI", "Plaese DO NOT set graphical backend type with this constructor! This will give no effect!"); if (windowSize != null) { _windowSize2D = windowSize; } if (windowPosition != null) { _windowPosition2D = windowPosition; } Registry.Instance.SavedApplicationThread = Thread.CurrentThread; me = this; // TODO Enable this after tizen-theme-manager is released. // themeLoader.ThemeChanged += TizenThemeChanged; }
protected override void OnLayout(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom) { // Absolute layout positions it's children at their Actor positions. // Children could overlap or spill outside the parent, as is the nature of absolute positions. foreach (LayoutItem childLayout in _children) { if (childLayout != null) { LayoutLength childWidth = childLayout.MeasuredWidth.Size; LayoutLength childHeight = childLayout.MeasuredHeight.Size; Position2D childPosition = childLayout.Owner.Position2D; LayoutLength childLeft = new LayoutLength(childPosition.X); LayoutLength childTop = new LayoutLength(childPosition.Y); childLayout.Layout(childLeft, childTop, childLeft + childWidth, childTop + childHeight); } } }
protected void LayoutForIndependentChild() { int count = LayoutChildren.Count; for (int childIndex = 0; childIndex < count; childIndex++) { LayoutItem childLayout = LayoutChildren[childIndex]; if (childLayout != null) { if (childLayout.Owner.ExcludeLayouting) { LayoutLength childWidth = childLayout.MeasuredWidth.Size; LayoutLength childHeight = childLayout.MeasuredHeight.Size; Position2D childPosition = childLayout.Owner.Position2D; LayoutLength childPositionX = new LayoutLength(childPosition.X); LayoutLength childPositionY = new LayoutLength(childPosition.Y); childLayout.Layout(childPositionX, childPositionY, childPositionX + childWidth, childPositionY + childHeight, true); } } } }
// Starts of the actual measuring and layouting from the given root node. // Can be called from multiple starting roots but in series. void MeasureAndLayout(View root) { if (root !=null) { // Get parent MeasureSpecification, this could be the Window or View with an exact size. Container parentNode = root.GetParent(); Size2D rootSize; Position2D rootPosition = root.Position2D; View parentView = parentNode as View; if (parentView) { // Get parent View's Size. If using Legacy size negotiation then should have been set already. rootSize = new Size2D(parentView.Size2D.Width, parentView.Size2D.Height); } else { // Parent not a View so assume it's a Layer which is the size of the window. rootSize = new Size2D(_window.Size.Width, _window.Size.Height); } // Determine measure specification for root. // The root layout policy could be an exact size, be match parent or wrap children. // If wrap children then at most it can be the root parent size. // If match parent then should be root parent size. // If exact then should be that size limited by the root parent size. LayoutLength width = new LayoutLength(rootSize.Width); LayoutLength height = new LayoutLength(rootSize.Height); MeasureSpecification.ModeType widthMode = MeasureSpecification.ModeType.AtMost; MeasureSpecification.ModeType heightMode = MeasureSpecification.ModeType.AtMost; if (root.WidthSpecification >= 0 ) { // exact size provided so match width exactly width = new LayoutLength(root.WidthSpecification); widthMode = MeasureSpecification.ModeType.Exactly; } else if (root.WidthSpecification == LayoutParamPolicies.MatchParent) { widthMode = MeasureSpecification.ModeType.Exactly; } if (root.HeightSpecification >= 0 ) { // exact size provided so match height exactly height = new LayoutLength(root.HeightSpecification); heightMode = MeasureSpecification.ModeType.Exactly; } else if (root.HeightSpecification == LayoutParamPolicies.MatchParent) { heightMode = MeasureSpecification.ModeType.Exactly; } MeasureSpecification parentWidthSpecification = new MeasureSpecification( width, widthMode); MeasureSpecification parentHeightSpecification = new MeasureSpecification( height, heightMode); // Start at root with it's parent's widthSpecification and heightSpecification MeasureHierarchy(root, parentWidthSpecification, parentHeightSpecification); // Start at root which was just measured. PerformLayout( root, new LayoutLength(rootPosition.X), new LayoutLength(rootPosition.Y), new LayoutLength(rootPosition.X) + root.Layout.MeasuredWidth.Size, new LayoutLength(rootPosition.Y) + root.Layout.MeasuredHeight.Size ); } }
/// <summary> /// The constructor with stylesheet, window mode, window size and window position. /// </summary> public NUICoreBackend(string stylesheet, NUIApplication.WindowMode windowMode, Size2D windowSize, Position2D windowPosition) { this.stylesheet = stylesheet; this.windowMode = windowMode; if (windowSize != null && windowPosition != null) { this.windowRectangle = new Rectangle(windowPosition.X, windowPosition.Y, windowSize.Width, windowSize.Height); } }
public NUIApplication(Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend("", WindowMode.Opaque, windowSize, windowPosition)) { Registry.Instance.SavedApplicationThread = Thread.CurrentThread; _windowSize2D = windowSize; _windowPosition2D = windowPosition; }
public NUIApplication(Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend("", NUIApplication.WindowMode.Opaque, windowSize, windowPosition)) { ExternalThemeManager.Initialize(); }
public NUIApplication(Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend("", NUIApplication.WindowMode.Opaque, windowSize, windowPosition)) { }
public NUIApplication(Graphics.BackendType backend, WindowMode windowMode = WindowMode.Opaque, Size2D windowSize = null, Position2D windowPosition = null, string styleSheet = "") : base(new NUICoreBackend(styleSheet, windowMode, windowSize, windowPosition)) { //windowMode and styleSheet will be added later. currently it's not working as expected. Graphics.Backend = backend; Tizen.Log.Error("NUI", "Plaese DO NOT set graphical backend type with this constructor! This will give no effect!"); }
private Position2D Divide(Position2D rhs) { Position2D ret = new Position2D(NDalicPINVOKE.Vector2_Divide__SWIG_0(swigCPtr, Position2D.getCPtr(rhs)), true); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
public NUIApplication(string styleSheet, WindowMode windowMode, Size2D windowSize, Position2D windowPosition, WindowType type) : base(new NUICoreBackend(styleSheet, windowMode, windowSize, windowPosition, type)) { ExternalThemeManager.Initialize(); }
/// <summary> /// Internal constructor with Graphics Backend Type /// </summary> /// <param name="backend"></param> /// <param name="windowMode"></param> /// <param name="windowSize"></param> /// <param name="windowPosition"></param> /// <param name="styleSheet"></param> internal NUIApplication(Graphics.BackendType backend, WindowMode windowMode = WindowMode.Opaque, Size2D windowSize = null, Position2D windowPosition = null, string styleSheet = "") : base(new NUICoreBackend(styleSheet, windowMode)) { //windowMode and styleSheet will be added later. currenlty it's not working as expected. Graphics.Backend = backend; if (windowSize != null) { _windowSize2D = windowSize; } if (windowPosition != null) { _windowPosition2D = windowPosition; } Registry.Instance.SavedApplicationThread = Thread.CurrentThread; }
public NUIApplication(string styleSheet, Size2D windowSize, Position2D windowPosition, IBorderInterface borderInterface, WindowMode windowMode = WindowMode.Opaque) : base(new NUICoreBackend(styleSheet, windowMode, windowSize, windowPosition)) { borderEnabled = true; this.borderInterface = borderInterface; }
public NUIApplication(string styleSheet, WindowMode windowMode, Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend(styleSheet, windowMode, windowSize, windowPosition)) { Registry.Instance.SavedApplicationThread = Thread.CurrentThread; // TODO Enable this after tizen-theme-manager is released. // themeLoader.ThemeChanged += TizenThemeChanged; _windowSize2D = windowSize; _windowPosition2D = windowPosition; me = this; }
public NUIApplication(string styleSheet, Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend(styleSheet)) { Registry.Instance.SavedApplicationThread = Thread.CurrentThread; _windowSize2D = windowSize; _windowPosition2D = windowPosition; }
private Position2D Multiply(Position2D rhs) { Position2D ret = new Position2D(Interop.Vector2.Vector2_Multiply__SWIG_0(swigCPtr, Position2D.getCPtr(rhs)), true); if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } return(ret); }
protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec) { float totalHeight = 0.0f; float totalWidth = 0.0f; HeightAndWidthState childState = new HeightAndWidthState(MeasuredSize.StateType.MeasuredSizeOK, MeasuredSize.StateType.MeasuredSizeOK); float minPositionX = 0.0f; float minPositionY = 0.0f; float maxPositionX = 0.0f; float maxPositionY = 0.0f; // measure children foreach (LayoutItem childLayout in _children) { if (childLayout != null) { // Get size of child MeasureChild(childLayout, widthMeasureSpec, heightMeasureSpec); float childWidth = childLayout.MeasuredWidth.Size.AsDecimal(); float childHeight = childLayout.MeasuredHeight.Size.AsDecimal(); // Determine the width and height needed by the children using their given position and size. // Children could overlap so find the left most and right most child. Position2D childPosition = childLayout.Owner.Position2D; float childLeft = childPosition.X; float childTop = childPosition.Y; minPositionX = Math.Min(minPositionX, childLeft); maxPositionX = Math.Max(maxPositionX, childLeft + childWidth); // Children could overlap so find the highest and lowest child. minPositionY = Math.Min(minPositionY, childTop); maxPositionY = Math.Max(maxPositionY, childTop + childHeight); // Store current width and height needed to contain all children. totalWidth = maxPositionX - minPositionX; totalHeight = maxPositionY - minPositionY; if (childLayout.MeasuredWidthAndState.State == MeasuredSize.StateType.MeasuredSizeTooSmall) { childState.widthState = MeasuredSize.StateType.MeasuredSizeTooSmall; } if (childLayout.MeasuredWidthAndState.State == MeasuredSize.StateType.MeasuredSizeTooSmall) { childState.heightState = MeasuredSize.StateType.MeasuredSizeTooSmall; } } } MeasuredSize widthSizeAndState = ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK); MeasuredSize heightSizeAndState = ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, MeasuredSize.StateType.MeasuredSizeOK); totalWidth = widthSizeAndState.Size.AsDecimal(); totalHeight = heightSizeAndState.Size.AsDecimal(); // Ensure layout respects it's given minimum size totalWidth = Math.Max(totalWidth, SuggestedMinimumWidth.AsDecimal()); totalHeight = Math.Max(totalHeight, SuggestedMinimumHeight.AsDecimal()); widthSizeAndState.State = childState.widthState; heightSizeAndState.State = childState.heightState; SetMeasuredDimensions(ResolveSizeAndState(new LayoutLength(totalWidth), widthMeasureSpec, childState.widthState), ResolveSizeAndState(new LayoutLength(totalHeight), heightMeasureSpec, childState.heightState)); }
internal static global::System.Runtime.InteropServices.HandleRef getCPtr(Position2D obj) { return((obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr); }
/// <summary> /// Creates a Position2D property value. /// </summary> /// <param name="vectorValue">Position2D values.</param> /// <since_tizen> 3 </since_tizen> public PropertyValue(Position2D vectorValue) : this(Interop.PropertyValue.NewPropertyValueVector2(Position2D.getCPtr(vectorValue)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } }
public NUIApplication(Size2D windowSize, Position2D windowPosition, ThemeOptions option) : base(new NUICoreBackend("", NUIApplication.WindowMode.Opaque, windowSize, windowPosition)) { ApplyThemeOption(option); }
/// <summary> /// The constructor. /// </summary> /// <param name="position2d">Position2D to create this vector from.</param> /// <since_tizen> 3 </since_tizen> public Position(Position2D position2d) : this(Interop.Vector3.new_Vector3__SWIG_3(Position2D.getCPtr(position2d)), true) { if (NDalicPINVOKE.SWIGPendingException.Pending) { throw NDalicPINVOKE.SWIGPendingException.Retrieve(); } }
public NUIApplication(string styleSheet, Size2D windowSize, Position2D windowPosition) : base(new NUICoreBackend(styleSheet, WindowMode.Opaque, windowSize, windowPosition)) { }
/// <summary> /// The constructor with stylesheet, window mode, window size and window position. /// </summary> public NUICoreBackend(string stylesheet, NUIApplication.WindowMode windowMode, Size2D windowSize, Position2D windowPosition) { _stylesheet = stylesheet; _windowMode = windowMode; _windowSize = windowSize; _windowPosition = windowPosition; }