src/Tizen.NUI/src/public/Layouting/FlexLayout.cs

   1 /* Copyright (c) 2021 Samsung Electronics Co., Ltd.
   2  *
   3  * Licensed under the Apache License, Version 2.0 (the "License");
   4  * you may not use this file except in compliance with the License.
   5  * You may obtain a copy of the License at
   6  *
   7  * http://www.apache.org/licenses/LICENSE-2.0
   8  *
   9  * Unless required by applicable law or agreed to in writing, software
  10  * distributed under the License is distributed on an "AS IS" BASIS,
  11  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12  * See the License for the specific language governing permissions and
  13  * limitations under the License.
  14  *
  15  */
  16
  17 using System;
  18 using System.ComponentModel;
  19 using Tizen.NUI.BaseComponents;
  20 using System.Runtime.InteropServices;
  21 using System.Diagnostics;
  22 using Tizen.NUI.Binding;
  23
  24 namespace Tizen.NUI
  25 {
  26     /// <summary>
  27     /// This class implements a flex layout.
  28     /// The flex layout implementation is based on open source Facebook Yoga layout engine.
  29     /// For more information about the flex layout API and how to use it please refer to https://yogalayout.com/docs/
  30     /// We implement the subset of the API in the class below.
  31     /// </summary>
  32     public class FlexLayout : LayoutGroup
  33     {
  34         /// <summary>
  35         /// FlexItemProperty
  36         /// </summary>
  37         [EditorBrowsable(EditorBrowsableState.Never)]
  38         internal static readonly BindableProperty FlexItemProperty = BindableProperty.CreateAttached("FlexItem", typeof(HandleRef), typeof(FlexLayout), default(HandleRef));
  39
  40         /// <summary>
  41         /// FlexAlignmentSelfProperty
  42         /// </summary>
  43         [EditorBrowsable(EditorBrowsableState.Never)]
  44         public static readonly BindableProperty FlexAlignmentSelfProperty = BindableProperty.CreateAttached("FlexAlignmentSelf", typeof(AlignmentType), typeof(FlexLayout), AlignmentType.Auto, validateValue: ValidateEnum((int)AlignmentType.Auto, (int)AlignmentType.Stretch), propertyChanged: OnChildPropertyChanged);
  45
  46         /// <summary>
  47         /// FlexPositionTypeProperty
  48         /// </summary>
  49         [EditorBrowsable(EditorBrowsableState.Never)]
  50         public static readonly BindableProperty FlexPositionTypeProperty = BindableProperty.CreateAttached("FlexPositionType", typeof(PositionType), typeof(FlexLayout), PositionType.Relative, validateValue: ValidateEnum((int)PositionType.Relative, (int)PositionType.Absolute),
  51         propertyChanged: (bindable, oldValue, newValue) =>
  52         {
  53             if (bindable is View view)
  54             {
  55                 view.ExcludeLayouting = (PositionType)newValue == PositionType.Absolute;
  56             }
  57         },
  58         defaultValueCreator: (bindable) =>
  59         {
  60             var view = (View)bindable;
  61             if (view.ExcludeLayouting)
  62                 return PositionType.Absolute;
  63
  64             return PositionType.Relative;
  65         });
  66
  67
  68         /// <summary>
  69         /// AspectRatioProperty
  70         /// </summary>
  71         [EditorBrowsable(EditorBrowsableState.Never)]
  72         public static readonly BindableProperty FlexAspectRatioProperty = BindableProperty.CreateAttached("FlexAspectRatio", typeof(float), typeof(FlexLayout), FlexUndefined, validateValue: (bindable, value) => (float)value > 0, propertyChanged: OnChildPropertyChanged);
  73
  74         /// <summary>
  75         /// FlexBasisProperty
  76         /// </summary>
  77         [EditorBrowsable(EditorBrowsableState.Never)]
  78         public static readonly BindableProperty FlexBasisProperty = BindableProperty.CreateAttached("FlexBasis", typeof(float), typeof(FlexLayout), FlexUndefined, validateValue: (bindable, value) => (float)value >= 0, propertyChanged: OnChildPropertyChanged);
  79
  80         /// <summary>
  81         /// FlexShrinkProperty
  82         /// </summary>
  83         [EditorBrowsable(EditorBrowsableState.Never)]
  84         public static readonly BindableProperty FlexShrinkProperty = BindableProperty.CreateAttached("FlexShrink", typeof(float), typeof(FlexLayout), 1.0f, validateValue: (bindable, value) => (float)value >= 0, propertyChanged: OnChildPropertyChanged);
  85
  86         /// <summary>
  87         /// FlexGrowProperty
  88         /// </summary>
  89         [EditorBrowsable(EditorBrowsableState.Never)]
  90         public static readonly BindableProperty FlexGrowProperty = BindableProperty.CreateAttached("FlexGrow", typeof(float), typeof(FlexLayout), FlexUndefined, validateValue: (bindable, value) => (float)value >= 0, propertyChanged: OnChildPropertyChanged);
  91
  92         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  93         private bool swigCMemOwn;
  94         private bool disposed;
  95         private bool isDisposeQueued = false;
  96
  97         private MeasureSpecification parentMeasureSpecificationWidth;
  98         private MeasureSpecification parentMeasureSpecificationHeight;
  99
 100         private IntPtr _rootFlex;  // Pointer to the unmanaged flex layout class.
 101
 102         internal const float FlexUndefined = 10E20F; // Auto setting which is equivalent to WrapContent.
 103
 104         internal struct MeasuredSize
 105         {
 106             public MeasuredSize(float x, float y)
 107             {
 108                 width = x;
 109                 height = y;
 110             }
 111             public float width;
 112             public float height;
 113         };
 114
 115         /// <summary>
 116         /// Gets the alignment self of the child view.
 117         /// </summary>
 118         /// <seealso cref="SetFlexAlignmentSelf(View, AlignmentType)"/>
 119         /// <param name="view">The child view.</param>
 120         /// <returns> The value of alignment self.</returns>
 121         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 122         /// <since_tizen> 8 </since_tizen>
 123         public static AlignmentType GetFlexAlignmentSelf(View view) => GetAttachedValue<AlignmentType>(view, FlexAlignmentSelfProperty);
 124
 125         /// <summary>
 126         /// Gets the position type of the child view.
 127         /// </summary>
 128         /// <seealso cref="SetFlexPositionType(View, PositionType)"/>
 129         /// <param name="view">The child view.</param>
 130         /// <returns> The value of position type</returns>
 131         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 132         /// <since_tizen> 8 </since_tizen>
 133         public static PositionType GetFlexPositionType(View view) => GetAttachedValue<PositionType>(view, FlexPositionTypeProperty);
 134
 135         /// <summary>
 136         /// Gets the aspect ratio of the child view.
 137         /// </summary>
 138         /// <seealso cref="SetFlexAspectRatio(View, float)"/>
 139         /// <param name="view">The child view.</param>
 140         /// <returns> The value of aspect ratio</returns>
 141         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 142         /// <since_tizen> 8 </since_tizen>
 143         public static float GetFlexAspectRatio(View view) => GetAttachedValue<float>(view, FlexAspectRatioProperty);
 144
 145         /// <summary>
 146         /// Gets the basis of the child view.
 147         /// </summary>
 148         /// <seealso cref="SetFlexBasis(View, float)"/>
 149         /// <param name="view">The child view.</param>
 150         /// <returns> The value of basis</returns>
 151         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 152         /// <since_tizen> 8 </since_tizen>
 153         public static float GetFlexBasis(View view) => GetAttachedValue<float>(view, FlexBasisProperty);
 154
 155         /// <summary>
 156         /// Gets the shrink of the child view.
 157         /// </summary>
 158         /// <seealso cref="SetFlexShrink(View, float)"/>
 159         /// <param name="view">The child view.</param>
 160         /// <returns> The value of shrink</returns>
 161         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 162         /// <since_tizen> 8 </since_tizen>
 163         public static float GetFlexShrink(View view) => GetAttachedValue<float>(view, FlexShrinkProperty);
 164
 165         /// <summary>
 166         /// Gets the grow of the child view.
 167         /// </summary>
 168         /// <seealso cref="SetFlexGrow(View, float)"/>
 169         /// <param name="view">The child view.</param>
 170         /// <returns> The value of grow</returns>
 171         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 172         /// <since_tizen> 8 </since_tizen>
 173         public static float GetFlexGrow(View view) => GetAttachedValue<float>(view, FlexGrowProperty);
 174
 175         /// <summary>
 176         /// Sets the alignment self of the child view.<br/>
 177         /// Alignment self has the same options and effect as <see cref="ItemsAlignment"/> but instead of affecting the children within a container,
 178         /// you can apply this property to a single child to change its alignment within its parent.<br/>
 179         /// Alignment self overrides any option set by the parent with <see cref="ItemsAlignment"/>.
 180         /// </summary>
 181         /// <param name="view">The child view.</param>
 182         /// <param name="value">The value of alignment self.</param>
 183         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 184         /// <exception cref="ArgumentException">The <paramref name="value"/> should be <see cref="AlignmentType"/>.</exception>
 185         /// <since_tizen> 8 </since_tizen>
 186         public static void SetFlexAlignmentSelf(View view, AlignmentType value) => SetAttachedValue(view, FlexAlignmentSelfProperty, value);
 187
 188         /// <summary>
 189         /// Sets the position type of the child view.<br/>
 190         /// The position type of an element defines how it is positioned within its parent.
 191         /// By default a child is positioned relatively. This means a child is positioned according to the normal flow of the layout,
 192         /// and then offset relative to that position based on the values of <see cref="View.Margin"/>.<br/>
 193         /// When positioned absolutely an element doesn't take part in the normal layout flow.
 194         /// It is instead laid out independent of its siblings. The position is determined based on the <see cref="View.Margin"/>.
 195         /// </summary>
 196         /// <param name="view">The child view.</param>
 197         /// <param name="value">The value of position type.</param>
 198         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 199         /// <exception cref="ArgumentException">The <paramref name="value"/> should be <see cref="PositionType"/>.</exception>
 200         /// <since_tizen> 8 </since_tizen>
 201         public static void SetFlexPositionType(View view, PositionType value) => SetAttachedValue(view, FlexPositionTypeProperty, value);
 202
 203         /// <summary>
 204         /// Sets the aspect ratio of the child view.
 205         /// Aspect ratio Defines as the ratio between the width and the height of a node
 206         /// e.g. if a node has an aspect ratio of 2 then its width is twice the size of its height.<br/>
 207         /// Aspect ratio accepts any floating point value > 0. this has higher priority than flex grow.
 208         /// </summary>
 209         /// <param name="view">The child view.</param>
 210         /// <param name="value">The value of aspect ratio</param>
 211         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 212         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than or equal to 0.0f.</exception>
 213         /// <since_tizen> 8 </since_tizen>
 214         public static void SetFlexAspectRatio(View view, float value) => SetAttachedValue(view, FlexAspectRatioProperty, value);
 215
 216         /// <summary>
 217         /// Sets the flex basis of the child view.
 218         /// Flex basis is an axis-independent way of providing the default size of an item along the main axis.<br/>
 219         /// Setting the flex basis of a child is similar to setting the width of that child if its parent is a container with <see cref="FlexDirection.Row"/>
 220         /// or setting the height of a child if its parent is a container with <see cref="FlexDirection.Column"/>.<br/>
 221         /// The flex basis of an item is the default size of that item, the size of the item before any flex grow and flex shrink calculations are performed.
 222         /// </summary>
 223         /// <param name="view">The child view.</param>
 224         /// <param name="value">The value of basis</param>
 225         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 226         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 227         /// <since_tizen> 8 </since_tizen>
 228         public static void SetFlexBasis(View view, float value) => SetAttachedValue(view, FlexBasisProperty, value);
 229
 230         /// <summary>
 231         /// Sets the flex shrink of the child view.
 232         /// Flex shrink describes how to shrink children along the main axis in the case that the total size of the children overflow the size of the container on the main axis.<br/>
 233         /// Flex shrink is very similar to flex grow and can be thought of in the same way if any overflowing size is considered to be negative remaining space.
 234         /// These two properties also work well together by allowing children to grow and shrink as needed.<br/>
 235         /// Flex shrink accepts any floating point value >= 0, with 1 being the default value. A container will shrink its children weighted by the child's flex shrink value.
 236         /// </summary>
 237         /// <param name="view">The child view.</param>
 238         /// <param name="value">The value of shrink</param>
 239         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 240         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 241         /// <since_tizen> 8 </since_tizen>
 242         public static void SetFlexShrink(View view, float value) => SetAttachedValue(view, FlexShrinkProperty, value);
 243
 244         /// <summary>
 245         /// Sets the grow of the child view.
 246         /// Flex grow describes how any space within a container should be distributed among its children along the main axis.
 247         /// After laying out its children, a container will distribute any remaining space according to the flex grow values specified by its children.<br/>
 248         /// Flex grow accepts any floating point value >= 0, with 0 being the default value.<br/>
 249         /// A container will distribute any remaining space among its children weighted by the child's flex grow value.
 250         /// </summary>
 251         /// <param name="view">The child view.</param>
 252         /// <param name="value">The value of flex</param>
 253         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 254         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 255         /// <since_tizen> 8 </since_tizen>
 256         public static void SetFlexGrow(View view, float value) => SetAttachedValue(view, FlexGrowProperty, value);
 257
 258         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 259         internal delegate void ChildMeasureCallback(global::System.IntPtr child, float width, int measureModeWidth, float height, int measureModeHeight, out MeasuredSize measureSize);
 260
 261         event ChildMeasureCallback measureChildDelegate; // Stores a delegate to the child measure callback. Used for all children of this FlexLayout.
 262
 263         internal FlexLayout(global::System.IntPtr cPtr, bool cMemoryOwn)
 264         {
 265             swigCMemOwn = cMemoryOwn;
 266             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 267             _rootFlex = Interop.FlexLayout.New();
 268             measureChildDelegate = new ChildMeasureCallback(measureChild);
 269         }
 270
 271         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FlexLayout obj)
 272         {
 273             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 274         }
 275
 276         /// <summary>
 277         /// Hidden API (Inhouse API).
 278         /// Destructor.
 279         /// </summary>
 280         [EditorBrowsable(EditorBrowsableState.Never)]
 281         ~FlexLayout() => Dispose(false);
 282
 283         /// <inheritdoc/>
 284         /// <since_tizen> 6 </since_tizen>
 285         public new void Dispose()
 286         {
 287             Dispose(true);
 288             System.GC.SuppressFinalize(this);
 289         }
 290
 291         /// <summary>
 292         /// Hidden API (Inhouse API).
 293         /// Dispose.
 294         /// </summary>
 295         /// <remarks>
 296         /// Following the guide of https://docs.microsoft.com/en-us/dotnet/standard/garbage-collection/implementing-dispose.
 297         /// This will replace "protected virtual void Dispose(DisposeTypes type)" which is exactly same in functionality.
 298         /// </remarks>
 299         /// <param name="disposing">true in order to free managed objects</param>
 300         // Protected implementation of Dispose pattern.
 301         [EditorBrowsable(EditorBrowsableState.Never)]
 302         protected override void Dispose(bool disposing)
 303         {
 304             if (disposed)
 305             {
 306                 return;
 307             }
 308
 309             if (disposing)
 310             {
 311                 // TODO: dispose managed state (managed objects).
 312                 // Explicit call. user calls Dispose()
 313
 314                 //Throw exception if Dispose() is called in separate thread.
 315                 if (!Window.IsInstalled())
 316                 {
 317                     throw new System.InvalidOperationException("This API called from separate thread. This API must be called from MainThread.");
 318                 }
 319
 320                 if (isDisposeQueued)
 321                 {
 322                     Dispose(DisposeTypes.Implicit);
 323                 }
 324                 else
 325                 {
 326                     Dispose(DisposeTypes.Explicit);
 327                 }
 328             }
 329             else
 330             {
 331                 // Implicit call. user doesn't call Dispose(), so this object is added into DisposeQueue to be disposed automatically.
 332                 if (!isDisposeQueued)
 333                 {
 334                     isDisposeQueued = true;
 335                     DisposeQueue.Instance.Add(this);
 336                 }
 337             }
 338
 339             // TODO: free unmanaged resources (unmanaged objects) and override a finalizer below.
 340             // TODO: set large fields to null.
 341             base.Dispose(disposing);
 342         }
 343
 344         /// <inheritdoc/>
 345         /// <since_tizen> 6 </since_tizen>
 346         protected virtual void Dispose(DisposeTypes type)
 347         {
 348             if (disposed)
 349             {
 350                 return;
 351             }
 352
 353             if (type == DisposeTypes.Explicit)
 354             {
 355                 //Called by User
 356                 //Release your own managed resources here.
 357                 //You should release all of your own disposable objects here.
 358             }
 359
 360             //Release your own unmanaged resources here.
 361             //You should not access any managed member here except static instance.
 362             //because the execution order of Finalizes is non-deterministic.
 363             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 364             {
 365                 if (swigCMemOwn)
 366                 {
 367                     swigCMemOwn = false;
 368                     ReleaseSwigCPtr(swigCPtr);
 369                 }
 370                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 371             }
 372
 373             disposed = true;
 374         }
 375
 376         /// <summary>
 377         /// Hidden API (Inhouse API).
 378         /// Release swigCPtr.
 379         /// </summary>
 380         /// This will not be public opened.
 381         [EditorBrowsable(EditorBrowsableState.Never)]
 382         protected virtual void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
 383         {
 384             Interop.FlexLayout.DeleteFlexLayout(swigCPtr);
 385         }
 386
 387         /// <summary>
 388         /// Creates a FlexLayout object.
 389         /// </summary>
 390         /// <since_tizen> 6 </since_tizen>
 391         public FlexLayout() : this(Interop.FlexLayout.New(), true)
 392         {
 393             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 394         }
 395
 396         internal static FlexLayout DownCast(BaseHandle handle)
 397         {
 398             FlexLayout ret = new FlexLayout(Interop.FlexLayout.DownCast(BaseHandle.getCPtr(handle)), true);
 399             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 400             return ret;
 401         }
 402
 403         internal FlexLayout(FlexLayout other) : this(Interop.FlexLayout.NewFlexLayout(FlexLayout.getCPtr(other)), true)
 404         {
 405             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 406         }
 407
 408         internal FlexLayout.AlignmentType GetFlexAlignment()
 409         {
 410             FlexLayout.AlignmentType ret = (FlexLayout.AlignmentType)Interop.FlexLayout.GetFlexAlignment(swigCPtr);
 411             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 412             return ret;
 413         }
 414
 415         internal FlexLayout.AlignmentType GetFlexItemsAlignment()
 416         {
 417             FlexLayout.AlignmentType ret = (FlexLayout.AlignmentType)Interop.FlexLayout.GetFlexItemsAlignment(swigCPtr);
 418             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 419             return ret;
 420         }
 421
 422         /// <summary>
 423         /// Gets/Sets the flex direction in the layout.
 424         /// The direction of the main-axis which determines the direction that flex items are laid out.
 425         /// </summary>
 426         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 427         /// <since_tizen> 6 </since_tizen>
 428         public FlexDirection Direction
 429         {
 430             get => (FlexDirection)Interop.FlexLayout.GetFlexDirection(swigCPtr);
 431             set
 432             {
 433                 if (value < FlexDirection.Column || value > FlexDirection.RowReverse)
 434                     throw new InvalidEnumArgumentException(nameof(Direction));
 435
 436                 Interop.FlexLayout.SetFlexDirection(swigCPtr, (int)value);
 437                 RequestLayout();
 438             }
 439         }
 440
 441         /// <summary>
 442         /// Gets/Sets the justification in the layout.
 443         /// Justify content describes how to align children within the main axis of their container.<br/>
 444         /// For example, you can use this property to center a child horizontally within a container with <see cref="Direction"/> set to <see cref="FlexDirection.Row"/>
 445         /// or vertically within a container with <see cref="Direction"/> set to <see cref="FlexDirection.Column"/>.
 446         /// </summary>
 447         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 448         /// <since_tizen> 6 </since_tizen>
 449         public FlexJustification Justification
 450         {
 451             get => (FlexJustification)Interop.FlexLayout.GetFlexJustification(swigCPtr);
 452             set
 453             {
 454                 if (value < FlexJustification.FlexStart || value > FlexJustification.SpaceAround)
 455                     throw new InvalidEnumArgumentException(nameof(Justification));
 456
 457                 Interop.FlexLayout.SetFlexJustification(swigCPtr, (int)value);
 458                 RequestLayout();
 459             }
 460         }
 461
 462         /// <summary>
 463         /// Gets/Sets the wrap in the layout.
 464         /// The flex wrap property is set on containers and controls what happens when children overflow the size of the container along the main axis.<br/>
 465         /// By default children are forced into a single line (which can shrink elements).<br/>
 466         /// If wrapping is allowed items are wrapped into multiple lines along the main axis if needed. wrap reverse behaves the same, but the order of the lines is reversed.<br/>
 467         /// When wrapping lines <see cref="Alignment"/> can be used to specify how the lines are placed in the container.
 468         /// </summary>
 469         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 470         /// <since_tizen> 6 </since_tizen>
 471         public FlexWrapType WrapType
 472         {
 473             get => (FlexWrapType)Interop.FlexLayout.GetFlexWrap(swigCPtr);
 474             set
 475             {
 476                 if (value != FlexWrapType.NoWrap && value != FlexWrapType.Wrap)
 477                     throw new InvalidEnumArgumentException(nameof(WrapType));
 478
 479                 Interop.FlexLayout.SetFlexWrap(swigCPtr, (int)value);
 480                 RequestLayout();
 481
 482             }
 483         }
 484
 485         /// <summary>
 486         /// Gets/Sets the alignment of the layout content.
 487         /// Alignment defines the distribution of lines along the cross-axis.<br/>
 488         /// This only has effect when items are wrapped to multiple lines using flex wrap.
 489         /// </summary>
 490         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 491         /// <since_tizen> 6 </since_tizen>
 492         public AlignmentType Alignment
 493         {
 494             get => GetFlexAlignment();
 495             set
 496             {
 497                 if (value < AlignmentType.Auto || value > AlignmentType.Stretch)
 498                     throw new InvalidEnumArgumentException(nameof(Alignment));
 499
 500                 Interop.FlexLayout.SetFlexAlignment(swigCPtr, (int)value);
 501                 RequestLayout();
 502             }
 503         }
 504
 505         /// <summary>
 506         /// Gets/Sets the alignment of the layout items.
 507         /// Items alignment describes how to align children along the cross axis of their container.<br/>
 508         /// Align items is very similar to <see cref="Justification"/> but instead of applying to the main axis, align items applies to the cross axis.
 509         /// </summary>
 510         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 511         /// <since_tizen> 6 </since_tizen>
 512         public AlignmentType ItemsAlignment
 513         {
 514             get => GetFlexItemsAlignment();
 515             set
 516             {
 517                 if (value < AlignmentType.Auto || value > AlignmentType.Stretch)
 518                     throw new InvalidEnumArgumentException(nameof(ItemsAlignment));
 519
 520                 Interop.FlexLayout.SetFlexItemsAlignment(swigCPtr, (int)value);
 521                 RequestLayout();
 522             }
 523         }
 524
 525         /// <summary>
 526         /// Enumeration for the direction of the main axis in the flex container.
 527         /// This determines the direction that flex items are laid out in the flex container.
 528         /// </summary>
 529         /// <since_tizen> 6 </since_tizen>
 530         public enum FlexDirection
 531         {
 532             /// <summary>
 533             /// The flexible items are displayed vertically as a column
 534             /// </summary>
 535             Column,
 536             /// <summary>
 537             /// The flexible items are displayed vertically as a column, but in reverse order
 538             /// </summary>
 539             ColumnReverse,
 540             /// <summary>
 541             /// The flexible items are displayed horizontally as a row
 542             /// </summary>
 543             Row,
 544             /// <summary>
 545             /// The flexible items are displayed horizontally as a row, but in reverse order
 546             /// </summary>
 547             RowReverse
 548         }
 549
 550         /// <summary>
 551         /// Enumeration for the alignment of the flex items when the items do not use all available space on the main-axis.
 552         /// </summary>
 553         /// <since_tizen> 6 </since_tizen>
 554         public enum FlexJustification
 555         {
 556             /// <summary>
 557             /// Items are positioned at the beginning of the container.
 558             /// </summary>
 559             FlexStart,
 560             /// <summary>
 561             /// Items are positioned at the center of the container.
 562             /// </summary>
 563             Center,
 564             /// <summary>
 565             /// Items are positioned at the end of the container.
 566             /// </summary>
 567             FlexEnd,
 568             /// <summary>
 569             /// Items are positioned with equal space between the lines.
 570             /// </summary>
 571             SpaceBetween,
 572             /// <summary>
 573             /// Items are positioned with equal space before, between, and after the lines.<br/>
 574             /// Compared to <see cref="FlexJustification.SpaceBetween"/> using <see cref="FlexJustification.SpaceAround"/>
 575             /// will result in space being distributed to the beginning of the first child and end of the last child.
 576             /// </summary>
 577             SpaceAround
 578         }
 579
 580         /// <summary>
 581         /// Enumeration for the wrap type of the flex container when there is no enough room for all the items on one flex line.
 582         /// </summary>
 583         /// <since_tizen> 6 </since_tizen>
 584         public enum FlexWrapType
 585         {
 586             /// <summary>
 587             /// Flex items laid out in single line (shrunk to fit the flex container along the main axis)
 588             /// </summary>
 589             NoWrap,
 590             /// <summary>
 591             /// Flex items laid out in multiple lines if needed
 592             /// </summary>
 593             Wrap
 594         }
 595
 596         /// <summary>
 597         /// Enumeration for the alignment of the flex items or lines when the items or lines do not use all the available space on the cross-axis.
 598         /// </summary>
 599         /// <since_tizen> 6 </since_tizen>
 600         public enum AlignmentType
 601         {
 602             /// <summary>
 603             /// Inherits the same alignment from the parent
 604             /// </summary>
 605             Auto,
 606             /// <summary>
 607             /// At the beginning of the container
 608             /// </summary>
 609             FlexStart,
 610             /// <summary>
 611             /// At the center of the container
 612             /// </summary>
 613             Center,
 614             /// <summary>
 615             /// At the end of the container
 616             /// </summary>
 617             FlexEnd,
 618             /// <summary>
 619             /// Stretch to fit the container
 620             /// </summary>
 621             Stretch
 622         }
 623
 624         /// <summary>
 625         /// Enumeration for the position type of the flex item how it is positioned within its parent.
 626         /// </summary>
 627         /// <since_tizen> 8 </since_tizen>
 628         public enum PositionType
 629         {
 630             /// <summary>
 631             /// Flex items laid out relatively.
 632             /// </summary>
 633             Relative,
 634             /// <summary>
 635             /// Flex items laid out absolutely.
 636             /// </summary>
 637             Absolute
 638         }
 639
 640         private void measureChild(global::System.IntPtr childPtr, float width, int measureModeWidth, float height, int measureModeHeight, out MeasuredSize measureSize)
 641         {
 642             // We need to measure child layout
 643             View child = Registry.GetManagedBaseHandleFromNativePtr(childPtr) as View;
 644             // independent child will be measured in LayoutGroup.OnMeasureIndependentChildren().
 645             if ((child == null) || (child?.ExcludeLayouting ?? true))
 646             {
 647                 measureSize.width = 0;
 648                 measureSize.height = 0;
 649                 return;
 650             }
 651
 652             LayoutItem childLayout = child.Layout;
 653             Extents margin = child.Margin;
 654
 655             MeasureSpecification childWidthMeasureSpec = GetChildMeasureSpecification(
 656                                     new MeasureSpecification(
 657                                         new LayoutLength(parentMeasureSpecificationWidth.Size - (margin.Start + margin.End)),
 658                                         parentMeasureSpecificationWidth.Mode),
 659                                     new LayoutLength(Padding.Start + Padding.End),
 660                                     new LayoutLength(child.WidthSpecification));
 661
 662             MeasureSpecification childHeightMeasureSpec = GetChildMeasureSpecification(
 663                                     new MeasureSpecification(
 664                                         new LayoutLength(parentMeasureSpecificationHeight.Size - (margin.Top + margin.Bottom)),
 665                                         parentMeasureSpecificationHeight.Mode),
 666                                     new LayoutLength(Padding.Top + Padding.Bottom),
 667                                     new LayoutLength(child.HeightSpecification));
 668
 669             childLayout.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
 670
 671             measureSize.width = childLayout.MeasuredWidth.Size.AsRoundedValue();
 672             measureSize.height = childLayout.MeasuredHeight.Size.AsRoundedValue();
 673         }
 674
 675         void InsertChild(LayoutItem child)
 676         {
 677             // Store created node for child
 678             IntPtr childPtr = Interop.FlexLayout.AddChildWithMargin(swigCPtr, View.getCPtr(child.Owner), Extents.getCPtr(child.Owner.Margin), measureChildDelegate, LayoutChildren.Count - 1);
 679             HandleRef childHandleRef = new HandleRef(child.Owner, childPtr);
 680             SetAttachedValue(child.Owner, FlexItemProperty, childHandleRef);
 681         }
 682
 683         /// <summary>
 684         /// Callback when child is added to container.<br />
 685         /// Derived classes can use this to set their own child properties on the child layout's owner.<br />
 686         /// </summary>
 687         /// <param name="child">The Layout child.</param>
 688         /// <exception cref="ArgumentNullException"> Thrown when child is null. </exception>
 689         /// <since_tizen> 6 </since_tizen>
 690         protected override void OnChildAdd(LayoutItem child)
 691         {
 692             if (null == child)
 693             {
 694                 throw new ArgumentNullException(nameof(child));
 695             }
 696             InsertChild(child);
 697         }
 698
 699         /// <summary>
 700         /// Callback when child is removed from container.<br />
 701         /// </summary>
 702         /// <param name="child">The Layout child.</param>
 703         /// <exception cref="ArgumentNullException"> Thrown when child is null. </exception>
 704         /// <since_tizen> 6 </since_tizen>
 705         protected override void OnChildRemove(LayoutItem child)
 706         {
 707             if (null == child)
 708             {
 709                 throw new ArgumentNullException(nameof(child));
 710             }
 711             // When child View is removed from it's parent View (that is a Layout) then remove it from the layout too.
 712             // FlexLayout refers to the child as a View not LayoutItem.
 713             Interop.FlexLayout.RemoveChild(swigCPtr, child.Owner.SwigCPtr);
 714         }
 715
 716         /// <summary>
 717         /// Measure the layout and its content to determine the measured width and the measured height.<br />
 718         /// </summary>
 719         /// <param name="widthMeasureSpec">horizontal space requirements as imposed by the parent.</param>
 720         /// <param name="heightMeasureSpec">vertical space requirements as imposed by the parent.</param>
 721         /// <since_tizen> 6 </since_tizen>
 722         protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 723         {
 724             bool isLayoutRtl = Owner.LayoutDirection == ViewLayoutDirectionType.RTL;
 725             Extents padding = Owner.Padding;
 726
 727             Interop.FlexLayout.SetPadding(swigCPtr, Extents.getCPtr(padding));
 728
 729             float width = FlexUndefined; // Behaves as WrapContent (Flex Auto)
 730             float height = FlexUndefined; // Behaves as WrapContent (Flex Auto)
 731
 732             if (widthMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly || widthMeasureSpec.Mode == MeasureSpecification.ModeType.AtMost)
 733             {
 734                 width = widthMeasureSpec.Size.AsDecimal();
 735             }
 736
 737             if (heightMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly || heightMeasureSpec.Mode == MeasureSpecification.ModeType.AtMost)
 738             {
 739                 height = heightMeasureSpec.Size.AsDecimal();
 740             }
 741
 742             // Save measureSpec to measure children.
 743             // In other Layout, we can pass it as parameter to measuring child but in FlexLayout we can't
 744             // because measurChild function is called by native callback.
 745             parentMeasureSpecificationWidth = widthMeasureSpec;
 746             parentMeasureSpecificationHeight = heightMeasureSpec;
 747
 748             Extents zeroMargin = new Extents();
 749
 750             // Assign child properties
 751             for (int i = 0; i < LayoutChildren.Count; i++)
 752             {
 753                 LayoutItem layoutItem = LayoutChildren[i];
 754                 View Child = layoutItem?.Owner;
 755                 HandleRef childHandleRef = (HandleRef)Child.GetValue(FlexItemProperty);
 756                 if (childHandleRef.Handle == IntPtr.Zero || Child == null)
 757                     continue;
 758
 759                 AlignmentType flexAlignemnt = GetFlexAlignmentSelf(Child);
 760                 PositionType positionType = GetFlexPositionType(Child);
 761                 float flexAspectRatio = GetFlexAspectRatio(Child);
 762                 float flexBasis = GetFlexBasis(Child);
 763                 float flexShrink = GetFlexShrink(Child);
 764                 float flexGrow = GetFlexGrow(Child);
 765                 Extents childMargin = Child.ExcludeLayouting ? zeroMargin : layoutItem.Margin;
 766
 767                 Interop.FlexLayout.SetMargin(childHandleRef, Extents.getCPtr(childMargin));
 768                 Interop.FlexLayout.SetFlexAlignmentSelf(childHandleRef, (int)flexAlignemnt);
 769                 Interop.FlexLayout.SetFlexPositionType(childHandleRef, (int)positionType);
 770                 Interop.FlexLayout.SetFlexAspectRatio(childHandleRef, flexAspectRatio);
 771                 Interop.FlexLayout.SetFlexBasis(childHandleRef, flexBasis);
 772                 Interop.FlexLayout.SetFlexShrink(childHandleRef, flexShrink);
 773                 Interop.FlexLayout.SetFlexGrow(childHandleRef, flexGrow);
 774             }
 775
 776             Interop.FlexLayout.CalculateLayout(swigCPtr, width, height, isLayoutRtl);
 777             zeroMargin.Dispose();
 778
 779             LayoutLength flexLayoutWidth = new LayoutLength(Interop.FlexLayout.GetWidth(swigCPtr));
 780             LayoutLength flexLayoutHeight = new LayoutLength(Interop.FlexLayout.GetHeight(swigCPtr));
 781
 782             NUILog.Debug("FlexLayout OnMeasure width:" + flexLayoutWidth.AsRoundedValue() + " height:" + flexLayoutHeight.AsRoundedValue());
 783
 784             SetMeasuredDimensions(GetDefaultSize(flexLayoutWidth, widthMeasureSpec),
 785                                    GetDefaultSize(flexLayoutHeight, heightMeasureSpec));
 786         }
 787
 788         /// <summary>
 789         /// Assign a size and position to each of its children.<br />
 790         /// </summary>
 791         /// <param name="changed">This is a new size or position for this layout.</param>
 792         /// <param name="left">Left position, relative to parent.</param>
 793         /// <param name="top"> Top position, relative to parent.</param>
 794         /// <param name="right">Right position, relative to parent.</param>
 795         /// <param name="bottom">Bottom position, relative to parent.</param>
 796         /// <since_tizen> 6 </since_tizen>
 797         protected override void OnLayout(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom)
 798         {
 799
 800             bool isLayoutRtl = Owner.LayoutDirection == ViewLayoutDirectionType.RTL;
 801             LayoutLength width = right - left;
 802             LayoutLength height = bottom - top;
 803
 804             // Call to FlexLayout implementation to calculate layout values for later retrieval.
 805             Interop.FlexLayout.CalculateLayout(swigCPtr, width.AsDecimal(), height.AsDecimal(), isLayoutRtl);
 806
 807             for (int childIndex = 0; childIndex < LayoutChildren.Count; childIndex++)
 808             {
 809                 LayoutItem childLayout = LayoutChildren[childIndex];
 810                 if (!childLayout?.Owner?.ExcludeLayouting ?? false)
 811                 {
 812                     // Get the frame for the child, start, top, end, bottom.
 813                     Vector4 frame = new Vector4(Interop.FlexLayout.GetNodeFrame(swigCPtr, childIndex), true);
 814                     childLayout.Layout(new LayoutLength(frame.X), new LayoutLength(frame.Y), new LayoutLength(frame.Z), new LayoutLength(frame.W));
 815                     frame.Dispose();
 816                 }
 817             }
 818         }
 819     } // FLexlayout
 820 } // namesspace Tizen.NUI