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

   1 /* Copyright (c) 2020 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, global::System.IDisposable
  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 static bool LayoutDebugFlex = false; // Debug flag
  93
  94         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
  95         private bool swigCMemOwn;
  96         private bool disposed;
  97         private bool isDisposeQueued = false;
  98
  99         private MeasureSpecification parentMeasureSpecificationWidth;
 100         private MeasureSpecification parentMeasureSpecificationHeight;
 101
 102         private IntPtr _rootFlex;  // Pointer to the unmanged flex layout class.
 103
 104         internal const float FlexUndefined = 10E20F; // Auto setting which is equivalent to WrapContent.
 105
 106         internal struct MeasuredSize
 107         {
 108             public MeasuredSize(float x, float y)
 109             {
 110                 width = x;
 111                 height = y;
 112             }
 113             public float width;
 114             public float height;
 115         };
 116
 117         /// <summary>
 118         /// Gets the alignment self of the child view.
 119         /// </summary>
 120         /// <seealso cref="SetFlexAlignmentSelf(View, AlignmentType)"/>
 121         /// <param name="view">The child view.</param>
 122         /// <returns> The value of alignment self.</returns>
 123         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 124         /// <since_tizen> 8 </since_tizen>
 125         public static AlignmentType GetFlexAlignmentSelf(View view) => GetAttachedValue<AlignmentType>(view, FlexAlignmentSelfProperty);
 126
 127         /// <summary>
 128         /// Gets the position type of the child view.
 129         /// </summary>
 130         /// <seealso cref="SetFlexPositionType(View, PositionType)"/>
 131         /// <param name="view">The child view.</param>
 132         /// <returns> The value of position type</returns>
 133         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 134         /// <since_tizen> 8 </since_tizen>
 135         public static PositionType GetFlexPositionType(View view) => GetAttachedValue<PositionType>(view, FlexPositionTypeProperty);
 136
 137         /// <summary>
 138         /// Gets the aspect ratio of the child view.
 139         /// </summary>
 140         /// <seealso cref="SetFlexAspectRatio(View, float)"/>
 141         /// <param name="view">The child view.</param>
 142         /// <returns> The value of aspect ratio</returns>
 143         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 144         /// <since_tizen> 8 </since_tizen>
 145         public static float GetFlexAspectRatio(View view) => GetAttachedValue<float>(view, FlexAspectRatioProperty);
 146
 147         /// <summary>
 148         /// Gets the basis of the child view.
 149         /// </summary>
 150         /// <seealso cref="SetFlexBasis(View, float)"/>
 151         /// <param name="view">The child view.</param>
 152         /// <returns> The value of basis</returns>
 153         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 154         /// <since_tizen> 8 </since_tizen>
 155         public static float GetFlexBasis(View view) => GetAttachedValue<float>(view, FlexBasisProperty);
 156
 157         /// <summary>
 158         /// Gets the shrink of the child view.
 159         /// </summary>
 160         /// <seealso cref="SetFlexShrink(View, float)"/>
 161         /// <param name="view">The child view.</param>
 162         /// <returns> The value of shrink</returns>
 163         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 164         /// <since_tizen> 8 </since_tizen>
 165         public static float GetFlexShrink(View view) => GetAttachedValue<float>(view, FlexShrinkProperty);
 166
 167         /// <summary>
 168         /// Gets the grow of the child view.
 169         /// </summary>
 170         /// <seealso cref="SetFlexGrow(View, float)"/>
 171         /// <param name="view">The child view.</param>
 172         /// <returns> The value of grow</returns>
 173         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 174         /// <since_tizen> 8 </since_tizen>
 175         public static float GetFlexGrow(View view) => GetAttachedValue<float>(view, FlexGrowProperty);
 176
 177         /// <summary>
 178         /// Sets the alignment self of the child view.<br/>
 179         /// Alignment self has the same options and effect as <see cref="ItemsAlignment"/> but instead of affecting the children within a container,
 180         /// you can apply this property to a single child to change its alignment within its parent.<br/>
 181         /// Alignment self overrides any option set by the parent with <see cref="ItemsAlignment"/>.
 182         /// </summary>
 183         /// <param name="view">The child view.</param>
 184         /// <param name="value">The value of alignment self.</param>
 185         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 186         /// <exception cref="ArgumentException">The <paramref name="value"/> should be <see cref="AlignmentType"/>.</exception>
 187         /// <since_tizen> 8 </since_tizen>
 188         public static void SetFlexAlignmentSelf(View view, AlignmentType value) => SetAttachedValue(view, FlexAlignmentSelfProperty, value);
 189
 190         /// <summary>
 191         /// Sets the position type of the child view.<br/>
 192         /// The position type of an element defines how it is positioned within its parent.
 193         /// By default a child is positioned relatively. This means a child is positioned according to the normal flow of the layout,
 194         /// and then offset relative to that position based on the values of <see cref="View.Margin"/>.<br/>
 195         /// When positioned absolutely an element doesn't take part in the normal layout flow.
 196         /// It is instead laid out independent of its siblings. The position is determined based on the <see cref="View.Margin"/>.
 197         /// </summary>
 198         /// <param name="view">The child view.</param>
 199         /// <param name="value">The value of position type.</param>
 200         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 201         /// <exception cref="ArgumentException">The <paramref name="value"/> should be <see cref="PositionType"/>.</exception>
 202         /// <since_tizen> 8 </since_tizen>
 203         public static void SetFlexPositionType(View view, PositionType value) => SetAttachedValue(view, FlexPositionTypeProperty, value);
 204
 205         /// <summary>
 206         /// Sets the aspect ratio of the child view.
 207         /// Aspect ratio Defines as the ratio between the width and the height of a node
 208         /// e.g. if a node has an aspect ratio of 2 then its width is twice the size of its height.<br/>
 209         /// Aspect ratio accepts any floating point value > 0. this has higher priority than flex grow.
 210         /// </summary>
 211         /// <param name="view">The child view.</param>
 212         /// <param name="value">The value of aspect ratio</param>
 213         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 214         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than or equal to 0.0f.</exception>
 215         /// <since_tizen> 8 </since_tizen>
 216         public static void SetFlexAspectRatio(View view, float value) => SetAttachedValue(view, FlexAspectRatioProperty, value);
 217
 218         /// <summary>
 219         /// Sets the flex basis of the child view.
 220         /// Flex basis is an axis-independent way of providing the default size of an item along the main axis.<br/>
 221         /// 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"/>
 222         /// or setting the height of a child if its parent is a container with <see cref="FlexDirection.Column"/>.<br/>
 223         /// 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.
 224         /// </summary>
 225         /// <param name="view">The child view.</param>
 226         /// <param name="value">The value of basis</param>
 227         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 228         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 229         /// <since_tizen> 8 </since_tizen>
 230         public static void SetFlexBasis(View view, float value) => SetAttachedValue(view, FlexBasisProperty, value);
 231
 232         /// <summary>
 233         /// Sets the flex shrink of the child view.
 234         /// 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/>
 235         /// 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.
 236         /// These two properties also work well together by allowing children to grow and shrink as needed.<br/>
 237         /// 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.
 238         /// </summary>
 239         /// <param name="view">The child view.</param>
 240         /// <param name="value">The value of shrink</param>
 241         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 242         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 243         /// <since_tizen> 8 </since_tizen>
 244         public static void SetFlexShrink(View view, float value) => SetAttachedValue(view, FlexShrinkProperty, value);
 245
 246         /// <summary>
 247         /// Sets the grow of the child view.
 248         /// Flex grow describes how any space within a container should be distributed among its children along the main axis.
 249         /// After laying out its children, a container will distribute any remaining space according to the flex grow values specified by its children.<br/>
 250         /// Flex grow accepts any floating point value >= 0, with 0 being the default value.<br/>
 251         /// A container will distribute any remaining space among its children weighted by the child's flex grow value.
 252         /// </summary>
 253         /// <param name="view">The child view.</param>
 254         /// <param name="value">The value of flex</param>
 255         /// <exception cref="ArgumentNullException">The <paramref name="view"/> cannot be null.</exception>
 256         /// <exception cref="ArgumentException">The <paramref name="value"/> cannot be less than 0.0f.</exception>
 257         /// <since_tizen> 8 </since_tizen>
 258         public static void SetFlexGrow(View view, float value) => SetAttachedValue(view, FlexGrowProperty, value);
 259
 260         [UnmanagedFunctionPointer(CallingConvention.Cdecl)]
 261         internal delegate void ChildMeasureCallback(global::System.IntPtr child, float width, int measureModeWidth, float height, int measureModeHeight, out MeasuredSize measureSize);
 262
 263         event ChildMeasureCallback measureChildDelegate; // Stores a delegate to the child measure callback. Used for all children of this FlexLayout.
 264
 265         internal FlexLayout(global::System.IntPtr cPtr, bool cMemoryOwn)
 266         {
 267             swigCMemOwn = cMemoryOwn;
 268             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 269             _rootFlex = Interop.FlexLayout.New();
 270             measureChildDelegate = new ChildMeasureCallback(measureChild);
 271         }
 272
 273         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(FlexLayout obj)
 274         {
 275             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
 276         }
 277
 278         /// <inheritdoc/>
 279         /// <since_tizen> 6 </since_tizen>
 280         public void Dispose()
 281         {
 282             // Throw exception if Dispose() is called in separate thread.
 283             if (!Window.IsInstalled())
 284             {
 285                 Tizen.Log.Error("NUI", "This API called from separate thread.This API must be called from MainThread.");
 286                 return;
 287             }
 288
 289             if (isDisposeQueued)
 290             {
 291                 Dispose(DisposeTypes.Implicit);
 292             }
 293             else
 294             {
 295                 Dispose(DisposeTypes.Explicit);
 296                 System.GC.SuppressFinalize(this);
 297             }
 298         }
 299
 300         /// <inheritdoc/>
 301         /// <since_tizen> 6 </since_tizen>
 302         protected virtual void Dispose(DisposeTypes type)
 303         {
 304             if (disposed)
 305             {
 306                 return;
 307             }
 308
 309             if (type == DisposeTypes.Explicit)
 310             {
 311                 // Called by User
 312                 // Release your own managed resources here.
 313                 // You should release all of your own disposable objects here.
 314
 315             }
 316
 317             // Release your own unmanaged resources here.
 318             // You should not access any managed member here except static instance.
 319             // because the execution order of Finalizes is non-deterministic.
 320             if (swigCPtr.Handle != global::System.IntPtr.Zero)
 321             {
 322                 if (swigCMemOwn)
 323                 {
 324                     swigCMemOwn = false;
 325                     Interop.FlexLayout.DeleteFlexLayout(swigCPtr);
 326                 }
 327                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 328             }
 329             disposed = true;
 330         }
 331
 332         /// <summary>
 333         /// Creates a FlexLayout object.
 334         /// </summary>
 335         /// <since_tizen> 6 </since_tizen>
 336         public FlexLayout() : this(Interop.FlexLayout.New(), true)
 337         {
 338             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 339         }
 340
 341         internal static FlexLayout DownCast(BaseHandle handle)
 342         {
 343             FlexLayout ret = new FlexLayout(Interop.FlexLayout.DownCast(BaseHandle.getCPtr(handle)), true);
 344             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 345             return ret;
 346         }
 347
 348         internal FlexLayout(FlexLayout other) : this(Interop.FlexLayout.NewFlexLayout(FlexLayout.getCPtr(other)), true)
 349         {
 350             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 351         }
 352
 353         internal FlexLayout.AlignmentType GetFlexAlignment()
 354         {
 355             FlexLayout.AlignmentType ret = (FlexLayout.AlignmentType)Interop.FlexLayout.GetFlexAlignment(swigCPtr);
 356             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 357             return ret;
 358         }
 359
 360         internal FlexLayout.AlignmentType GetFlexItemsAlignment()
 361         {
 362             FlexLayout.AlignmentType ret = (FlexLayout.AlignmentType)Interop.FlexLayout.GetFlexItemsAlignment(swigCPtr);
 363             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 364             return ret;
 365         }
 366
 367         /// <summary>
 368         /// Gets/Sets the flex direction in the layout.
 369         /// The direction of the main-axis which determines the direction that flex items are laid out.
 370         /// </summary>
 371         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 372         /// <since_tizen> 6 </since_tizen>
 373         public FlexDirection Direction
 374         {
 375             get => (FlexDirection)Interop.FlexLayout.GetFlexDirection(swigCPtr);
 376             set
 377             {
 378                 if (value < FlexDirection.Column || value > FlexDirection.RowReverse)
 379                     throw new InvalidEnumArgumentException(nameof(Direction));
 380
 381                 Interop.FlexLayout.SetFlexDirection(swigCPtr, (int)value);
 382                 RequestLayout();
 383             }
 384         }
 385
 386         /// <summary>
 387         /// Gets/Sets the justification in the layout.
 388         /// Justify content describes how to align children within the main axis of their container.<br/>
 389         /// 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"/>
 390         /// or vertically within a container with <see cref="Direction"/> set to <see cref="FlexDirection.Column"/>.
 391         /// </summary>
 392         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 393         /// <since_tizen> 6 </since_tizen>
 394         public FlexJustification Justification
 395         {
 396             get => (FlexJustification)Interop.FlexLayout.GetFlexJustification(swigCPtr);
 397             set
 398             {
 399                 if (value < FlexJustification.FlexStart || value > FlexJustification.SpaceAround)
 400                     throw new InvalidEnumArgumentException(nameof(Justification));
 401
 402                 Interop.FlexLayout.SetFlexJustification(swigCPtr, (int)value);
 403                 RequestLayout();
 404             }
 405         }
 406
 407         /// <summary>
 408         /// Gets/Sets the wrap in the layout.
 409         /// 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/>
 410         /// By default children are forced into a single line (which can shrink elements).<br/>
 411         /// 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/>
 412         /// When wrapping lines <see cref="Alignment"/> can be used to specify how the lines are placed in the container.
 413         /// </summary>
 414         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 415         /// <since_tizen> 6 </since_tizen>
 416         public FlexWrapType WrapType
 417         {
 418             get => (FlexWrapType)Interop.FlexLayout.GetFlexWrap(swigCPtr);
 419             set
 420             {
 421                 if (value != FlexWrapType.NoWrap && value != FlexWrapType.Wrap)
 422                     throw new InvalidEnumArgumentException(nameof(WrapType));
 423
 424                 Interop.FlexLayout.SetFlexWrap(swigCPtr, (int)value);
 425                 RequestLayout();
 426
 427             }
 428         }
 429
 430         /// <summary>
 431         /// Gets/Sets the alignment of the layout content.
 432         /// Alignment defines the distribution of lines along the cross-axis.<br/>
 433         /// This only has effect when items are wrapped to multiple lines using flex wrap.
 434         /// </summary>
 435         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 436         /// <since_tizen> 6 </since_tizen>
 437         public AlignmentType Alignment
 438         {
 439             get => GetFlexAlignment();
 440             set
 441             {
 442                 if (value < AlignmentType.Auto || value > AlignmentType.Stretch)
 443                     throw new InvalidEnumArgumentException(nameof(Alignment));
 444
 445                 Interop.FlexLayout.SetFlexAlignment(swigCPtr, (int)value);
 446                 RequestLayout();
 447             }
 448         }
 449
 450         /// <summary>
 451         /// Gets/Sets the alignment of the layout items.
 452         /// Items alignment describes how to align children along the cross axis of their container.<br/>
 453         /// Align items is very similar to <see cref="Justification"/> but instead of applying to the main axis, align items applies to the cross axis.
 454         /// </summary>
 455         /// <exception cref="InvalidEnumArgumentException">Thrown when using invalid arguments that are enumerators.</exception>
 456         /// <since_tizen> 6 </since_tizen>
 457         public AlignmentType ItemsAlignment
 458         {
 459             get => GetFlexItemsAlignment();
 460             set
 461             {
 462                 if (value < AlignmentType.Auto || value > AlignmentType.Stretch)
 463                     throw new InvalidEnumArgumentException(nameof(ItemsAlignment));
 464
 465                 Interop.FlexLayout.SetFlexItemsAlignment(swigCPtr, (int)value);
 466                 RequestLayout();
 467             }
 468         }
 469
 470         /// <summary>
 471         /// Enumeration for the direction of the main axis in the flex container.
 472         /// This determines the direction that flex items are laid out in the flex container.
 473         /// </summary>
 474         /// <since_tizen> 6 </since_tizen>
 475         public enum FlexDirection
 476         {
 477             /// <summary>
 478             /// The flexible items are displayed vertically as a column
 479             /// </summary>
 480             Column,
 481             /// <summary>
 482             /// The flexible items are displayed vertically as a column, but in reverse order
 483             /// </summary>
 484             ColumnReverse,
 485             /// <summary>
 486             /// The flexible items are displayed horizontally as a row
 487             /// </summary>
 488             Row,
 489             /// <summary>
 490             /// The flexible items are displayed horizontally as a row, but in reverse order
 491             /// </summary>
 492             RowReverse
 493         }
 494
 495         /// <summary>
 496         /// Enumeration for the alignment of the flex items when the items do not use all available space on the main-axis.
 497         /// </summary>
 498         /// <since_tizen> 6 </since_tizen>
 499         public enum FlexJustification
 500         {
 501             /// <summary>
 502             /// Items are positioned at the beginning of the container.
 503             /// </summary>
 504             FlexStart,
 505             /// <summary>
 506             /// Items are positioned at the center of the container.
 507             /// </summary>
 508             Center,
 509             /// <summary>
 510             /// Items are positioned at the end of the container.
 511             /// </summary>
 512             FlexEnd,
 513             /// <summary>
 514             /// Items are positioned with equal space between the lines.
 515             /// </summary>
 516             SpaceBetween,
 517             /// <summary>
 518             /// Items are positioned with equal space before, between, and after the lines.<br/>
 519             /// Compared to <see cref="FlexJustification.SpaceBetween"/> using <see cref="FlexJustification.SpaceAround"/>
 520             /// will result in space being distributed to the beginning of the first child and end of the last child.
 521             /// </summary>
 522             SpaceAround
 523         }
 524
 525         /// <summary>
 526         /// Enumeration for the wrap type of the flex container when there is no enough room for all the items on one flex line.
 527         /// </summary>
 528         /// <since_tizen> 6 </since_tizen>
 529         public enum FlexWrapType
 530         {
 531             /// <summary>
 532             /// Flex items laid out in single line (shrunk to fit the flex container along the main axis)
 533             /// </summary>
 534             NoWrap,
 535             /// <summary>
 536             /// Flex items laid out in multiple lines if needed
 537             /// </summary>
 538             Wrap
 539         }
 540
 541         /// <summary>
 542         /// 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.
 543         /// </summary>
 544         /// <since_tizen> 6 </since_tizen>
 545         public enum AlignmentType
 546         {
 547             /// <summary>
 548             /// Inherits the same alignment from the parent
 549             /// </summary>
 550             Auto,
 551             /// <summary>
 552             /// At the beginning of the container
 553             /// </summary>
 554             FlexStart,
 555             /// <summary>
 556             /// At the center of the container
 557             /// </summary>
 558             Center,
 559             /// <summary>
 560             /// At the end of the container
 561             /// </summary>
 562             FlexEnd,
 563             /// <summary>
 564             /// Stretch to fit the container
 565             /// </summary>
 566             Stretch
 567         }
 568
 569         /// <summary>
 570         /// Enumeration for the position type of the flex item how it is positioned within its parent.
 571         /// </summary>
 572         /// <since_tizen> 8 </since_tizen>
 573         public enum PositionType
 574         {
 575             /// <summary>
 576             /// Flex items laid out relatively.
 577             /// </summary>
 578             Relative,
 579             /// <summary>
 580             /// Flex items laid out absolutely.
 581             /// </summary>
 582             Absolute
 583         }
 584
 585         private void measureChild(global::System.IntPtr childPtr, float width, int measureModeWidth, float height, int measureModeHeight, out MeasuredSize measureSize)
 586         {
 587             // We need to measure child layout
 588             View child = Registry.GetManagedBaseHandleFromNativePtr(childPtr) as View;
 589             // independent child will be measured in LayoutGroup.OnMeasureIndependentChildren().
 590             if (child?.ExcludeLayouting ?? true)
 591             {
 592                 measureSize.width = 0;
 593                 measureSize.height = 0;
 594                 return;
 595             }
 596
 597             LayoutItem childLayout = child.Layout;
 598
 599             MeasureSpecification childWidthMeasureSpec = GetChildMeasureSpecification(
 600                                     new MeasureSpecification(
 601                                         new LayoutLength(parentMeasureSpecificationWidth.Size - (child.Margin.Start + child.Margin.End)),
 602                                         parentMeasureSpecificationWidth.Mode),
 603                                     new LayoutLength(Padding.Start + Padding.End),
 604                                     new LayoutLength(child.WidthSpecification));
 605
 606             MeasureSpecification childHeightMeasureSpec = GetChildMeasureSpecification(
 607                                     new MeasureSpecification(
 608                                         new LayoutLength(parentMeasureSpecificationHeight.Size - (child.Margin.Top + child.Margin.Bottom)),
 609                                         parentMeasureSpecificationHeight.Mode),
 610                                     new LayoutLength(Padding.Top + Padding.Bottom),
 611                                     new LayoutLength(child.HeightSpecification));
 612
 613             childLayout.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
 614
 615             measureSize.width = childLayout.MeasuredWidth.Size.AsRoundedValue();
 616             measureSize.height = childLayout.MeasuredHeight.Size.AsRoundedValue();
 617         }
 618
 619         void InsertChild(LayoutItem child)
 620         {
 621             // Store created node for child
 622             IntPtr childPtr = Interop.FlexLayout.AddChildWithMargin(swigCPtr, View.getCPtr(child.Owner), Extents.getCPtr(child.Owner.Margin), measureChildDelegate, LayoutChildren.Count - 1);
 623             HandleRef childHandleRef = new HandleRef(child.Owner, childPtr);
 624             SetAttachedValue(child.Owner, FlexItemProperty, childHandleRef);
 625         }
 626
 627         /// <summary>
 628         /// Callback when child is added to container.<br />
 629         /// Derived classes can use this to set their own child properties on the child layout's owner.<br />
 630         /// </summary>
 631         /// <param name="child">The Layout child.</param>
 632         /// <exception cref="ArgumentNullException"> Thrown when child is null. </exception>
 633         /// <since_tizen> 6 </since_tizen>
 634         protected override void OnChildAdd(LayoutItem child)
 635         {
 636             if (null == child)
 637             {
 638                 throw new ArgumentNullException(nameof(child));
 639             }
 640             InsertChild(child);
 641         }
 642
 643         /// <summary>
 644         /// Callback when child is removed from container.<br />
 645         /// </summary>
 646         /// <param name="child">The Layout child.</param>
 647         /// <since_tizen> 6 </since_tizen>
 648         protected override void OnChildRemove(LayoutItem child)
 649         {
 650             // When child View is removed from it's parent View (that is a Layout) then remove it from the layout too.
 651             // FlexLayout refers to the child as a View not LayoutItem.
 652             Interop.FlexLayout.RemoveChild(swigCPtr, child);
 653         }
 654
 655         /// <summary>
 656         /// Measure the layout and its content to determine the measured width and the measured height.<br />
 657         /// </summary>
 658         /// <param name="widthMeasureSpec">horizontal space requirements as imposed by the parent.</param>
 659         /// <param name="heightMeasureSpec">vertical space requirements as imposed by the parent.</param>
 660         /// <since_tizen> 6 </since_tizen>
 661         protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 662         {
 663             bool isLayoutRtl = Owner.LayoutDirection == ViewLayoutDirectionType.RTL;
 664             Extents padding = Owner.Padding;
 665
 666             Interop.FlexLayout.SetPadding(swigCPtr, Extents.getCPtr(padding));
 667
 668             float width = FlexUndefined; // Behaves as WrapContent (Flex Auto)
 669             float height = FlexUndefined; // Behaves as WrapContent (Flex Auto)
 670
 671             if (widthMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly || widthMeasureSpec.Mode == MeasureSpecification.ModeType.AtMost)
 672             {
 673                 width = widthMeasureSpec.Size.AsDecimal();
 674             }
 675
 676             if (heightMeasureSpec.Mode == MeasureSpecification.ModeType.Exactly || heightMeasureSpec.Mode == MeasureSpecification.ModeType.AtMost)
 677             {
 678                 height = heightMeasureSpec.Size.AsDecimal();
 679             }
 680
 681             // Save measureSpec to measure children.
 682             // In other Layout, we can pass it as parameter to measuring child but in FlexLayout we can't
 683             // because measurChild function is called by native callback.
 684             parentMeasureSpecificationWidth = widthMeasureSpec;
 685             parentMeasureSpecificationHeight = heightMeasureSpec;
 686
 687             Extents zeroMargin = new Extents();
 688
 689             // Assign child properties
 690             for (int i = 0; i < LayoutChildren.Count; i++)
 691             {
 692                 LayoutItem layoutItem = LayoutChildren[i];
 693                 View Child = layoutItem?.Owner;
 694                 HandleRef childHandleRef = (HandleRef)Child.GetValue(FlexItemProperty);
 695                 if (childHandleRef.Handle == IntPtr.Zero || Child == null)
 696                     continue;
 697
 698                 AlignmentType flexAlignemnt = GetFlexAlignmentSelf(Child);
 699                 PositionType positionType = GetFlexPositionType(Child);
 700                 float flexAspectRatio = GetFlexAspectRatio(Child);
 701                 float flexBasis = GetFlexBasis(Child);
 702                 float flexShrink = GetFlexShrink(Child);
 703                 float flexGrow = GetFlexGrow(Child);
 704                 Extents childMargin = Child.ExcludeLayouting ? zeroMargin : layoutItem.Margin;
 705
 706                 Interop.FlexLayout.SetMargin(childHandleRef, Extents.getCPtr(childMargin));
 707                 Interop.FlexLayout.SetFlexAlignmentSelf(childHandleRef, (int)flexAlignemnt);
 708                 Interop.FlexLayout.SetFlexPositionType(childHandleRef, (int)positionType);
 709                 Interop.FlexLayout.SetFlexAspectRatio(childHandleRef, flexAspectRatio);
 710                 Interop.FlexLayout.SetFlexBasis(childHandleRef, flexBasis);
 711                 Interop.FlexLayout.SetFlexShrink(childHandleRef, flexShrink);
 712                 Interop.FlexLayout.SetFlexGrow(childHandleRef, flexGrow);
 713             }
 714
 715             Interop.FlexLayout.CalculateLayout(swigCPtr, width, height, isLayoutRtl);
 716             zeroMargin.Dispose();
 717
 718             LayoutLength flexLayoutWidth = new LayoutLength(Interop.FlexLayout.GetWidth(swigCPtr));
 719             LayoutLength flexLayoutHeight = new LayoutLength(Interop.FlexLayout.GetHeight(swigCPtr));
 720
 721             Debug.WriteLineIf(LayoutDebugFlex, "FlexLayout OnMeasure width:" + flexLayoutWidth.AsRoundedValue()
 722                                                 + " height:" + flexLayoutHeight.AsRoundedValue());
 723
 724             SetMeasuredDimensions(GetDefaultSize(flexLayoutWidth, widthMeasureSpec),
 725                                    GetDefaultSize(flexLayoutHeight, heightMeasureSpec));
 726         }
 727
 728         /// <summary>
 729         /// Assign a size and position to each of its children.<br />
 730         /// </summary>
 731         /// <param name="changed">This is a new size or position for this layout.</param>
 732         /// <param name="left">Left position, relative to parent.</param>
 733         /// <param name="top"> Top position, relative to parent.</param>
 734         /// <param name="right">Right position, relative to parent.</param>
 735         /// <param name="bottom">Bottom position, relative to parent.</param>
 736         /// <since_tizen> 6 </since_tizen>
 737         protected override void OnLayout(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom)
 738         {
 739
 740             bool isLayoutRtl = Owner.LayoutDirection == ViewLayoutDirectionType.RTL;
 741             LayoutLength width = right - left;
 742             LayoutLength height = bottom - top;
 743
 744             // Call to FlexLayout implementation to calculate layout values for later retrieval.
 745             Interop.FlexLayout.CalculateLayout(swigCPtr, width.AsDecimal(), height.AsDecimal(), isLayoutRtl);
 746
 747             for (int childIndex = 0; childIndex < LayoutChildren.Count; childIndex++)
 748             {
 749                 LayoutItem childLayout = LayoutChildren[childIndex];
 750                 if (!childLayout?.Owner?.ExcludeLayouting ?? false)
 751                 {
 752                     // Get the frame for the child, start, top, end, bottom.
 753                     Vector4 frame = new Vector4(Interop.FlexLayout.GetNodeFrame(swigCPtr, childIndex), true);
 754                     childLayout.Layout(new LayoutLength(frame.X), new LayoutLength(frame.Y), new LayoutLength(frame.Z), new LayoutLength(frame.W));
 755                 }
 756             }
 757         }
 758     } // FLexlayout
 759 } // namesspace Tizen.NUI