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

   1 /*
   2  * Copyright (c) 2021 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Collections.Generic;
  19 using System.ComponentModel;
  20 using System.Linq;
  21
  22 using Tizen.NUI.BaseComponents;
  23 using Tizen.NUI.Binding.Internals;
  24 using static Tizen.NUI.Binding.BindableObject;
  25
  26 namespace Tizen.NUI
  27 {
  28     /// <summary>
  29     /// [Draft] LayoutGroup class providing container functionality.
  30     /// </summary>
  31     public class LayoutGroup : LayoutItem, ILayoutParent
  32     {
  33         /// <summary>
  34         /// [Draft] List of child layouts in this container.
  35         /// </summary>
  36         /// <since_tizen> 6 </since_tizen>
  37         protected List<LayoutItem> LayoutChildren { get; } // Children of this LayoutGroup
  38
  39         /// <summary>
  40         /// [Draft] Constructor
  41         /// </summary>
  42         /// <since_tizen> 6 </since_tizen>
  43         public LayoutGroup()
  44         {
  45             LayoutChildren = new List<LayoutItem>();
  46         }
  47
  48         /// <summary>
  49         /// returns an enumerable collection of the child layouts that owner's <see cref="View.ExcludeLayouting"/> is false.
  50         /// </summary>
  51         /// <returns>An enumerable collection of the child layouts that affected by this layout.</returns>
  52         [EditorBrowsable(EditorBrowsableState.Never)]
  53         protected IEnumerable<LayoutItem> IterateLayoutChildren()
  54         {
  55             return LayoutChildren.Where<LayoutItem>(childLayout => childLayout.SetPositionByLayout);
  56         }
  57
  58         /// <summary>
  59         /// From ILayoutParent.<br />
  60         /// </summary>
  61         /// <exception cref="ArgumentNullException"> Thrown when childLayout is null. </exception>
  62         /// <since_tizen> 6 </since_tizen>
  63         /// <param name="childLayout">LayoutItem to add to the layout group.</param>
  64         public virtual void Add(LayoutItem childLayout)
  65         {
  66             if (null == childLayout)
  67             {
  68                 throw new ArgumentNullException(nameof(childLayout));
  69             }
  70             LayoutChildren.Add(childLayout);
  71             childLayout.SetParent(this);
  72             // Child added to use a Add transition.
  73             childLayout.ConditionForAnimation = ConditionForAnimation | TransitionCondition.Add;
  74             // Child's parent sets all other children not being added to a ChangeOnAdd transition.
  75             SetConditionsForAnimationOnLayoutGroup(TransitionCondition.ChangeOnAdd);
  76             OnChildAdd(childLayout);
  77             RequestLayout();
  78         }
  79
  80         /// <summary>
  81         /// Remove all layout children.<br />
  82         /// </summary>
  83         /// <since_tizen> 6 </since_tizen>
  84         public void RemoveAll()
  85         {
  86             foreach (LayoutItem childLayout in LayoutChildren)
  87             {
  88                 childLayout.ConditionForAnimation = ConditionForAnimation | TransitionCondition.Remove;
  89                 childLayout.Owner = null;
  90             }
  91             LayoutChildren.Clear();
  92             // todo ensure child LayoutItems are still not parented to this group.
  93             RequestLayout();
  94         }
  95
  96         /// <summary>
  97         /// From ILayoutParent
  98         /// </summary>
  99         /// <param name="layoutItem">LayoutItem to remove from the layout group.</param>
 100         /// <since_tizen> 6 </since_tizen>
 101         public virtual void Remove(LayoutItem layoutItem)
 102         {
 103             bool childRemoved = false;
 104             foreach (LayoutItem childLayout in LayoutChildren.ToList())
 105             {
 106                 if (childLayout == layoutItem)
 107                 {
 108                     childLayout.ClearReplaceFlag();
 109                     LayoutChildren.Remove(childLayout);
 110
 111                     if (LayoutWithTransition)
 112                     {
 113                         if (!childLayout.IsReplaceFlag())
 114                         {
 115                             NUIApplication.GetDefaultWindow().LayoutController.AddToRemovalStack(childLayout);
 116                         }
 117
 118                         childLayout.ConditionForAnimation = childLayout.ConditionForAnimation | TransitionCondition.Remove;
 119                         // Add LayoutItem to the transition stack so can animate it out.
 120                         NUIApplication.GetDefaultWindow().LayoutController.AddTransitionDataEntry(new LayoutData(layoutItem, ConditionForAnimation, 0, 0, 0, 0));
 121                     }
 122
 123                     // Reset condition for animation ready for next transition when required.
 124                     // SetFrame usually would do this but this LayoutItem is being removed.
 125                     childLayout.ConditionForAnimation = TransitionCondition.Unspecified;
 126                     childRemoved = true;
 127
 128                     break;
 129                 }
 130             }
 131
 132             if (childRemoved)
 133             {
 134                 // If child removed then set all siblings not being added to a ChangeOnRemove transition.
 135                 SetConditionsForAnimationOnLayoutGroup(TransitionCondition.ChangeOnRemove);
 136             }
 137             OnChildRemove(layoutItem);
 138             RequestLayout();
 139         }
 140
 141
 142         /// <summary>
 143         /// Sets the sibling order of the layout item so the layout can be defined within the same parent.
 144         /// </summary>
 145         /// <param name="order">the sibling order of the layout item</param>
 146         /// <since_tizen> 6 </since_tizen>
 147         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 148         [EditorBrowsable(EditorBrowsableState.Never)]
 149         public void ChangeLayoutSiblingOrder(int order)
 150         {
 151             if (Owner != null)
 152             {
 153                 var ownerParent = Owner.GetParent() as View;
 154                 if (ownerParent != null)
 155                 {
 156                     var parent = ownerParent.Layout as LayoutGroup;
 157
 158                     if (parent != null && parent.LayoutChildren.Count > order)
 159                     {
 160                         parent.LayoutChildren.Remove(this);
 161                         parent.LayoutChildren.Insert(order, this);
 162                     }
 163                 }
 164             }
 165             RequestLayout();
 166         }
 167
 168         // Attaches to View ChildAdded signal so called when a View is added to a view.
 169         private void AddChildToLayoutGroup(View child)
 170         {
 171             if (View.LayoutingDisabled)
 172             {
 173                 return;
 174             }
 175             // Only give children a layout if their parent is an explicit container or a pure View.
 176             // Pure View meaning not derived from a View, e.g a Legacy container.
 177             // layoutSet flag is true when the View became a layout using the set Layout API opposed to automatically due to it's parent.
 178             // First time the set Layout API is used by any View the Window no longer has layoutingDisabled.
 179
 180             // If child already has a Layout then don't change it.
 181             if (null == child.Layout)
 182             {
 183                 // If child view does not have Layout, then default layout is automatically set to the child view.
 184                 // The Layout is automatically added to this LayoutGroup when child view sets Layout.
 185                 child.Layout = child.CreateDefaultLayout();
 186             }
 187             else
 188             {
 189                 Add(child.Layout);
 190             }
 191             // Parent transitions are not attached to children.
 192         }
 193
 194         /// <summary>
 195         /// If the child has a layout then it is removed from the parent layout.
 196         /// </summary>
 197         /// <param name="child">Child View to remove.</param>
 198         internal void RemoveChildFromLayoutGroup(View child)
 199         {
 200             if (child.Layout != null)
 201             {
 202                 Remove(child.Layout);
 203             }
 204         }
 205
 206         /// <summary>
 207         /// Set all children in a LayoutGroup to the supplied condition.
 208         /// Children with Add or Remove conditions should not be changed.
 209         /// </summary>
 210         private void SetConditionsForAnimationOnLayoutGroup(TransitionCondition conditionToSet)
 211         {
 212             foreach (LayoutItem childLayout in LayoutChildren)
 213             {
 214                 switch (conditionToSet)
 215                 {
 216                     case TransitionCondition.ChangeOnAdd:
 217                         {
 218                             // If other children also being added (TransitionCondition.Add) then do not change their
 219                             // conditions, Continue to use their Add transitions.
 220                             if (childLayout.ConditionForAnimation.HasFlag(TransitionCondition.Add))
 221                             {
 222                                 break;  // Child being Added so don't update it's condition
 223                             }
 224                             else
 225                             {
 226                                 // Set siblings for the child being added to use the ChangeOnAdd transition.
 227                                 childLayout.ConditionForAnimation = TransitionCondition.ChangeOnAdd;
 228                             }
 229                             break;
 230                         }
 231                     case TransitionCondition.ChangeOnRemove:
 232                         {
 233                             if (childLayout.ConditionForAnimation.HasFlag(TransitionCondition.Remove))
 234                             {
 235                                 break; // Child being Removed so don't update it's condition
 236                             }
 237                             else
 238                             {
 239                                 childLayout.ConditionForAnimation = TransitionCondition.ChangeOnRemove;
 240                             }
 241                             break;
 242                         }
 243                     case TransitionCondition.LayoutChanged:
 244                         {
 245                             childLayout.ConditionForAnimation = TransitionCondition.LayoutChanged;
 246                             break;
 247                         }
 248                 }
 249             }
 250
 251         }
 252
 253         /// <summary>
 254         /// Callback for View.ChildAdded event
 255         /// </summary>
 256         /// <param name="sender">The object triggering the event.</param>
 257         /// <param name="childAddedEvent">Arguments from the event.</param>
 258         void OnChildAddedToOwner(object sender, View.ChildAddedEventArgs childAddedEvent)
 259         {
 260             AddChildToLayoutGroup(childAddedEvent.Added);
 261         }
 262
 263         /// <summary>
 264         /// Callback for View.ChildRemoved event
 265         /// </summary>
 266         /// <param name="sender">The object triggering the event.</param>
 267         /// <param name="childRemovedEvent">Arguments from the event.</param>
 268         void OnChildRemovedFromOwner(object sender, View.ChildRemovedEventArgs childRemovedEvent)
 269         {
 270             RemoveChildFromLayoutGroup(childRemovedEvent.Removed);
 271         }
 272
 273         /// <summary>
 274         /// Calculate the right measure spec for this child.
 275         /// Does the hard part of MeasureChildren: figuring out the MeasureSpec to
 276         /// pass to a particular child. This method figures out the right MeasureSpec
 277         /// for one dimension (height or width) of one child view.<br />
 278         /// </summary>
 279         /// <param name="parentMeasureSpec">The requirements for this view. MeasureSpecification.</param>
 280         /// <param name="padding">The padding of this view for the current dimension and margins, if applicable. LayoutLength.</param>
 281         /// <param name="childDimension"> How big the child wants to be in the current dimension. LayoutLength.</param>
 282         /// <returns>a MeasureSpec for the child.</returns>
 283         public static MeasureSpecification GetChildMeasureSpecification(MeasureSpecification parentMeasureSpec, LayoutLength padding, LayoutLength childDimension)
 284         {
 285             MeasureSpecification.ModeType specMode = parentMeasureSpec.Mode;
 286             MeasureSpecification.ModeType resultMode = MeasureSpecification.ModeType.Unspecified;
 287
 288             // Child only can use parent's size without parent's padding and own margin.
 289             LayoutLength resultSize = new LayoutLength(Math.Max(0.0f, (parentMeasureSpec.Size - padding).AsDecimal()));
 290             switch (specMode)
 291             {
 292                 // Parent has imposed an exact size on us
 293                 case MeasureSpecification.ModeType.Exactly:
 294                     {
 295                         if ((int)childDimension.AsRoundedValue() == LayoutParamPolicies.MatchParent)
 296                         {
 297                             resultMode = MeasureSpecification.ModeType.Exactly;
 298                         }
 299                         else if ((int)childDimension.AsRoundedValue() == LayoutParamPolicies.WrapContent)
 300                         {
 301                             resultMode = MeasureSpecification.ModeType.AtMost;
 302                         }
 303                         else
 304                         {
 305                             resultSize = childDimension;
 306                             resultMode = MeasureSpecification.ModeType.Exactly;
 307                         }
 308
 309                         break;
 310                     }
 311
 312                 // Parent has imposed a maximum size on us
 313                 case MeasureSpecification.ModeType.AtMost:
 314                     {
 315                         if (childDimension.AsRoundedValue() == LayoutParamPolicies.MatchParent)
 316                         {
 317                             // Crashed. Cannot calculate.
 318
 319                             // Child wants to be our size, but our size is not fixed.
 320                             // Constrain child to not be bigger than us.
 321                             resultMode = MeasureSpecification.ModeType.AtMost;
 322                         }
 323                         else if (childDimension.AsRoundedValue() == LayoutParamPolicies.WrapContent)
 324                         {
 325                             // Child wants to determine its own size. It can't be
 326                             // bigger than us.
 327
 328                             // Don't need parent's size. Size of this child will be determined by its children.
 329                             resultMode = MeasureSpecification.ModeType.AtMost;
 330                         }
 331                         else
 332                         {
 333                             // Child wants a specific size... so be it
 334                             resultSize = childDimension;
 335                             resultMode = MeasureSpecification.ModeType.Exactly;
 336                         }
 337
 338                         break;
 339                     }
 340
 341                 // Parent asked to see how big we want to be
 342                 case MeasureSpecification.ModeType.Unspecified:
 343                     {
 344                         if ((childDimension.AsRoundedValue() == LayoutParamPolicies.MatchParent))
 345                         {
 346                             // Child wants to be our size... find out how big it should be
 347
 348                             // There is no one who has exact size in parent hierarchy.
 349                             // Cannot calculate.
 350                             resultMode = MeasureSpecification.ModeType.Unspecified;
 351                         }
 352                         else if (childDimension.AsRoundedValue() == (LayoutParamPolicies.WrapContent))
 353                         {
 354                             // Child wants to determine its own size.... find out how big
 355                             // it should be
 356                             resultMode = MeasureSpecification.ModeType.Unspecified;
 357                         }
 358                         else
 359                         {
 360                             // Child wants a specific size... let him have it
 361                             resultSize = childDimension;
 362                             resultMode = MeasureSpecification.ModeType.Exactly;
 363                         }
 364                         break;
 365                     }
 366             } // switch
 367
 368             return new MeasureSpecification(resultSize, resultMode);
 369         }
 370
 371         /// <summary>
 372         /// Measure the layout and its content to determine the measured width and the measured height.<br />
 373         /// If this method is overridden, it is the subclass's responsibility to make
 374         /// sure the measured height and width are at least the layout's minimum height
 375         /// and width. <br />
 376         /// </summary>
 377         /// <param name="widthMeasureSpec">horizontal space requirements as imposed by the parent.</param>
 378         /// <param name="heightMeasureSpec">vertical space requirements as imposed by the parent.</param>
 379         /// <since_tizen> 6 </since_tizen>
 380         protected override void OnMeasure(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 381         {
 382             LayoutLength measuredWidth = new LayoutLength(0.0f);
 383             LayoutLength measuredHeight = new LayoutLength(0.0f);
 384
 385             // Layout takes size of largest child width and largest child height dimensions
 386             foreach (LayoutItem childLayout in LayoutChildren)
 387             {
 388                 if (childLayout != null)
 389                 {
 390                     MeasureChildWithMargins(childLayout, widthMeasureSpec, new LayoutLength(0), heightMeasureSpec, new LayoutLength(0));
 391                     LayoutLength childWidth = new LayoutLength(childLayout.MeasuredWidth.Size);
 392                     LayoutLength childHeight = new LayoutLength(childLayout.MeasuredHeight.Size);
 393
 394                     Extents childMargin = childLayout.Margin;
 395                     measuredWidth = new LayoutLength(Math.Max(measuredWidth.AsDecimal(), childWidth.AsDecimal() + childMargin.Start + childMargin.End));
 396                     measuredHeight = new LayoutLength(Math.Max(measuredHeight.AsDecimal(), childHeight.AsDecimal() + childMargin.Top + childMargin.Bottom));
 397                 }
 398             }
 399
 400             if (0 == LayoutChildren.Count)
 401             {
 402                 // Must be a leaf as has no children
 403                 measuredWidth = GetDefaultSize(SuggestedMinimumWidth, widthMeasureSpec);
 404                 measuredHeight = GetDefaultSize(SuggestedMinimumHeight, heightMeasureSpec);
 405             }
 406
 407             SetMeasuredDimensions(new MeasuredSize(measuredWidth, MeasuredSize.StateType.MeasuredSizeOK),
 408                                    new MeasuredSize(measuredHeight, MeasuredSize.StateType.MeasuredSizeOK));
 409         }
 410
 411         internal override void OnMeasureIndependentChildren(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 412         {
 413             foreach (var childLayout in LayoutChildren)
 414             {
 415                 if (!childLayout.SetPositionByLayout)
 416                 {
 417                     MeasureChildWithoutPadding(childLayout, widthMeasureSpec, heightMeasureSpec);
 418                 }
 419             }
 420         }
 421
 422         /// <summary>
 423         /// Called from Layout() when this layout should assign a size and position to each of its children.<br />
 424         /// Derived classes with children should override this method and call Layout() on each of their children.<br />
 425         /// </summary>
 426         /// <param name="changed">This is a new size or position for this layout.</param>
 427         /// <param name="left">Left position, relative to parent.</param>
 428         /// <param name="top"> Top position, relative to parent.</param>
 429         /// <param name="right">Right position, relative to parent.</param>
 430         /// <param name="bottom">Bottom position, relative to parent.</param>
 431         /// <since_tizen> 6 </since_tizen>
 432         protected override void OnLayout(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom)
 433         {
 434             foreach (LayoutItem childLayout in LayoutChildren)
 435             {
 436                 if (childLayout != null)
 437                 {
 438                     // Use position if explicitly set to child otherwise will be top left.
 439                     var childLeft = new LayoutLength(childLayout.Owner.PositionX);
 440                     var childTop = new LayoutLength(childLayout.Owner.PositionY);
 441
 442                     View owner = Owner;
 443
 444                     if (owner != null)
 445                     {
 446                         // Margin and Padding only supported when child anchor point is TOP_LEFT.
 447                         if (owner.PivotPoint == PivotPoint.TopLeft || (owner.PositionUsesPivotPoint == false))
 448                         {
 449                             childLeft = childLeft + owner.Padding.Start + childLayout.Margin.Start;
 450                             childTop = childTop + owner.Padding.Top + childLayout.Margin.Top;
 451                         }
 452                     }
 453                     childLayout.Layout(childLeft, childTop, childLeft + childLayout.MeasuredWidth.Size, childTop + childLayout.MeasuredHeight.Size);
 454                 }
 455             }
 456         }
 457
 458         /// <summary>
 459         /// Layout independent children those Owners have true ExcludeLayouting. <br />
 460         /// These children are required not to be affected by this layout. <br />
 461         /// </summary>
 462         internal override void OnLayoutIndependentChildren(bool changed, LayoutLength left, LayoutLength top, LayoutLength right, LayoutLength bottom)
 463         {
 464             foreach (var childLayout in LayoutChildren)
 465             {
 466                 if (!childLayout.SetPositionByLayout)
 467                 {
 468                     LayoutLength childWidth = childLayout.MeasuredWidth.Size;
 469                     LayoutLength childHeight = childLayout.MeasuredHeight.Size;
 470
 471                     LayoutLength childPositionX = new LayoutLength(childLayout.Owner.PositionX);
 472                     LayoutLength childPositionY = new LayoutLength(childLayout.Owner.PositionY);
 473
 474                     childLayout.Layout(childPositionX, childPositionY, childPositionX + childWidth, childPositionY + childHeight, true);
 475                 }
 476             }
 477         }
 478
 479         /// <summary>
 480         /// Overridden method called when the layout is attached to an owner.<br />
 481         /// </summary>
 482         /// <since_tizen> 6 </since_tizen>
 483         protected override void OnAttachedToOwner()
 484         {
 485             // Layout takes ownership of it's owner's children.
 486             foreach (View view in Owner.Children)
 487             {
 488                 AddChildToLayoutGroup(view);
 489             }
 490
 491             // Connect to owner ChildAdded signal.
 492             Owner.ChildAdded += OnChildAddedToOwner;
 493
 494             // Removing Child from the owners View will directly call the LayoutGroup removal API.
 495         }
 496
 497         /// <summary>
 498         /// Virtual method to allow derived classes to remove any children before it is removed from
 499         /// its parent.
 500         /// </summary>
 501         [EditorBrowsable(EditorBrowsableState.Never)]
 502         protected override void OnUnparent()
 503         {
 504             // Disconnect to owner ChildAdded signal.
 505             Owner.ChildAdded -= OnChildAddedToOwner;
 506         }
 507
 508         // Virtual Methods that can be overridden by derived classes.
 509
 510         /// <summary>
 511         /// Callback when child is added to container.<br />
 512         /// Derived classes can use this to set their own child properties on the child layout's owner.<br />
 513         /// </summary>
 514         /// <param name="child">The Layout child.</param>
 515         /// <since_tizen> 6 </since_tizen>
 516         protected virtual void OnChildAdd(LayoutItem child)
 517         {
 518         }
 519
 520         /// <summary>
 521         /// Callback when child is removed from container.<br />
 522         /// </summary>
 523         /// <param name="child">The Layout child.</param>
 524         /// <since_tizen> 6 </since_tizen>
 525         protected virtual void OnChildRemove(LayoutItem child)
 526         {
 527         }
 528
 529         /// <summary>
 530         /// Ask all of the children of this view to measure themselves, taking into
 531         /// account both the MeasureSpec requirements for this view and its padding.<br />
 532         /// The heavy lifting is done in GetChildMeasureSpec.<br />
 533         /// </summary>
 534         /// <param name="widthMeasureSpec">The width requirements for this view.</param>
 535         /// <param name="heightMeasureSpec">The height requirements for this view.</param>
 536         /// <since_tizen> 6 </since_tizen>
 537         protected virtual void MeasureChildren(MeasureSpecification widthMeasureSpec, MeasureSpecification heightMeasureSpec)
 538         {
 539             foreach (LayoutItem childLayout in LayoutChildren)
 540             {
 541                 MeasureChildWithMargins(childLayout, widthMeasureSpec, new LayoutLength(0), heightMeasureSpec, new LayoutLength(0));
 542             }
 543         }
 544
 545         /// <summary>
 546         /// Ask one of the children of this view to measure itself, taking into
 547         /// account both the MeasureSpec requirements for this view and its padding.<br />
 548         /// The heavy lifting is done in GetChildMeasureSpecification.<br />
 549         /// </summary>
 550         /// <param name="child">The child to measure.</param>
 551         /// <param name="parentWidthMeasureSpec">The width requirements for this view.</param>
 552         /// <param name="parentHeightMeasureSpec">The height requirements for this view.</param>
 553         /// <exception cref="ArgumentNullException"> Thrown when child is null. </exception>
 554         /// <since_tizen> 6 </since_tizen>
 555         protected virtual void MeasureChild(LayoutItem child, MeasureSpecification parentWidthMeasureSpec, MeasureSpecification parentHeightMeasureSpec)
 556         {
 557             if (null == child)
 558             {
 559                 throw new ArgumentNullException(nameof(child));
 560             }
 561
 562             View childOwner = child.Owner;
 563
 564             MeasureSpecification childWidthMeasureSpec = GetChildMeasureSpecification(
 565                         new MeasureSpecification(new LayoutLength(parentWidthMeasureSpec.Size), parentWidthMeasureSpec.Mode),
 566                         new LayoutLength(Padding.Start + Padding.End),
 567                         new LayoutLength(childOwner.WidthSpecification));
 568
 569             MeasureSpecification childHeightMeasureSpec = GetChildMeasureSpecification(
 570                         new MeasureSpecification(new LayoutLength(parentHeightMeasureSpec.Size), parentHeightMeasureSpec.Mode),
 571                         new LayoutLength(Padding.Top + Padding.Bottom),
 572                         new LayoutLength(childOwner.HeightSpecification));
 573
 574             child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
 575         }
 576
 577         /// <summary>
 578         /// Ask one of the children of this view to measure itself, taking into
 579         /// account both the MeasureSpec requirements for this view and its padding.<br />
 580         /// and margins. The heavy lifting is done in GetChildMeasureSpecification.<br />
 581         /// </summary>
 582         /// <param name="child">The child to measure.</param>
 583         /// <param name="parentWidthMeasureSpec">The width requirements for this view.</param>
 584         /// <param name="widthUsed">Extra space that has been used up by the parent horizontally (possibly by other children of the parent).</param>
 585         /// <param name="parentHeightMeasureSpec">The height requirements for this view.</param>
 586         /// <param name="heightUsed">Extra space that has been used up by the parent vertically (possibly by other children of the parent).</param>
 587         /// <exception cref="ArgumentNullException"> Thrown when child is null. </exception>
 588         /// <since_tizen> 6 </since_tizen>
 589         protected virtual void MeasureChildWithMargins(LayoutItem child, MeasureSpecification parentWidthMeasureSpec, LayoutLength widthUsed, MeasureSpecification parentHeightMeasureSpec, LayoutLength heightUsed)
 590         {
 591             if (null == child)
 592             {
 593                 throw new ArgumentNullException(nameof(child));
 594             }
 595
 596             View childOwner = child.Owner;
 597             Extents margin = childOwner.Margin;
 598
 599             MeasureSpecification childWidthMeasureSpec = GetChildMeasureSpecification(
 600                         new MeasureSpecification(
 601                             new LayoutLength(parentWidthMeasureSpec.Size + widthUsed - (margin.Start + margin.End)),
 602                             parentWidthMeasureSpec.Mode),
 603                         new LayoutLength(Padding.Start + Padding.End),
 604                         new LayoutLength(childOwner.WidthSpecification));
 605
 606             MeasureSpecification childHeightMeasureSpec = GetChildMeasureSpecification(
 607                         new MeasureSpecification(
 608                             new LayoutLength(parentHeightMeasureSpec.Size + heightUsed - (margin.Top + margin.Bottom)),
 609                             parentHeightMeasureSpec.Mode),
 610                         new LayoutLength(Padding.Top + Padding.Bottom),
 611                         new LayoutLength(childOwner.HeightSpecification));
 612             child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
 613
 614         }
 615
 616         /// <summary>
 617         /// Ask one of the children of this view to measure itself, taking into
 618         /// account both the MeasureSpec requirements for this view and without its padding.<br />
 619         /// and margins. The heavy lifting is done in GetChildMeasureSpecification.<br />
 620         /// </summary>
 621         /// <param name="child">The child to measure.</param>
 622         /// <param name="parentWidthMeasureSpec">The width requirements for this view.</param>
 623         /// <param name="parentHeightMeasureSpec">The height requirements for this view.</param>
 624         [EditorBrowsable(EditorBrowsableState.Never)]
 625         protected void MeasureChildWithoutPadding(LayoutItem child, MeasureSpecification parentWidthMeasureSpec, MeasureSpecification parentHeightMeasureSpec)
 626         {
 627             View childOwner = child.Owner;
 628
 629             MeasureSpecification childWidthMeasureSpec = GetChildMeasureSpecification(
 630                         new MeasureSpecification(new LayoutLength(parentWidthMeasureSpec.Size), parentWidthMeasureSpec.Mode),
 631                         new LayoutLength(0),
 632                         new LayoutLength(childOwner.WidthSpecification));
 633
 634             MeasureSpecification childHeightMeasureSpec = GetChildMeasureSpecification(
 635                         new MeasureSpecification(new LayoutLength(parentHeightMeasureSpec.Size), parentHeightMeasureSpec.Mode),
 636                         new LayoutLength(0),
 637                         new LayoutLength(childOwner.HeightSpecification));
 638
 639             child.Measure(childWidthMeasureSpec, childHeightMeasureSpec);
 640         }
 641
 642         /// <summary>
 643         /// Gets the value that is contained in the attached BindableProperty.
 644         /// </summary>
 645         /// <typeparam name="T">The return type of property</typeparam>
 646         /// <param name="bindable">The bindable object.</param>
 647         /// <param name="property">The BindableProperty for which to get the value.</param>
 648         /// <returns>The value that is contained in the attached BindableProperty.</returns>
 649         [EditorBrowsable(EditorBrowsableState.Never)]
 650         public static T GetAttachedValue<T>(Binding.BindableObject bindable, Binding.BindableProperty property)
 651         {
 652             if (bindable == null)
 653                 throw new ArgumentNullException(nameof(bindable));
 654
 655             return (T)bindable.GetValue(property);
 656         }
 657
 658         /// <summary>
 659         /// Sets the value of the attached property.
 660         /// </summary>
 661         /// <param name="bindable">The bindable object.</param>
 662         /// <param name="property">The BindableProperty on which to assign a value.</param>
 663         /// <param name="value">The value to set.</param>
 664         [EditorBrowsable(EditorBrowsableState.Never)]
 665         public static void SetAttachedValue(Binding.BindableObject bindable, Binding.BindableProperty property, object value)
 666         {
 667             if (bindable == null)
 668                 throw new ArgumentNullException(nameof(bindable));
 669
 670             bindable.SetValueCore(property, value, SetValueFlags.None, SetValuePrivateFlags.ManuallySet, false);
 671         }
 672         internal static void OnChildPropertyChanged(Binding.BindableObject bindable, object oldValue, object newValue)
 673         {
 674             // Unused parameters
 675             _ = oldValue;
 676             _ = newValue;
 677
 678             View view = bindable as View;
 679             view?.Layout?.RequestLayout();
 680         }
 681
 682         internal static Binding.BindableProperty.ValidateValueDelegate ValidateEnum(int enumMin, int enumMax)
 683         {
 684             return (Binding.BindableObject bindable, object value) =>
 685             {
 686                 int @enum = (int)value;
 687                 return enumMin <= @enum && @enum <= enumMax;
 688             };
 689         }
 690     }
 691 }