src/Tizen.NUI/src/public/BaseComponents/ViewPublicMethods.cs

   1 /*
   2  * Copyright(c) 2020 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
  18 using System;
  19 using System.ComponentModel;
  20 using System.Reflection;
  21 using System.Runtime.InteropServices;
  22 using Tizen.NUI.Binding;
  23
  24 namespace Tizen.NUI.BaseComponents
  25 {
  26     /// <summary>
  27     /// View is the base class for all views.
  28     /// </summary>
  29     /// <since_tizen> 3 </since_tizen>
  30     public partial class View
  31     {
  32         /// <summary>
  33         /// Perform an action on a visual registered to this view. <br />
  34         /// Visuals will have actions. This API is used to perform one of these actions with the given attributes.
  35         /// </summary>
  36         /// <param name="propertyIndexOfVisual">The Property index of the visual.</param>
  37         /// <param name="propertyIndexOfActionId">The action to perform. See Visual to find the supported actions.</param>
  38         /// <param name="attributes">Optional attributes for the action.</param>
  39         /// <since_tizen> 5 </since_tizen>
  40         public void DoAction(int propertyIndexOfVisual, int propertyIndexOfActionId, PropertyValue attributes)
  41         {
  42             Interop.View.DoAction(SwigCPtr, propertyIndexOfVisual, propertyIndexOfActionId, PropertyValue.getCPtr(attributes));
  43             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
  44         }
  45
  46         /// <summary>
  47         /// Creates an animation to animate the background color visual. If there is no
  48         /// background visual, creates one with transparent black as it's mixColor.
  49         /// </summary>
  50         /// <since_tizen> 3 </since_tizen>
  51         public Animation AnimateBackgroundColor(object destinationValue,
  52                                                  int startTime,
  53                                                  int endTime,
  54                                                  AlphaFunction.BuiltinFunctions? alphaFunction = null,
  55                                                  object initialValue = null)
  56         {
  57             Tizen.NUI.PropertyMap background = Background;
  58
  59             if (background.Empty())
  60             {
  61                 // If there is no background yet, ensure there is a transparent
  62                 // color visual
  63                 BackgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
  64                 background = Background;
  65             }
  66             return AnimateColor("background", destinationValue, startTime, endTime, alphaFunction, initialValue);
  67         }
  68
  69         /// <summary>
  70         /// Creates an animation to animate the mixColor of the named visual.
  71         /// </summary>
  72         /// <since_tizen> 3 </since_tizen>
  73         public Animation AnimateColor(string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialColor = null)
  74         {
  75             Animation animation = null;
  76             using (PropertyMap animator = new PropertyMap())
  77             using (PropertyMap timePeriod = new PropertyMap())
  78             using (PropertyValue pvDuration = new PropertyValue((endTime - startTime) / 1000.0f))
  79             using (PropertyValue pvDelay = new PropertyValue(startTime / 1000.0f))
  80             using (PropertyMap transition = new PropertyMap())
  81             using (PropertyValue pvTarget = new PropertyValue(targetVisual))
  82             using (PropertyValue pvProperty = new PropertyValue("mixColor"))
  83             using (PropertyValue destValue = PropertyValue.CreateFromObject(destinationColor))
  84             {
  85                 if (alphaFunction != null)
  86                 {
  87                     using (PropertyValue pvAlpha = new PropertyValue(AlphaFunction.BuiltinToPropertyKey(alphaFunction)))
  88                     {
  89                         animator.Add("alphaFunction", pvAlpha);
  90                     }
  91                 }
  92
  93                 timePeriod.Add("duration", pvDuration);
  94                 timePeriod.Add("delay", pvDelay);
  95                 using (PropertyValue pvTimePeriod = new PropertyValue(timePeriod))
  96                 {
  97                     animator.Add("timePeriod", pvTimePeriod);
  98                 }
  99                 using (PropertyValue pvAnimator = new PropertyValue(animator))
 100                 {
 101                     transition.Add("animator", pvAnimator);
 102                 }
 103                 transition.Add("target", pvTarget);
 104                 transition.Add("property", pvProperty);
 105
 106                 if (initialColor != null)
 107                 {
 108                     using (PropertyValue initValue = PropertyValue.CreateFromObject(initialColor))
 109                     {
 110                         transition.Add("initialValue", initValue);
 111                     }
 112                 }
 113
 114                 transition.Add("targetValue", destValue);
 115                 using (TransitionData transitionData = new TransitionData(transition))
 116                 {
 117                     animation = new Animation(Interop.View.CreateTransition(SwigCPtr, TransitionData.getCPtr(transitionData)), true);
 118                 }
 119                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 120                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 121             }
 122             return animation;
 123         }
 124
 125         // From Container Base class
 126         /// <summary>
 127         /// Adds a child view to this view.
 128         /// </summary>
 129         /// <seealso cref="Container.Add" />
 130         /// <since_tizen> 4 </since_tizen>
 131         public override void Add(View child)
 132         {
 133             bool hasLayout = (layout != null);
 134
 135             if (null == child)
 136             {
 137                 Tizen.Log.Fatal("NUI", "Child is null");
 138                 return;
 139             }
 140
 141             Container oldParent = child.GetParent();
 142             if (oldParent != this)
 143             {
 144                 // If child already has a parent then re-parent child
 145                 if (oldParent != null)
 146                 {
 147                     if (child.Layout != null)
 148                     {
 149                         child.Layout.SetReplaceFlag();
 150                     }
 151                     oldParent.Remove(child);
 152                 }
 153                 child.InternalParent = this;
 154
 155                 Interop.Actor.Add(SwigCPtr, View.getCPtr(child));
 156
 157                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 158                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 159                 Children.Add(child);
 160
 161                 if (ChildAdded != null)
 162                 {
 163                     ChildAddedEventArgs e = new ChildAddedEventArgs
 164                     {
 165                         Added = child
 166                     };
 167                     ChildAdded(this, e);
 168                 }
 169
 170                 AddChildBindableObject(child);
 171             }
 172         }
 173
 174         /// <summary>
 175         /// Removes a child view from this View. If the view was not a child of this view, this is a no-op.
 176         /// </summary>
 177         /// <seealso cref="Container.Remove" />
 178         /// <since_tizen> 4 </since_tizen>
 179         /// <exception cref="InvalidOperationException">Thrown when deleting a view that is not a child of this view</exception>
 180         public override void Remove(View child)
 181         {
 182             if (child == null || child.GetParent() == null) // Early out if child null.
 183                 return;
 184
 185             if (child.GetParent() != this)
 186             {
 187                 //throw new System.InvalidOperationException("You have deleted a view that is not a child of this view.");
 188                 Tizen.Log.Error("NUI", "You have deleted a view that is not a child of this view.");
 189             }
 190
 191             bool hasLayout = (layout != null);
 192
 193             // If View has a layout then do a deferred child removal
 194             // Actual child removal is performed by the layouting system so
 195             // transitions can be completed.
 196             if (hasLayout)
 197             {
 198                 (layout as LayoutGroup)?.RemoveChildFromLayoutGroup(child);
 199             }
 200
 201             RemoveChild(child);
 202         }
 203
 204         /// <summary>
 205         /// Retrieves a child view by index.
 206         /// </summary>
 207         /// <seealso cref="Container.GetChildAt" />
 208         /// <since_tizen> 4 </since_tizen>
 209         public override View GetChildAt(uint index)
 210         {
 211             if (index < Children.Count)
 212             {
 213                 return Children[Convert.ToInt32(index)];
 214             }
 215             else
 216             {
 217                 return null;
 218             }
 219         }
 220
 221         /// <summary>
 222         /// Retrieves the number of children held by the view.
 223         /// </summary>
 224         /// <seealso cref="Container.GetChildCount" />
 225         /// <since_tizen> 4 </since_tizen>
 226         [Obsolete("Deprecated in API9, will be removed in API11. Please use ChildCount property instead!")]
 227         public override uint GetChildCount()
 228         {
 229             return Convert.ToUInt32(Children.Count);
 230         }
 231
 232         /// <summary>
 233         /// Gets the views parent.
 234         /// </summary>
 235         /// <seealso cref="Container.GetParent()" />
 236         /// <since_tizen> 4 </since_tizen>
 237         public override Container GetParent()
 238         {
 239             return InternalParent as Container;
 240         }
 241
 242         /// <summary>
 243         /// Queries whether the view has a focus.
 244         /// </summary>
 245         /// <returns>True if this view has a focus.</returns>
 246         /// <since_tizen> 3 </since_tizen>
 247         public bool HasFocus()
 248         {
 249             bool ret = false;
 250             if (SwigCPtr.Handle != global::System.IntPtr.Zero)
 251             {
 252                 ret = Interop.View.HasKeyInputFocus(SwigCPtr);
 253                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 254             }
 255             else
 256             {
 257                 Tizen.Log.Error("NUI", "swigCPtr of view is already disposed.");
 258             }
 259             return ret;
 260         }
 261
 262         /// <summary>
 263         /// Sets the name of the style to be applied to the view.
 264         /// </summary>
 265         /// <param name="styleName">A string matching a style described in a stylesheet.</param>
 266         /// <since_tizen> 3 </since_tizen>
 267         [Obsolete("Deprecated in API9, will be removed in API11. Please use StyleName property instead!")]
 268         public void SetStyleName(string styleName)
 269         {
 270             Interop.View.SetStyleName(SwigCPtr, styleName);
 271             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 272         }
 273
 274         /// <summary>
 275         /// Retrieves the name of the style to be applied to the view (if any).
 276         /// </summary>
 277         /// <returns>A string matching a style, or an empty string.</returns>
 278         /// <since_tizen> 3 </since_tizen>
 279         [Obsolete("Deprecated in API9, will be removed in API11. Please use StyleName property instead!")]
 280         public string GetStyleName()
 281         {
 282             string ret = Interop.View.GetStyleName(SwigCPtr);
 283             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 284             return ret;
 285         }
 286
 287         /// <summary>
 288         /// Clears the background.
 289         /// </summary>
 290         /// <since_tizen> 3 </since_tizen>
 291         public void ClearBackground()
 292         {
 293             Interop.View.ClearBackground(SwigCPtr);
 294             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 295         }
 296
 297         /// <summary>
 298         /// Shows the view.
 299         /// </summary>
 300         /// <remarks>
 301         /// This is an asynchronous method.
 302         /// </remarks>
 303         /// <since_tizen> 3 </since_tizen>
 304         public void Show()
 305         {
 306             if (Accessibility.Accessibility.Enabled && ((GetAccessibilityStates() & AccessibilityStates.Modal) != 0))
 307             {
 308                 RegisterPopup();
 309             }
 310
 311             SetVisible(true);
 312         }
 313
 314         /// <summary>
 315         /// Hides the view.
 316         /// </summary>
 317         /// <remarks>
 318         /// This is an asynchronous method.
 319         /// If the view is hidden, then the view and its children will not be rendered.
 320         /// This is regardless of the individual visibility of the children, i.e., the view will only be rendered if all of its parents are shown.
 321         /// </remarks>
 322         /// <since_tizen> 3 </since_tizen>
 323         public void Hide()
 324         {
 325             SetVisible(false);
 326
 327             if (Accessibility.Accessibility.Enabled && ((GetAccessibilityStates() & AccessibilityStates.Modal) != 0))
 328             {
 329                 RemovePopup();
 330             }
 331         }
 332
 333         /// <summary>
 334         /// Raises the view above all other views.
 335         /// </summary>
 336         /// <remarks>
 337         /// Sibling order of views within the parent will be updated automatically.
 338         /// Once a raise or lower API is used, that view will then have an exclusive sibling order independent of insertion.
 339         /// </remarks>
 340         /// <since_tizen> 3 </since_tizen>
 341         public void RaiseToTop()
 342         {
 343             var parentChildren = GetParent()?.Children;
 344
 345             if (parentChildren != null)
 346             {
 347                 parentChildren.Remove(this);
 348                 parentChildren.Add(this);
 349
 350                 LayoutGroup layout = Layout as LayoutGroup;
 351                 layout?.ChangeLayoutSiblingOrder(parentChildren.Count - 1);
 352
 353                 Interop.NDalic.RaiseToTop(SwigCPtr);
 354                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 355                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 356             }
 357
 358         }
 359
 360         /// <summary>
 361         /// Lowers the view to the bottom of all views.
 362         /// </summary>
 363         /// <remarks>
 364         /// The sibling order of views within the parent will be updated automatically.
 365         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
 366         /// </remarks>
 367         /// <since_tizen> 3 </since_tizen>
 368         public void LowerToBottom()
 369         {
 370             var parentChildren = GetParent()?.Children;
 371
 372             if (parentChildren != null)
 373             {
 374                 parentChildren.Remove(this);
 375                 parentChildren.Insert(0, this);
 376
 377                 LayoutGroup layout = Layout as LayoutGroup;
 378                 layout?.ChangeLayoutSiblingOrder(0);
 379
 380                 Interop.NDalic.LowerToBottom(SwigCPtr);
 381                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 382                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 383             }
 384         }
 385
 386         /// <summary>
 387         /// Queries if all resources required by a view are loaded and ready.
 388         /// </summary>
 389         /// <remarks>Most resources are only loaded when the control is placed on the stage.
 390         /// </remarks>
 391         /// <since_tizen> 3 </since_tizen>
 392         public bool IsResourceReady()
 393         {
 394             bool ret = Interop.View.IsResourceReady(SwigCPtr);
 395             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 396             return ret;
 397         }
 398
 399         /// <summary>
 400         /// Gets the parent layer of this view.If a view has no parent, this method does not do anything.
 401         /// </summary>
 402         /// <pre>The view has been initialized. </pre>
 403         /// <returns>The parent layer of view </returns>
 404         /// <since_tizen> 5 </since_tizen>
 405         public Layer GetLayer()
 406         {
 407             //to fix memory leak issue, match the handle count with native side.
 408             IntPtr cPtr = Interop.Actor.GetLayer(SwigCPtr);
 409             Layer ret = this.GetInstanceSafely<Layer>(cPtr);
 410             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 411             return ret;
 412         }
 413
 414         /// <summary>
 415         /// Removes a view from its parent view or layer. If a view has no parent, this method does nothing.
 416         /// </summary>
 417         /// <pre>The (child) view has been initialized. </pre>
 418         /// <since_tizen> 4 </since_tizen>
 419         public void Unparent()
 420         {
 421             GetParent()?.Remove(this);
 422         }
 423
 424         /// <summary>
 425         /// Search through this view's hierarchy for a view with the given name.
 426         /// The view itself is also considered in the search.
 427         /// </summary>
 428         /// <pre>The view has been initialized.</pre>
 429         /// <param name="viewName">The name of the view to find.</param>
 430         /// <returns>A handle to the view if found, or an empty handle if not.</returns>
 431         /// <since_tizen> 3 </since_tizen>
 432         public View FindChildByName(string viewName)
 433         {
 434             //to fix memory leak issue, match the handle count with native side.
 435             IntPtr cPtr = Interop.Actor.FindChildByName(SwigCPtr, viewName);
 436             View ret = this.GetInstanceSafely<View>(cPtr);
 437             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 438             return ret;
 439         }
 440
 441         /// <summary>
 442         /// Converts screen coordinates into the view's coordinate system using the default camera.
 443         /// </summary>
 444         /// <pre>The view has been initialized.</pre>
 445         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5).</remarks>
 446         /// <param name="localX">On return, the X-coordinate relative to the view.</param>
 447         /// <param name="localY">On return, the Y-coordinate relative to the view.</param>
 448         /// <param name="screenX">The screen X-coordinate.</param>
 449         /// <param name="screenY">The screen Y-coordinate.</param>
 450         /// <returns>True if the conversion succeeded.</returns>
 451         /// <since_tizen> 3 </since_tizen>
 452         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
 453         {
 454             bool ret = Interop.Actor.ScreenToLocal(SwigCPtr, out localX, out localY, screenX, screenY);
 455             if (NDalicPINVOKE.SWIGPendingException.Pending)
 456                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 457             return ret;
 458         }
 459
 460         /// <summary>
 461         /// Sets the relative to parent size factor of the view.<br />
 462         /// This factor is only used when ResizePolicy is set to either:
 463         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br />
 464         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br />
 465         /// </summary>
 466         /// <pre>The view has been initialized.</pre>
 467         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis.</param>
 468         /// <since_tizen> 3 </since_tizen>
 469         public void SetSizeModeFactor(Vector3 factor)
 470         {
 471             Interop.Actor.SetSizeModeFactor(SwigCPtr, Vector3.getCPtr(factor));
 472             if (NDalicPINVOKE.SWIGPendingException.Pending)
 473                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 474         }
 475         /// <summary>
 476         /// Calculates the height of the view given a width.<br />
 477         /// The natural size is used for default calculation.<br />
 478         /// Size 0 is treated as aspect ratio 1:1.<br />
 479         /// </summary>
 480         /// <param name="width">The width to use.</param>
 481         /// <returns>The height based on the width.</returns>
 482         /// <since_tizen> 3 </since_tizen>
 483         public float GetHeightForWidth(float width)
 484         {
 485             float ret = Interop.Actor.GetHeightForWidth(SwigCPtr, width);
 486             if (NDalicPINVOKE.SWIGPendingException.Pending)
 487                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 488             return ret;
 489         }
 490
 491         /// <summary>
 492         /// Calculates the width of the view given a height.<br />
 493         /// The natural size is used for default calculation.<br />
 494         /// Size 0 is treated as aspect ratio 1:1.<br />
 495         /// </summary>
 496         /// <param name="height">The height to use.</param>
 497         /// <returns>The width based on the height.</returns>
 498         /// <since_tizen> 3 </since_tizen>
 499         public float GetWidthForHeight(float height)
 500         {
 501             float ret = Interop.Actor.GetWidthForHeight(SwigCPtr, height);
 502             if (NDalicPINVOKE.SWIGPendingException.Pending)
 503                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 504             return ret;
 505         }
 506
 507         /// <summary>
 508         /// Return the amount of size allocated for relayout.
 509         /// </summary>
 510         /// <param name="dimension">The dimension to retrieve.</param>
 511         /// <returns>Return the size.</returns>
 512         /// <since_tizen> 3 </since_tizen>
 513         public float GetRelayoutSize(DimensionType dimension)
 514         {
 515             float ret = Interop.Actor.GetRelayoutSize(SwigCPtr, (int)dimension);
 516             if (NDalicPINVOKE.SWIGPendingException.Pending)
 517                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 518             return ret;
 519         }
 520
 521         /// <summary>
 522         /// Set the padding for the view.
 523         /// </summary>
 524         /// <param name="padding">Padding for the view.</param>
 525         /// <since_tizen> 3 </since_tizen>
 526         // [Obsolete("Deprecated in API9, will be removed in API11. Please use Padding property instead!")]
 527         public void SetPadding(PaddingType padding)
 528         {
 529             Interop.Actor.SetPadding(SwigCPtr, PaddingType.getCPtr(padding));
 530             if (NDalicPINVOKE.SWIGPendingException.Pending)
 531                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 532         }
 533
 534         /// <summary>
 535         /// Return the value of padding for the view.
 536         /// </summary>
 537         /// <param name="paddingOut">the value of padding for the view</param>
 538         /// <since_tizen> 3 </since_tizen>
 539         [Obsolete("Deprecated in API9, will be removed in API11. Please use Padding property instead!")]
 540         public void GetPadding(PaddingType paddingOut)
 541         {
 542             Interop.Actor.GetPadding(SwigCPtr, PaddingType.getCPtr(paddingOut));
 543             if (NDalicPINVOKE.SWIGPendingException.Pending)
 544                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 545         }
 546
 547         /// <since_tizen> 3 </since_tizen>
 548         public uint AddRenderer(Renderer renderer)
 549         {
 550             uint ret = Interop.Actor.AddRenderer(SwigCPtr, Renderer.getCPtr(renderer));
 551             if (NDalicPINVOKE.SWIGPendingException.Pending)
 552                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 553             return ret;
 554         }
 555
 556         /// <since_tizen> 3 </since_tizen>
 557         public Renderer GetRendererAt(uint index)
 558         {
 559             //to fix memory leak issue, match the handle count with native side.
 560             IntPtr cPtr = Interop.Actor.GetRendererAt(SwigCPtr, index);
 561             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
 562             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as Renderer;
 563             if (cPtr != null && ret == null)
 564             {
 565                 ret = new Renderer(cPtr, false);
 566                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 567                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 568                 return ret;
 569             }
 570             Interop.BaseHandle.DeleteBaseHandle(CPtr);
 571             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
 572
 573             if (NDalicPINVOKE.SWIGPendingException.Pending)
 574                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 575             return ret;
 576         }
 577
 578         /// <since_tizen> 3 </since_tizen>
 579         public void RemoveRenderer(Renderer renderer)
 580         {
 581             Interop.Actor.RemoveRenderer(SwigCPtr, Renderer.getCPtr(renderer));
 582             if (NDalicPINVOKE.SWIGPendingException.Pending)
 583                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 584         }
 585
 586         /// <since_tizen> 3 </since_tizen>
 587         public void RemoveRenderer(uint index)
 588         {
 589             Interop.Actor.RemoveRenderer(SwigCPtr, index);
 590             if (NDalicPINVOKE.SWIGPendingException.Pending)
 591                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 592         }
 593
 594         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 595         [EditorBrowsable(EditorBrowsableState.Never)]
 596         public void RotateBy(Degree angle, Vector3 axis)
 597         {
 598             Interop.ActorInternal.RotateByDegree(SwigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
 599             if (NDalicPINVOKE.SWIGPendingException.Pending)
 600                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 601         }
 602
 603         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 604         [EditorBrowsable(EditorBrowsableState.Never)]
 605         public void RotateBy(Radian angle, Vector3 axis)
 606         {
 607             Interop.ActorInternal.RotateByRadian(SwigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
 608             if (NDalicPINVOKE.SWIGPendingException.Pending)
 609                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 610         }
 611
 612         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 613         [EditorBrowsable(EditorBrowsableState.Never)]
 614         public void RotateBy(Rotation relativeRotation)
 615         {
 616             Interop.ActorInternal.RotateByQuaternion(SwigCPtr, Rotation.getCPtr(relativeRotation));
 617             if (NDalicPINVOKE.SWIGPendingException.Pending)
 618                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 619         }
 620
 621         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 622         [EditorBrowsable(EditorBrowsableState.Never)]
 623         public void ScaleBy(Vector3 relativeScale)
 624         {
 625             Interop.ActorInternal.ScaleBy(SwigCPtr, Vector3.getCPtr(relativeScale));
 626             if (NDalicPINVOKE.SWIGPendingException.Pending)
 627                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 628         }
 629
 630         /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
 631         [EditorBrowsable(EditorBrowsableState.Never)]
 632         public void SetColorMode(ColorMode colorMode)
 633         {
 634             Interop.ActorInternal.SetColorMode(SwigCPtr, (int)colorMode);
 635             if (NDalicPINVOKE.SWIGPendingException.Pending)
 636                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 637         }
 638
 639         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
 640         [EditorBrowsable(EditorBrowsableState.Never)]
 641         public void ObjectDump()
 642         {
 643             if (0 == Children.Count)
 644             {
 645                 Type type = this.GetType();
 646                 PropertyInfo[] properties = type.GetProperties(BindingFlags.Public | BindingFlags.Instance);
 647                 foreach (var property in properties)
 648                 {
 649                     if (null != property && property.CanRead)
 650                     {
 651                         Tizen.Log.Fatal("NUI", $"{type.Name} {property.Name} ({property.PropertyType.Name}): {property.GetValueString(this, property.PropertyType)}");
 652                     }
 653                 }
 654                 return;
 655             }
 656
 657             foreach (View view in Children)
 658             {
 659                 view.ObjectDump();
 660             }
 661         }
 662
 663         /// <summary>
 664         /// Search through this View's hierarchy for a View with the given unique ID.
 665         /// The View itself is also considered in the search.
 666         /// </summary>
 667         /// <param name="id">The ID of the View to find</param>
 668         /// <returns>A View if found or a null if not</returns>
 669         [EditorBrowsable(EditorBrowsableState.Never)]
 670         [Obsolete("This will be removed at API11! please use FindDescendantByID(uint id) instead!")]
 671         public View FindChildByID(uint id)
 672         {
 673             IntPtr cPtr = Interop.Actor.FindChildById(SwigCPtr, id);
 674             View ret = this.GetInstanceSafely<View>(cPtr);
 675             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 676             return ret;
 677         }
 678
 679         /// <summary>
 680         /// Search through this View's hierarchy for a View with the given unique ID.
 681         /// </summary>
 682         /// <param name="id">The ID of the View to find.</param>
 683         /// <returns>A handle to the View if found, or an empty handle if not.</returns>
 684         /// <since_tizen> 9 </since_tizen>
 685         public View FindDescendantByID(uint id)
 686         {
 687             return FindChildById(id);
 688         }
 689
 690         /// <summary>
 691         /// Raise view above the next sibling view.
 692         /// </summary>
 693         /// <since_tizen> 9 </since_tizen>
 694         public void Raise()
 695         {
 696             var parentChildren = GetParent()?.Children;
 697
 698             if (parentChildren != null)
 699             {
 700                 int currentIndex = parentChildren.IndexOf(this);
 701
 702                 // If the view is not already the last item in the list.
 703                 if (currentIndex >= 0 && currentIndex < parentChildren.Count - 1)
 704                 {
 705                     View temp = parentChildren[currentIndex + 1];
 706                     parentChildren[currentIndex + 1] = this;
 707                     parentChildren[currentIndex] = temp;
 708
 709                     Interop.NDalic.Raise(SwigCPtr);
 710                     if (NDalicPINVOKE.SWIGPendingException.Pending)
 711                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 712                 }
 713             }
 714         }
 715
 716         /// <summary>
 717         /// Lower the view below the previous sibling view.
 718         /// </summary>
 719         /// <since_tizen> 9 </since_tizen>
 720         public void Lower()
 721         {
 722             var parentChildren = GetParent()?.Children;
 723
 724             if (parentChildren != null)
 725             {
 726                 int currentIndex = parentChildren.IndexOf(this);
 727
 728                 // If the view is not already the first item in the list.
 729                 if (currentIndex > 0 && currentIndex < parentChildren.Count)
 730                 {
 731                     View temp = parentChildren[currentIndex - 1];
 732                     parentChildren[currentIndex - 1] = this;
 733                     parentChildren[currentIndex] = temp;
 734
 735                     Interop.NDalic.Lower(SwigCPtr);
 736                     if (NDalicPINVOKE.SWIGPendingException.Pending)
 737                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 738                 }
 739             }
 740         }
 741
 742         /// <summary>
 743         /// Raises the view to above the target view.
 744         /// </summary>
 745         /// <remarks>The sibling order of views within the parent will be updated automatically.
 746         /// Views on the level above the target view will still be shown above this view.
 747         /// Once a raise or lower API is used then that view will have an exclusive sibling order independent of insertion.
 748         /// </remarks>
 749         /// <param name="target">Will be raised above this view.</param>
 750         /// <since_tizen> 9 </since_tizen>
 751         public void RaiseAbove(View target)
 752         {
 753             var parentChildren = GetParent()?.Children;
 754
 755             if (parentChildren != null)
 756             {
 757                 int currentIndex = parentChildren.IndexOf(this);
 758                 int targetIndex = parentChildren.IndexOf(target);
 759
 760                 if (currentIndex < 0 || targetIndex < 0 ||
 761                     currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
 762                 {
 763                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
 764                     return;
 765                 }
 766                 // If the currentIndex is less than the target index and the target has the same parent.
 767                 if (currentIndex < targetIndex)
 768                 {
 769                     parentChildren.Remove(this);
 770                     parentChildren.Insert(targetIndex, this);
 771
 772                     Interop.NDalic.RaiseAbove(SwigCPtr, View.getCPtr(target));
 773                     if (NDalicPINVOKE.SWIGPendingException.Pending)
 774                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 775                 }
 776             }
 777
 778         }
 779
 780         /// <summary>
 781         /// Lowers the view to below the target view.
 782         /// </summary>
 783         /// <remarks>The sibling order of views within the parent will be updated automatically.
 784         /// Once a raise or lower API is used then that view will have an exclusive sibling order independent of insertion.
 785         /// </remarks>
 786         /// <param name="target">Will be lowered below this view.</param>
 787         /// <since_tizen> 9 </since_tizen>
 788         public void LowerBelow(View target)
 789         {
 790             var parentChildren = GetParent()?.Children;
 791
 792             if (parentChildren != null)
 793             {
 794                 int currentIndex = parentChildren.IndexOf(this);
 795                 int targetIndex = parentChildren.IndexOf(target);
 796                 if (currentIndex < 0 || targetIndex < 0 ||
 797                    currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
 798                 {
 799                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
 800                     return;
 801                 }
 802
 803                 // If the currentIndex is not already the 0th index and the target has the same parent.
 804                 if ((currentIndex != 0) && (targetIndex != -1) &&
 805                     (currentIndex > targetIndex))
 806                 {
 807                     parentChildren.Remove(this);
 808                     parentChildren.Insert(targetIndex, this);
 809
 810                     Interop.NDalic.LowerBelow(SwigCPtr, View.getCPtr(target));
 811                     if (NDalicPINVOKE.SWIGPendingException.Pending)
 812                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 813                 }
 814             }
 815
 816         }
 817
 818     }
 819 }