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

   1 /*
   2  * Copyright(c) 2022 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 global::System.Diagnostics;
  21 using Tizen.NUI;
  22
  23 namespace Tizen.NUI.BaseComponents
  24 {
  25     /// <summary>
  26     /// View is the base class for all views.
  27     /// </summary>
  28     /// <since_tizen> 3 </since_tizen>
  29     public partial class View
  30     {
  31         internal string styleName;
  32
  33         internal virtual LayoutItem CreateDefaultLayout()
  34         {
  35             return new AbsoluteLayout();
  36         }
  37
  38         internal class ThemeData
  39         {
  40             [Flags]
  41             private enum States : byte
  42             {
  43                 None = 0,
  44                 ControlStatePropagation = 1 << 0,
  45                 ThemeChangeSensitive = 1 << 1,
  46                 ThemeApplied = 1 << 2, // It is true when the view has valid style name or the platform theme has a component style for this view type.
  47                                        // That indicates the view can have different styles by theme.
  48                                        // Hence if the current state has ThemeApplied and ThemeChangeSensitive, the view will change its style by theme changing.
  49                 ListeningThemeChangeEvent = 1 << 3,
  50             };
  51
  52             private States states = ThemeManager.ApplicationThemeChangeSensitive ? States.ThemeChangeSensitive : States.None;
  53             public ViewStyle viewStyle;
  54             public ControlState controlStates = ControlState.Normal;
  55             public ViewSelectorData selectorData;
  56
  57             public bool ControlStatePropagation
  58             {
  59                 get => ((states & States.ControlStatePropagation) != 0);
  60                 set => SetOption(States.ControlStatePropagation, value);
  61             }
  62
  63             public bool ThemeChangeSensitive
  64             {
  65                 get => ((states & States.ThemeChangeSensitive) != 0);
  66                 set => SetOption(States.ThemeChangeSensitive, value);
  67             }
  68
  69             public bool ThemeApplied
  70             {
  71                 get => ((states & States.ThemeApplied) != 0);
  72                 set => SetOption(States.ThemeApplied, value);
  73             }
  74
  75             public bool ListeningThemeChangeEvent
  76             {
  77                 get => ((states & States.ListeningThemeChangeEvent) != 0);
  78                 set => SetOption(States.ListeningThemeChangeEvent, value);
  79             }
  80
  81             private void SetOption(States option, bool value)
  82             {
  83                 if (value) states |= option;
  84                 else states &= ~option;
  85             }
  86         }
  87
  88         /// <summary>
  89         /// The color mode of View.
  90         /// This specifies whether the View uses its own color, or inherits its parent color.
  91         /// The default is ColorMode.UseOwnMultiplyParentColor.
  92         /// </summary>
  93         internal ColorMode ColorMode
  94         {
  95             set
  96             {
  97                 SetColorMode(value);
  98             }
  99             get
 100             {
 101                 return GetColorMode();
 102             }
 103         }
 104
 105         internal LayoutLength SuggestedMinimumWidth
 106         {
 107             get
 108             {
 109                 float result = Interop.Actor.GetSuggestedMinimumWidth(SwigCPtr);
 110                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 111                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 112                 return new LayoutLength(result);
 113             }
 114         }
 115
 116         internal LayoutLength SuggestedMinimumHeight
 117         {
 118             get
 119             {
 120                 float result = Interop.Actor.GetSuggestedMinimumHeight(SwigCPtr);
 121                 if (NDalicPINVOKE.SWIGPendingException.Pending)
 122                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 123                 return new LayoutLength(result);
 124             }
 125         }
 126
 127         internal float WorldPositionX
 128         {
 129             get
 130             {
 131
 132                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionX);
 133             }
 134         }
 135
 136         internal float WorldPositionY
 137         {
 138             get
 139             {
 140
 141                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionY);
 142             }
 143         }
 144
 145         internal float WorldPositionZ
 146         {
 147             get
 148             {
 149
 150                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.WorldPositionZ);
 151             }
 152         }
 153
 154         internal bool FocusState
 155         {
 156             get
 157             {
 158                 return IsKeyboardFocusable();
 159             }
 160             set
 161             {
 162                 SetKeyboardFocusable(value);
 163             }
 164         }
 165
 166         internal void SetLayout(LayoutItem layout)
 167         {
 168             LayoutCount++;
 169
 170             this.layout = layout;
 171             this.layout?.AttachToOwner(this);
 172             this.layout?.RequestLayout();
 173         }
 174
 175         internal void AttachTransitionsToChildren(LayoutTransition transition)
 176         {
 177             // Iterate children, adding the transition unless a transition
 178             // for the same condition and property has already been
 179             // explicitly added.
 180             foreach (View view in Children)
 181             {
 182                 LayoutTransitionsHelper.AddTransitionForCondition(view.LayoutTransitions, transition.Condition, transition, false);
 183             }
 184         }
 185
 186         internal float ParentOriginX
 187         {
 188             get
 189             {
 190
 191                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginX);
 192             }
 193             set
 194             {
 195
 196                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.WorldPositionX, value);
 197                 NotifyPropertyChanged();
 198             }
 199         }
 200
 201         internal float ParentOriginY
 202         {
 203             get
 204             {
 205
 206                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginY);
 207             }
 208             set
 209             {
 210
 211                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.ParentOriginY, value);
 212                 NotifyPropertyChanged();
 213             }
 214         }
 215
 216         internal float ParentOriginZ
 217         {
 218             get
 219             {
 220
 221                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.ParentOriginZ);
 222             }
 223             set
 224             {
 225
 226                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.ParentOriginZ, value);
 227                 NotifyPropertyChanged();
 228             }
 229         }
 230
 231         internal float PivotPointX
 232         {
 233             get
 234             {
 235
 236                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointX);
 237             }
 238             set
 239             {
 240
 241                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointX, value);
 242             }
 243         }
 244
 245         internal float PivotPointY
 246         {
 247             get
 248             {
 249
 250                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointY);
 251             }
 252             set
 253             {
 254
 255                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointY, value);
 256             }
 257         }
 258
 259         internal float PivotPointZ
 260         {
 261             get
 262             {
 263
 264                 return Object.InternalGetPropertyFloat(SwigCPtr, View.Property.AnchorPointZ);
 265             }
 266             set
 267             {
 268
 269                 Object.InternalSetPropertyFloat(SwigCPtr, View.Property.AnchorPointZ, value);
 270             }
 271         }
 272
 273         internal Matrix WorldMatrix
 274         {
 275             get
 276             {
 277                 Matrix returnValue = new Matrix();
 278                 PropertyValue wordMatrix = GetProperty(View.Property.WorldMatrix);
 279                 wordMatrix?.Get(returnValue);
 280                 wordMatrix?.Dispose();
 281                 return returnValue;
 282             }
 283         }
 284
 285         /// <summary>
 286         /// The number of layouts including view's layout and children's layouts.
 287         /// This can be used to set/unset Process callback to calculate Layout.
 288         /// </summary>
 289         internal int LayoutCount
 290         {
 291             get
 292             {
 293                 return layoutCount;
 294             }
 295
 296             set
 297             {
 298                 if (layoutCount == value) return;
 299
 300                 if (value < 0) throw new global::System.ArgumentOutOfRangeException(nameof(LayoutCount), "LayoutCount(" + LayoutCount + ") should not be less than zero");
 301
 302                 int diff = value - layoutCount;
 303                 layoutCount = value;
 304
 305                 if (InternalParent != null)
 306                 {
 307                     var parentView = InternalParent as View;
 308                     if (parentView != null)
 309                     {
 310                         parentView.LayoutCount += diff;
 311                     }
 312                     else
 313                     {
 314                         var parentLayer = InternalParent as Layer;
 315                         if (parentLayer != null)
 316                         {
 317                             parentLayer.LayoutCount += diff;
 318                         }
 319                     }
 320                 }
 321             }
 322         }
 323
 324         /// <summary>
 325         /// Indicates that this View should listen Touch event to handle its ControlState.
 326         /// </summary>
 327         private bool enableControlState = false;
 328
 329         private int LeftFocusableViewId
 330         {
 331             get
 332             {
 333
 334                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.LeftFocusableViewId);
 335             }
 336             set
 337             {
 338
 339                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.LeftFocusableViewId, value);
 340             }
 341         }
 342
 343         private int RightFocusableViewId
 344         {
 345             get
 346             {
 347
 348                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.RightFocusableViewId);
 349             }
 350             set
 351             {
 352
 353                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.RightFocusableViewId, value);
 354             }
 355         }
 356
 357         private int UpFocusableViewId
 358         {
 359             get
 360             {
 361
 362                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.UpFocusableViewId);
 363             }
 364             set
 365             {
 366
 367                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.UpFocusableViewId, value);
 368             }
 369         }
 370
 371         private int DownFocusableViewId
 372         {
 373             get
 374             {
 375
 376                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.DownFocusableViewId);
 377             }
 378             set
 379             {
 380
 381                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.DownFocusableViewId, value);
 382             }
 383         }
 384
 385         private int ClockwiseFocusableViewId
 386         {
 387             get
 388             {
 389
 390                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.ClockwiseFocusableViewId);
 391             }
 392             set
 393             {
 394
 395                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.ClockwiseFocusableViewId, value);
 396             }
 397         }
 398
 399         private int CounterClockwiseFocusableViewId
 400         {
 401             get
 402             {
 403
 404                 return Object.InternalGetPropertyInt(SwigCPtr, View.Property.CounterClockwiseFocusableViewId);
 405             }
 406             set
 407             {
 408
 409                 Object.InternalSetPropertyInt(SwigCPtr, View.Property.CounterClockwiseFocusableViewId, value);
 410             }
 411         }
 412
 413         internal string GetName()
 414         {
 415             string ret = Interop.Actor.GetName(SwigCPtr);
 416             if (NDalicPINVOKE.SWIGPendingException.Pending)
 417                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 418             return ret;
 419         }
 420
 421         internal void SetName(string name)
 422         {
 423             Interop.Actor.SetName(SwigCPtr, name);
 424             if (NDalicPINVOKE.SWIGPendingException.Pending)
 425                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 426         }
 427
 428         internal uint GetId()
 429         {
 430             uint ret = Interop.Actor.GetId(SwigCPtr);
 431             if (NDalicPINVOKE.SWIGPendingException.Pending)
 432                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 433             return ret;
 434         }
 435
 436         internal bool IsRoot()
 437         {
 438             bool ret = Interop.ActorInternal.IsRoot(SwigCPtr);
 439             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 440             return ret;
 441         }
 442
 443         internal bool OnWindow()
 444         {
 445             bool ret = Interop.Actor.OnStage(SwigCPtr);
 446             if (NDalicPINVOKE.SWIGPendingException.Pending)
 447                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 448             return ret;
 449         }
 450
 451         internal View FindChildById(uint id)
 452         {
 453             //to fix memory leak issue, match the handle count with native side.
 454             IntPtr cPtr = Interop.Actor.FindChildById(SwigCPtr, id);
 455             View ret = this.GetInstanceSafely<View>(cPtr);
 456             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 457             return ret;
 458         }
 459
 460         internal override View FindCurrentChildById(uint id)
 461         {
 462             return FindChildById(id);
 463         }
 464
 465         internal void SetParentOrigin(Position origin)
 466         {
 467             Interop.ActorInternal.SetParentOrigin(SwigCPtr, Position.getCPtr(origin));
 468             if (NDalicPINVOKE.SWIGPendingException.Pending)
 469                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 470         }
 471
 472         internal Position GetCurrentParentOrigin()
 473         {
 474
 475             if(internalCurrentParentOrigin == null)
 476             {
 477                 internalCurrentParentOrigin = new Position(0, 0, 0);
 478             }
 479
 480             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.ParentOrigin, internalCurrentParentOrigin.SwigCPtr);
 481
 482             if (NDalicPINVOKE.SWIGPendingException.Pending)
 483             {
 484                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 485             }
 486             return internalCurrentParentOrigin;
 487         }
 488
 489         internal void SetAnchorPoint(Position anchorPoint)
 490         {
 491             Interop.Actor.SetAnchorPoint(SwigCPtr, Position.getCPtr(anchorPoint));
 492             if (NDalicPINVOKE.SWIGPendingException.Pending)
 493                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 494         }
 495
 496         internal Position GetCurrentAnchorPoint()
 497         {
 498
 499             if(internalCurrentAnchorPoint == null)
 500             {
 501                 internalCurrentAnchorPoint = new Position(0, 0, 0);
 502             }
 503
 504             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.AnchorPoint, internalCurrentAnchorPoint.SwigCPtr);
 505
 506             if (NDalicPINVOKE.SWIGPendingException.Pending)
 507             {
 508                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 509             }
 510             return internalCurrentAnchorPoint;
 511         }
 512
 513         internal void SetSize(float width, float height)
 514         {
 515             Interop.ActorInternal.SetSize(SwigCPtr, width, height);
 516             if (NDalicPINVOKE.SWIGPendingException.Pending)
 517                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 518         }
 519
 520         internal void SetSize(float width, float height, float depth)
 521         {
 522             Interop.ActorInternal.SetSize(SwigCPtr, width, height, depth);
 523             if (NDalicPINVOKE.SWIGPendingException.Pending)
 524                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 525         }
 526
 527         internal void SetSize(Vector2 size)
 528         {
 529             Interop.ActorInternal.SetSizeVector2(SwigCPtr, Vector2.getCPtr(size));
 530             if (NDalicPINVOKE.SWIGPendingException.Pending)
 531                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 532         }
 533
 534         internal void SetSize(Vector3 size)
 535         {
 536             Interop.ActorInternal.SetSizeVector3(SwigCPtr, Vector3.getCPtr(size));
 537             if (NDalicPINVOKE.SWIGPendingException.Pending)
 538                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 539         }
 540
 541         internal Vector3 GetTargetSize()
 542         {
 543
 544             if(internalTargetSize == null)
 545             {
 546                 internalTargetSize = new Vector3(0, 0, 0);
 547             }
 548
 549             Interop.ActorInternal.RetrieveTargetSize(SwigCPtr, internalTargetSize.SwigCPtr);
 550
 551             if (NDalicPINVOKE.SWIGPendingException.Pending)
 552             {
 553                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 554             }
 555             return internalTargetSize;
 556         }
 557
 558         internal Size2D GetCurrentSize()
 559         {
 560
 561             if(internalCurrentSize == null)
 562             {
 563                 internalCurrentSize = new Size2D(0, 0);
 564             }
 565
 566             Interop.ActorInternal.RetrieveCurrentPropertyVector2ActualVector3(SwigCPtr, Property.SIZE, internalCurrentSize.SwigCPtr);
 567
 568             if (NDalicPINVOKE.SWIGPendingException.Pending)
 569             {
 570                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 571             }
 572             return internalCurrentSize;
 573         }
 574
 575         internal Size2D GetCurrentSizeFloat()
 576         {
 577             Size ret = new Size(Interop.Actor.GetCurrentSize(SwigCPtr), true);
 578             if (NDalicPINVOKE.SWIGPendingException.Pending)
 579                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 580             return ret;
 581         }
 582
 583         /// <summary>
 584         /// GetNaturalSize() function behaviour can be changed for each subclass of View.
 585         /// So we make GetNaturalSize() function virtual, and make subclass can define it's owned logic
 586         /// </summary>
 587         internal virtual Vector3 GetNaturalSize()
 588         {
 589             Vector3 ret = new Vector3(Interop.Actor.GetNaturalSize(SwigCPtr), true);
 590             if (NDalicPINVOKE.SWIGPendingException.Pending)
 591                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 592             return ret;
 593         }
 594
 595         internal void SetX(float x)
 596         {
 597             Interop.ActorInternal.SetX(SwigCPtr, x);
 598             if (NDalicPINVOKE.SWIGPendingException.Pending)
 599                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 600         }
 601
 602         internal void SetY(float y)
 603         {
 604             Interop.ActorInternal.SetY(SwigCPtr, y);
 605             if (NDalicPINVOKE.SWIGPendingException.Pending)
 606                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 607         }
 608
 609         internal void SetZ(float z)
 610         {
 611             Interop.ActorInternal.SetZ(SwigCPtr, z);
 612             if (NDalicPINVOKE.SWIGPendingException.Pending)
 613                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 614         }
 615
 616         internal void TranslateBy(Vector3 distance)
 617         {
 618             Interop.ActorInternal.TranslateBy(SwigCPtr, Vector3.getCPtr(distance));
 619             if (NDalicPINVOKE.SWIGPendingException.Pending)
 620                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 621         }
 622
 623         internal Position GetCurrentPosition()
 624         {
 625
 626             if(internalCurrentPosition == null)
 627             {
 628                 internalCurrentPosition = new Position(0, 0, 0);
 629             }
 630
 631             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, Property.POSITION, internalCurrentPosition.SwigCPtr);
 632
 633             if (NDalicPINVOKE.SWIGPendingException.Pending)
 634             {
 635                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 636             }
 637             return internalCurrentPosition;
 638         }
 639         internal Vector3 GetCurrentWorldPosition()
 640         {
 641
 642             if(internalCurrentWorldPosition == null)
 643             {
 644                 internalCurrentWorldPosition = new Vector3(0, 0, 0);
 645             }
 646
 647             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.WorldPosition, internalCurrentWorldPosition.SwigCPtr);
 648
 649             if (NDalicPINVOKE.SWIGPendingException.Pending)
 650             {
 651                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 652             }
 653             return internalCurrentWorldPosition;
 654         }
 655
 656         internal Vector2 GetCurrentScreenPosition()
 657         {
 658
 659             if(internalCurrentScreenPosition == null)
 660             {
 661                 internalCurrentScreenPosition = new Vector2(0, 0);
 662             }
 663
 664             Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.ScreenPosition, internalCurrentScreenPosition.SwigCPtr);
 665
 666             if (NDalicPINVOKE.SWIGPendingException.Pending)
 667             {
 668                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 669             }
 670             return internalCurrentScreenPosition;
 671         }
 672
 673         internal Vector4 GetCurrentScreenPositionSize()
 674         {
 675             Vector4 ret = new Vector4(Interop.Actor.CurrentScreenExtents(SwigCPtr), true);
 676             if (NDalicPINVOKE.SWIGPendingException.Pending) throw new InvalidOperationException("FATAL: get Exception", NDalicPINVOKE.SWIGPendingException.Retrieve());
 677             return ret;
 678         }
 679
 680         internal void SetInheritPosition(bool inherit)
 681         {
 682             Interop.ActorInternal.SetInheritPosition(SwigCPtr, inherit);
 683             if (NDalicPINVOKE.SWIGPendingException.Pending)
 684                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 685         }
 686
 687         internal bool IsPositionInherited()
 688         {
 689             bool ret = Interop.ActorInternal.IsPositionInherited(SwigCPtr);
 690             if (NDalicPINVOKE.SWIGPendingException.Pending)
 691                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 692             return ret;
 693         }
 694
 695         internal void SetOrientation(Degree angle, Vector3 axis)
 696         {
 697             Interop.ActorInternal.SetOrientationDegree(SwigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
 698             if (NDalicPINVOKE.SWIGPendingException.Pending)
 699                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 700         }
 701
 702         internal void SetOrientation(Radian angle, Vector3 axis)
 703         {
 704             Interop.ActorInternal.SetOrientationRadian(SwigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
 705             if (NDalicPINVOKE.SWIGPendingException.Pending)
 706                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 707         }
 708
 709         internal void SetOrientation(Rotation orientation)
 710         {
 711             Interop.ActorInternal.SetOrientationQuaternion(SwigCPtr, Rotation.getCPtr(orientation));
 712             if (NDalicPINVOKE.SWIGPendingException.Pending)
 713                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 714         }
 715
 716         internal Rotation GetCurrentOrientation()
 717         {
 718             Rotation ret = new Rotation(Interop.ActorInternal.GetCurrentOrientation(SwigCPtr), true);
 719             if (NDalicPINVOKE.SWIGPendingException.Pending)
 720                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 721             return ret;
 722         }
 723
 724         internal void SetInheritOrientation(bool inherit)
 725         {
 726             Interop.ActorInternal.SetInheritOrientation(SwigCPtr, inherit);
 727             if (NDalicPINVOKE.SWIGPendingException.Pending)
 728                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 729         }
 730
 731         internal bool IsOrientationInherited()
 732         {
 733             bool ret = Interop.ActorInternal.IsOrientationInherited(SwigCPtr);
 734             if (NDalicPINVOKE.SWIGPendingException.Pending)
 735                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 736             return ret;
 737         }
 738
 739         internal Rotation GetCurrentWorldOrientation()
 740         {
 741             Rotation ret = new Rotation(Interop.ActorInternal.GetCurrentWorldOrientation(SwigCPtr), true);
 742             if (NDalicPINVOKE.SWIGPendingException.Pending)
 743                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 744             return ret;
 745         }
 746
 747         internal void SetScale(float scale)
 748         {
 749             Interop.ActorInternal.SetScale(SwigCPtr, scale);
 750             if (NDalicPINVOKE.SWIGPendingException.Pending)
 751                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 752         }
 753
 754         internal void SetScale(float scaleX, float scaleY, float scaleZ)
 755         {
 756             Interop.ActorInternal.SetScale(SwigCPtr, scaleX, scaleY, scaleZ);
 757             if (NDalicPINVOKE.SWIGPendingException.Pending)
 758                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 759         }
 760
 761         internal void SetScale(Vector3 scale)
 762         {
 763             Interop.ActorInternal.SetScale(SwigCPtr, Vector3.getCPtr(scale));
 764             if (NDalicPINVOKE.SWIGPendingException.Pending)
 765                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 766         }
 767
 768         internal Vector3 GetCurrentScale()
 769         {
 770
 771             if(internalCurrentScale == null)
 772             {
 773                 internalCurrentScale = new Vector3(0, 0, 0);
 774             }
 775
 776             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.SCALE, internalCurrentScale.SwigCPtr);
 777
 778             if (NDalicPINVOKE.SWIGPendingException.Pending)
 779             {
 780                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 781             }
 782             return internalCurrentScale;
 783         }
 784
 785         internal Vector3 GetCurrentWorldScale()
 786         {
 787
 788             if(internalCurrentWorldScale == null)
 789             {
 790                 internalCurrentWorldScale = new Vector3(0, 0, 0);
 791             }
 792
 793             Interop.ActorInternal.RetrieveCurrentPropertyVector3(SwigCPtr, View.Property.WorldScale, internalCurrentWorldScale.SwigCPtr);
 794
 795             if (NDalicPINVOKE.SWIGPendingException.Pending)
 796             {
 797                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 798             }
 799             return internalCurrentWorldScale;
 800         }
 801
 802         internal void SetInheritScale(bool inherit)
 803         {
 804             Interop.ActorInternal.SetInheritScale(SwigCPtr, inherit);
 805             if (NDalicPINVOKE.SWIGPendingException.Pending)
 806                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 807         }
 808
 809         internal bool IsScaleInherited()
 810         {
 811             bool ret = Interop.ActorInternal.IsScaleInherited(SwigCPtr);
 812             if (NDalicPINVOKE.SWIGPendingException.Pending)
 813                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 814             return ret;
 815         }
 816
 817         internal Matrix GetCurrentWorldMatrix()
 818         {
 819             Matrix ret = new Matrix(Interop.ActorInternal.GetCurrentWorldMatrix(SwigCPtr), true);
 820             if (NDalicPINVOKE.SWIGPendingException.Pending)
 821                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 822             return ret;
 823         }
 824
 825         internal void SetVisible(bool visible)
 826         {
 827             Interop.Actor.SetVisible(SwigCPtr, visible);
 828             if (NDalicPINVOKE.SWIGPendingException.Pending)
 829                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 830         }
 831
 832         /// <summary>
 833         /// Retrieve the View's current Visibility.
 834         /// </summary>
 835         /// <remarks>
 836         /// The <see cref="Visibility"/> property is set in the main thread, so it is not updated in real time when the value is changed in the render thread.
 837         /// However, this method can get the current actual value updated in real time.
 838         /// </remarks>
 839         internal bool IsVisible()
 840         {
 841             bool ret = Interop.ActorInternal.IsVisible(SwigCPtr);
 842             if (NDalicPINVOKE.SWIGPendingException.Pending)
 843                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 844             return ret;
 845         }
 846
 847         internal void SetOpacity(float opacity)
 848         {
 849             Interop.ActorInternal.SetOpacity(SwigCPtr, opacity);
 850             if (NDalicPINVOKE.SWIGPendingException.Pending)
 851                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 852         }
 853
 854         internal float GetCurrentOpacity()
 855         {
 856             float ret = Interop.ActorInternal.GetCurrentOpacity(SwigCPtr);
 857             if (NDalicPINVOKE.SWIGPendingException.Pending)
 858                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 859             return ret;
 860         }
 861
 862         internal Vector4 GetCurrentColor()
 863         {
 864
 865             if(internalCurrentColor == null)
 866             {
 867                 internalCurrentColor = new Vector4(0, 0, 0, 0);
 868             }
 869
 870             Interop.ActorInternal.RetrieveCurrentPropertyVector4(SwigCPtr, Interop.ActorProperty.ColorGet(), internalCurrentColor.SwigCPtr);
 871
 872             if (NDalicPINVOKE.SWIGPendingException.Pending)
 873             {
 874                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 875             }
 876             return internalCurrentColor;
 877         }
 878         internal ColorMode GetColorMode()
 879         {
 880             ColorMode ret = (ColorMode)Interop.ActorInternal.GetColorMode(SwigCPtr);
 881             if (NDalicPINVOKE.SWIGPendingException.Pending)
 882                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 883             return ret;
 884         }
 885
 886         internal Vector4 GetCurrentWorldColor()
 887         {
 888
 889             if(internalCurrentWorldColor == null)
 890             {
 891                 internalCurrentWorldColor = new Vector4(0, 0, 0, 0);
 892             }
 893
 894             Interop.ActorInternal.RetrieveCurrentPropertyVector4(SwigCPtr, Property.WorldColor, internalCurrentWorldColor.SwigCPtr);
 895
 896             if (NDalicPINVOKE.SWIGPendingException.Pending)
 897             {
 898                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 899             }
 900             return internalCurrentWorldColor;
 901         }
 902
 903         internal void SetDrawMode(DrawModeType drawMode)
 904         {
 905             Interop.ActorInternal.SetDrawMode(SwigCPtr, (int)drawMode);
 906             if (NDalicPINVOKE.SWIGPendingException.Pending)
 907                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 908         }
 909
 910         internal DrawModeType GetDrawMode()
 911         {
 912             DrawModeType ret = (DrawModeType)Interop.ActorInternal.GetDrawMode(SwigCPtr);
 913             if (NDalicPINVOKE.SWIGPendingException.Pending)
 914                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 915             return ret;
 916         }
 917
 918         internal void SetKeyboardFocusable(bool focusable)
 919         {
 920             Interop.ActorInternal.SetKeyboardFocusable(SwigCPtr, focusable);
 921             if (NDalicPINVOKE.SWIGPendingException.Pending)
 922                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 923         }
 924
 925         internal bool IsKeyboardFocusable()
 926         {
 927             bool ret = Interop.ActorInternal.IsKeyboardFocusable(SwigCPtr);
 928             if (NDalicPINVOKE.SWIGPendingException.Pending)
 929                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 930             return ret;
 931         }
 932
 933         internal void SetKeyboardFocusableChildren(bool focusable)
 934         {
 935             Interop.ActorInternal.SetKeyboardFocusableChildren(SwigCPtr, focusable);
 936             if (NDalicPINVOKE.SWIGPendingException.Pending)
 937                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 938         }
 939
 940         internal bool AreChildrenKeyBoardFocusable()
 941         {
 942             bool ret = Interop.ActorInternal.AreChildrenKeyBoardFocusable(SwigCPtr);
 943             if (NDalicPINVOKE.SWIGPendingException.Pending)
 944                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 945             return ret;
 946         }
 947
 948         internal void SetFocusableInTouch(bool enabled)
 949         {
 950             Interop.ActorInternal.SetFocusableInTouch(SwigCPtr, enabled);
 951             if (NDalicPINVOKE.SWIGPendingException.Pending)
 952                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 953         }
 954
 955         internal bool IsFocusableInTouch()
 956         {
 957             bool ret = Interop.ActorInternal.IsFocusableInTouch(SwigCPtr);
 958             if (NDalicPINVOKE.SWIGPendingException.Pending)
 959                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 960             return ret;
 961         }
 962
 963         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
 964         {
 965             Interop.Actor.SetResizePolicy(SwigCPtr, (int)policy, (int)dimension);
 966             if (NDalicPINVOKE.SWIGPendingException.Pending)
 967                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 968         }
 969
 970         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
 971         {
 972             ResizePolicyType ret = (ResizePolicyType)Interop.Actor.GetResizePolicy(SwigCPtr, (int)dimension);
 973             if (NDalicPINVOKE.SWIGPendingException.Pending)
 974                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 975             return ret;
 976         }
 977
 978         internal Vector3 GetSizeModeFactor()
 979         {
 980
 981                 if (internalSizeModeFactor == null)
 982                 {
 983                     internalSizeModeFactor = new Vector3(OnSizeModeFactorChanged, 0, 0, 0);
 984                 }
 985                 Object.InternalRetrievingPropertyVector3(SwigCPtr, View.Property.SizeModeFactor, internalSizeModeFactor.SwigCPtr);
 986                 return internalSizeModeFactor;
 987         }
 988
 989         internal void SetMinimumSize(Vector2 size)
 990         {
 991             Interop.ActorInternal.SetMinimumSize(SwigCPtr, Vector2.getCPtr(size));
 992             if (NDalicPINVOKE.SWIGPendingException.Pending)
 993                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
 994         }
 995
 996         internal Vector2 GetMinimumSize()
 997         {
 998
 999             if (internalMinimumSize == null)
1000             {
1001                 internalMinimumSize = new Size2D(OnMinimumSizeChanged, 0, 0);
1002             }
1003             Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.MinimumSize, internalMinimumSize.SwigCPtr);
1004             return internalMinimumSize;
1005         }
1006
1007         internal void SetMaximumSize(Vector2 size)
1008         {
1009             Interop.ActorInternal.SetMaximumSize(SwigCPtr, Vector2.getCPtr(size));
1010             if (NDalicPINVOKE.SWIGPendingException.Pending)
1011                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1012         }
1013
1014         internal Vector2 GetMaximumSize()
1015         {
1016
1017             if (internalMaximumSize == null)
1018             {
1019                 internalMaximumSize = new Size2D(OnMaximumSizeChanged, 0, 0);
1020             }
1021             Object.InternalRetrievingPropertyVector2(SwigCPtr, View.Property.MaximumSize, internalMaximumSize.SwigCPtr);
1022             return internalMaximumSize;
1023         }
1024
1025         internal int GetHierarchyDepth()
1026         {
1027             int ret = Interop.Actor.GetHierarchyDepth(SwigCPtr);
1028             if (NDalicPINVOKE.SWIGPendingException.Pending)
1029                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1030             return ret;
1031         }
1032
1033         internal uint GetRendererCount()
1034         {
1035             uint ret = Interop.Actor.GetRendererCount(SwigCPtr);
1036             if (NDalicPINVOKE.SWIGPendingException.Pending)
1037                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1038             return ret;
1039         }
1040
1041         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
1042         {
1043             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.SwigCPtr;
1044         }
1045
1046         internal bool IsTopLevelView()
1047         {
1048             if (GetParent() is Layer)
1049             {
1050                 return true;
1051             }
1052             return false;
1053         }
1054
1055         /// <summary>
1056         /// Check whether Current view don't has BackgroundVisual or not.
1057         /// Some API (like Animation, Borderline) required non-empty backgrounds.
1058         /// </summary>
1059         internal bool IsBackgroundEmpty()
1060         {
1061
1062             int visualType = (int)Visual.Type.Invalid;
1063             Interop.View.InternalRetrievingVisualPropertyInt(this.SwigCPtr, Property.BACKGROUND, Visual.Property.Type, out visualType);
1064             return visualType == (int)Visual.Type.Invalid;
1065         }
1066
1067         internal void SetKeyInputFocus()
1068         {
1069             Interop.ViewInternal.SetKeyInputFocus(SwigCPtr);
1070             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1071         }
1072
1073         internal void ClearKeyInputFocus()
1074         {
1075             Interop.ViewInternal.ClearKeyInputFocus(SwigCPtr);
1076             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1077         }
1078
1079         internal PinchGestureDetector GetPinchGestureDetector()
1080         {
1081             PinchGestureDetector ret = new PinchGestureDetector(Interop.ViewInternal.GetPinchGestureDetector(SwigCPtr), true);
1082             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1083             return ret;
1084         }
1085
1086         internal PanGestureDetector GetPanGestureDetector()
1087         {
1088             PanGestureDetector ret = new PanGestureDetector(Interop.ViewInternal.GetPanGestureDetector(SwigCPtr), true);
1089             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1090             return ret;
1091         }
1092
1093         internal TapGestureDetector GetTapGestureDetector()
1094         {
1095             TapGestureDetector ret = new TapGestureDetector(Interop.ViewInternal.GetTapGestureDetector(SwigCPtr), true);
1096             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1097             return ret;
1098         }
1099
1100         internal LongPressGestureDetector GetLongPressGestureDetector()
1101         {
1102             LongPressGestureDetector ret = new LongPressGestureDetector(Interop.ViewInternal.GetLongPressGestureDetector(SwigCPtr), true);
1103             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1104             return ret;
1105         }
1106
1107         internal IntPtr GetPtrfromView()
1108         {
1109             return (IntPtr)SwigCPtr;
1110         }
1111
1112         internal void RemoveChild(View child)
1113         {
1114             // If the view had focus, it clears focus.
1115             if (child == FocusManager.Instance.GetCurrentFocusView())
1116             {
1117                 FocusManager.Instance.ClearFocus();
1118             }
1119             // Do actual child removal
1120             Interop.Actor.Remove(SwigCPtr, View.getCPtr(child));
1121             if (NDalicPINVOKE.SWIGPendingException.Pending)
1122                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1123
1124             Children.Remove(child);
1125             child.InternalParent = null;
1126             LayoutCount -= child.LayoutCount;
1127
1128             OnChildRemoved(child);
1129             if (ChildRemoved != null)
1130             {
1131                 ChildRemovedEventArgs e = new ChildRemovedEventArgs
1132                 {
1133                     Removed = child
1134                 };
1135                 ChildRemoved(this, e);
1136             }
1137         }
1138
1139         /// <summary>
1140         /// Removes the layout from this View.
1141         /// </summary>
1142         internal void ResetLayout()
1143         {
1144             LayoutCount--;
1145
1146             layout = null;
1147         }
1148
1149         internal ResourceLoadingStatusType GetBackgroundResourceStatus()
1150         {
1151             return (ResourceLoadingStatusType)Interop.View.GetVisualResourceStatus(this.SwigCPtr, Property.BACKGROUND);
1152         }
1153
1154         /// TODO open as a protected level
1155         internal virtual void ApplyCornerRadius()
1156         {
1157             if (backgroundExtraData == null) return;
1158
1159
1160             // Update corner radius properties to background and shadow by ActionUpdateProperty
1161             if (backgroundExtraData.CornerRadius != null)
1162             {
1163                 Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.CornerRadius, Vector4.getCPtr(backgroundExtraData.CornerRadius));
1164                 Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.SHADOW, Visual.Property.CornerRadius, Vector4.getCPtr(backgroundExtraData.CornerRadius));
1165             }
1166             Interop.View.InternalUpdateVisualPropertyInt(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.CornerRadiusPolicy, (int)backgroundExtraData.CornerRadiusPolicy);
1167             Interop.View.InternalUpdateVisualPropertyInt(this.SwigCPtr, View.Property.SHADOW, Visual.Property.CornerRadiusPolicy, (int)backgroundExtraData.CornerRadiusPolicy);
1168         }
1169
1170         /// TODO open as a protected level
1171         internal virtual void ApplyBorderline()
1172         {
1173             if (backgroundExtraData == null) return;
1174
1175
1176             // ActionUpdateProperty works well only if BACKGROUND visual setup before.
1177             // If view don't have BACKGROUND visual, we set transparent background color in default.
1178             if (IsBackgroundEmpty())
1179             {
1180                 // BACKGROUND visual doesn't exist.
1181                 SetBackgroundColor(Color.Transparent);
1182                 // SetBackgroundColor function apply borderline internally.
1183                 // So we can just return now.
1184                 return;
1185             }
1186
1187             // Update borderline properties to background by ActionUpdateProperty
1188             Interop.View.InternalUpdateVisualPropertyFloat(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineWidth, backgroundExtraData.BorderlineWidth);
1189             Interop.View.InternalUpdateVisualPropertyVector4(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineColor, Vector4.getCPtr(backgroundExtraData.BorderlineColor ?? Color.Black));
1190             Interop.View.InternalUpdateVisualPropertyFloat(this.SwigCPtr, View.Property.BACKGROUND, Visual.Property.BorderlineOffset, backgroundExtraData.BorderlineOffset);
1191         }
1192
1193         /// <summary>
1194         /// Get selector value from the triggerable selector or related property.
1195         /// </summary>
1196         internal Selector<T> GetSelector<T>(TriggerableSelector<T> triggerableSelector, NUI.Binding.BindableProperty relatedProperty)
1197         {
1198             var selector = triggerableSelector?.Get();
1199             if (selector != null)
1200             {
1201                 return selector;
1202             }
1203
1204             var value = (T)GetValue(relatedProperty);
1205             return value == null ? null : new Selector<T>(value);
1206         }
1207
1208         internal void SetThemeApplied()
1209         {
1210             if (themeData == null) themeData = new ThemeData();
1211             themeData.ThemeApplied = true;
1212
1213             if (ThemeChangeSensitive && !themeData.ListeningThemeChangeEvent)
1214             {
1215                 themeData.ListeningThemeChangeEvent = true;
1216                 ThemeManager.ThemeChangedInternal.Add(OnThemeChanged);
1217             }
1218         }
1219
1220         /// <summary>
1221         /// you can override it to clean-up your own resources.
1222         /// </summary>
1223         /// <param name="type">DisposeTypes</param>
1224         /// <since_tizen> 3 </since_tizen>
1225         protected override void Dispose(DisposeTypes type)
1226         {
1227             if (disposed)
1228             {
1229                 return;
1230             }
1231
1232             disposeDebugging(type);
1233
1234             //_mergedStyle = null;
1235
1236             internalMaximumSize?.Dispose();
1237             internalMaximumSize = null;
1238             internalMinimumSize?.Dispose();
1239             internalMinimumSize = null;
1240             internalMargin?.Dispose();
1241             internalMargin = null;
1242             internalPadding?.Dispose();
1243             internalPadding = null;
1244             internalSizeModeFactor?.Dispose();
1245             internalSizeModeFactor = null;
1246             internalCellIndex?.Dispose();
1247             internalCellIndex = null;
1248             internalBackgroundColor?.Dispose();
1249             internalBackgroundColor = null;
1250             internalColor?.Dispose();
1251             internalColor = null;
1252             internalPivotPoint?.Dispose();
1253             internalPivotPoint = null;
1254             internalPosition?.Dispose();
1255             internalPosition = null;
1256             internalPosition2D?.Dispose();
1257             internalPosition2D = null;
1258             internalScale?.Dispose();
1259             internalScale = null;
1260             internalSize?.Dispose();
1261             internalSize = null;
1262             internalSize2D?.Dispose();
1263             internalSize2D = null;
1264
1265             panGestureDetector?.Dispose();
1266             panGestureDetector = null;
1267             longGestureDetector?.Dispose();
1268             longGestureDetector = null;
1269             pinchGestureDetector?.Dispose();
1270             pinchGestureDetector = null;
1271             tapGestureDetector?.Dispose();
1272             tapGestureDetector = null;
1273             rotationGestureDetector?.Dispose();
1274             rotationGestureDetector = null;
1275
1276
1277             internalCurrentParentOrigin?.Dispose();
1278             internalCurrentParentOrigin = null;
1279             internalCurrentAnchorPoint?.Dispose();
1280             internalCurrentAnchorPoint = null;
1281             internalTargetSize?.Dispose();
1282             internalTargetSize = null;
1283             internalCurrentSize?.Dispose();
1284             internalCurrentSize = null;
1285             internalCurrentPosition?.Dispose();
1286             internalCurrentPosition = null;
1287             internalCurrentWorldPosition?.Dispose();
1288             internalCurrentWorldPosition = null;
1289             internalCurrentScale?.Dispose();
1290             internalCurrentScale = null;
1291             internalCurrentWorldScale?.Dispose();
1292             internalCurrentWorldScale = null;
1293             internalCurrentColor?.Dispose();
1294             internalCurrentColor = null;
1295             internalCurrentWorldColor?.Dispose();
1296             internalCurrentWorldColor = null;
1297             internalSizeModeFactor?.Dispose();
1298             internalSizeModeFactor = null;
1299             internalCurrentScreenPosition?.Dispose();
1300             internalCurrentScreenPosition = null;
1301
1302             if (type == DisposeTypes.Explicit)
1303             {
1304                 //Called by User
1305                 //Release your own managed resources here.
1306                 //You should release all of your own disposable objects here.
1307                 if (themeData != null)
1308                 {
1309                     themeData.selectorData?.Reset(this);
1310                     if (themeData.ListeningThemeChangeEvent)
1311                     {
1312                         ThemeManager.ThemeChangedInternal.Remove(OnThemeChanged);
1313                     }
1314                 }
1315                 if (widthConstraint != null)
1316                 {
1317                     widthConstraint.Remove();
1318                     widthConstraint.Dispose();
1319                 }
1320                 if (heightConstraint != null)
1321                 {
1322                     heightConstraint.Remove();
1323                     heightConstraint.Dispose();
1324                 }
1325             }
1326
1327             //Release your own unmanaged resources here.
1328             //You should not access any managed member here except static instance.
1329             //because the execution order of Finalizes is non-deterministic.
1330
1331             DisConnectFromSignals();
1332
1333             foreach (View view in Children)
1334             {
1335                 view.InternalParent = null;
1336             }
1337
1338             LayoutCount = 0;
1339
1340             NUILog.Debug($"[Dispose] View.Dispose({type}) END");
1341             NUILog.Debug($"=============================");
1342
1343             base.Dispose(type);
1344         }
1345
1346         /// This will not be public opened.
1347         [EditorBrowsable(EditorBrowsableState.Never)]
1348         protected override void ReleaseSwigCPtr(System.Runtime.InteropServices.HandleRef swigCPtr)
1349         {
1350             Interop.View.DeleteView(swigCPtr);
1351         }
1352
1353         /// <summary>
1354         /// The touch event handler for ControlState.
1355         /// Please change ControlState value by touch state if needed.
1356         /// </summary>
1357         /// <exception cref="ArgumentNullException"> Thrown when touch is null. </exception>
1358         [EditorBrowsable(EditorBrowsableState.Never)]
1359         protected virtual bool HandleControlStateOnTouch(Touch touch)
1360         {
1361             if (touch == null)
1362             {
1363                 throw new global::System.ArgumentNullException(nameof(touch));
1364             }
1365
1366             switch (touch.GetState(0))
1367             {
1368                 case PointStateType.Down:
1369                     ControlState += ControlState.Pressed;
1370                     break;
1371                 case PointStateType.Interrupted:
1372                 case PointStateType.Up:
1373                     if (ControlState.Contains(ControlState.Pressed))
1374                     {
1375                         ControlState -= ControlState.Pressed;
1376                     }
1377                     break;
1378                 default:
1379                     break;
1380             }
1381             return false;
1382         }
1383
1384         /// <summary>
1385         /// Internal callback of enabled property changes.
1386         /// Inherited view can override this method to implements enabled property changes.
1387         /// </summary>
1388         [EditorBrowsable(EditorBrowsableState.Never)]
1389         protected virtual void OnEnabled(bool enabled)
1390         {
1391             if (enabled)
1392             {
1393                 if (State == View.States.Disabled)
1394                 {
1395                     State = View.States.Normal;
1396                 }
1397                 if (enableControlState)
1398                 {
1399                     ControlState -= ControlState.Disabled;
1400                 }
1401             }
1402             else
1403             {
1404                 State = View.States.Disabled;
1405                 if (enableControlState)
1406                 {
1407                     ControlState += ControlState.Disabled;
1408                 }
1409             }
1410         }
1411
1412
1413         private void DisConnectFromSignals()
1414         {
1415             if (HasBody() == false)
1416             {
1417                 NUILog.Debug($"[Dispose] DisConnectFromSignals() No native body! No need to Disconnect Signals!");
1418                 return;
1419             }
1420             NUILog.Debug($"[Dispose] DisConnectFromSignals START");
1421             NUILog.Debug($"[Dispose] View.DisConnectFromSignals() type:{GetType()} copyNativeHandle:{GetBaseHandleCPtrHandleRef.Handle.ToString("X8")}");
1422             NUILog.Debug($"[Dispose] ID:{Interop.Actor.GetId(GetBaseHandleCPtrHandleRef)} Name:{Interop.Actor.GetName(GetBaseHandleCPtrHandleRef)}");
1423
1424             if (onRelayoutEventCallback != null)
1425             {
1426                 NUILog.Debug($"[Dispose] onRelayoutEventCallback");
1427
1428                 Interop.ActorSignal.OnRelayoutDisconnect(GetBaseHandleCPtrHandleRef, onRelayoutEventCallback.ToHandleRef(this));
1429                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1430                 onRelayoutEventCallback = null;
1431             }
1432
1433             if (offWindowEventCallback != null)
1434             {
1435                 NUILog.Debug($"[Dispose] offWindowEventCallback");
1436
1437                 Interop.ActorSignal.OffSceneDisconnect(GetBaseHandleCPtrHandleRef, offWindowEventCallback.ToHandleRef(this));
1438                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1439                 offWindowEventCallback = null;
1440             }
1441
1442             if (onWindowEventCallback != null)
1443             {
1444                 NUILog.Debug($"[Dispose] onWindowEventCallback");
1445
1446                 Interop.ActorSignal.OnSceneDisconnect(GetBaseHandleCPtrHandleRef, onWindowEventCallback.ToHandleRef(this));
1447                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1448                 onWindowEventCallback = null;
1449             }
1450
1451             if (interceptWheelCallback != null)
1452             {
1453                 NUILog.Debug($"[Dispose] interceptWheelCallback");
1454
1455                 Interop.ActorSignal.InterceptWheelDisconnect(GetBaseHandleCPtrHandleRef, interceptWheelCallback.ToHandleRef(this));
1456                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1457                 interceptWheelCallback = null;
1458             }
1459
1460             if (wheelEventCallback != null)
1461             {
1462                 NUILog.Debug($"[Dispose] wheelEventCallback");
1463
1464                 Interop.ActorSignal.WheelEventDisconnect(GetBaseHandleCPtrHandleRef, wheelEventCallback.ToHandleRef(this));
1465                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1466                 wheelEventCallback = null;
1467             }
1468
1469             if (hoverEventCallback != null)
1470             {
1471                 NUILog.Debug($"[Dispose] hoverEventCallback");
1472
1473                 Interop.ActorSignal.HoveredDisconnect(GetBaseHandleCPtrHandleRef, hoverEventCallback.ToHandleRef(this));
1474                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1475                 hoverEventCallback = null;
1476             }
1477
1478             if (hitTestResultDataCallback != null)
1479             {
1480                 NUILog.Debug($"[Dispose] hitTestResultDataCallback");
1481
1482                 Interop.ActorSignal.HitTestResultDisconnect(GetBaseHandleCPtrHandleRef, hitTestResultDataCallback.ToHandleRef(this));
1483                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1484                 hitTestResultDataCallback = null;
1485             }
1486
1487
1488             if (interceptTouchDataCallback != null)
1489             {
1490                 NUILog.Debug($"[Dispose] interceptTouchDataCallback");
1491
1492                 Interop.ActorSignal.InterceptTouchDisconnect(GetBaseHandleCPtrHandleRef, interceptTouchDataCallback.ToHandleRef(this));
1493                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1494                 interceptTouchDataCallback = null;
1495             }
1496
1497             if (touchDataCallback != null)
1498             {
1499                 NUILog.Debug($"[Dispose] touchDataCallback");
1500
1501                 Interop.ActorSignal.TouchDisconnect(GetBaseHandleCPtrHandleRef, touchDataCallback.ToHandleRef(this));
1502                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1503                 touchDataCallback = null;
1504             }
1505
1506             if (resourcesLoadedCallback != null)
1507             {
1508                 NUILog.Debug($"[Dispose] ResourcesLoadedCallback");
1509
1510                 Interop.ViewSignal.ResourceReadyDisconnect(GetBaseHandleCPtrHandleRef, resourcesLoadedCallback.ToHandleRef(this));
1511                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1512                 resourcesLoadedCallback = null;
1513             }
1514
1515             if (keyCallback != null)
1516             {
1517                 NUILog.Debug($"[Dispose] keyCallback");
1518
1519                 Interop.ViewSignal.KeyEventDisconnect(GetBaseHandleCPtrHandleRef, keyCallback.ToHandleRef(this));
1520                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1521                 keyCallback = null;
1522             }
1523
1524             if (keyInputFocusLostCallback != null)
1525             {
1526                 NUILog.Debug($"[Dispose] keyInputFocusLostCallback");
1527
1528                 Interop.ViewSignal.KeyInputFocusLostDisconnect(GetBaseHandleCPtrHandleRef, keyInputFocusLostCallback.ToHandleRef(this));
1529                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1530                 keyInputFocusLostCallback = null;
1531                 keyInputFocusLostEventHandler = null;
1532             }
1533
1534             if (keyInputFocusGainedCallback != null)
1535             {
1536                 NUILog.Debug($"[Dispose] keyInputFocusGainedCallback");
1537
1538                 Interop.ViewSignal.KeyInputFocusGainedDisconnect(GetBaseHandleCPtrHandleRef, keyInputFocusGainedCallback.ToHandleRef(this));
1539                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1540                 keyInputFocusGainedCallback = null;
1541                 keyInputFocusGainedEventHandler = null;
1542             }
1543
1544             if (backgroundResourceLoadedCallback != null)
1545             {
1546                 NUILog.Debug($"[Dispose] backgroundResourceLoadedCallback");
1547
1548                 Interop.ViewSignal.ResourceReadyDisconnect(GetBaseHandleCPtrHandleRef, backgroundResourceLoadedCallback.ToHandleRef(this));
1549                 NDalicPINVOKE.ThrowExceptionIfExistsDebug();
1550                 backgroundResourceLoadedCallback = null;
1551             }
1552
1553             NDalicPINVOKE.ThrowExceptionIfExists();
1554             NUILog.Debug($"[Dispose] DisConnectFromSignals END");
1555         }
1556
1557         /// <summary>
1558         /// Apply initial style to the view.
1559         /// </summary>
1560         [EditorBrowsable(EditorBrowsableState.Never)]
1561         protected virtual void InitializeStyle(ViewStyle style = null)
1562         {
1563             if (style == null && ThemeManager.InitialThemeDisabled)
1564             {
1565                 // Fast return in most TV cases.
1566                 return;
1567             }
1568
1569             var initialStyle = ThemeManager.GetInitialStyleWithoutClone(GetType());
1570             if (style == null)
1571             {
1572                 ApplyStyle(initialStyle);
1573             }
1574             else
1575             {
1576                 var refinedStyle = style;
1577                 if (style.IncludeDefaultStyle)
1578                 {
1579                     refinedStyle = initialStyle?.Merge(style);
1580                 }
1581                 ApplyStyle(refinedStyle);
1582             }
1583
1584             // Listen theme change event if needs.
1585             if (initialStyle != null)
1586             {
1587                 SetThemeApplied();
1588             }
1589         }
1590
1591         private View ConvertIdToView(uint id)
1592         {
1593             View view = GetParent()?.FindCurrentChildById(id);
1594
1595             //If we can't find the parent's children, find in the top layer.
1596             if (!view)
1597             {
1598                 Container parent = GetParent();
1599                 while ((parent is View) && (parent != null))
1600                 {
1601                     parent = parent.GetParent();
1602                     if (parent is Layer)
1603                     {
1604                         view = parent.FindCurrentChildById(id);
1605                         break;
1606                     }
1607                 }
1608             }
1609
1610             return view;
1611         }
1612
1613         private void OnScaleChanged(float x, float y, float z)
1614         {
1615             Scale = new Vector3(x, y, z);
1616         }
1617
1618         private void OnBackgroundColorChanged(float r, float g, float b, float a)
1619         {
1620             BackgroundColor = new Color(r, g, b, a);
1621         }
1622
1623         private void OnPaddingChanged(ushort start, ushort end, ushort top, ushort bottom)
1624         {
1625             Padding = new Extents(start, end, top, bottom);
1626         }
1627
1628         private void OnMarginChanged(ushort start, ushort end, ushort top, ushort bottom)
1629         {
1630             Margin = new Extents(start, end, top, bottom);
1631         }
1632
1633         private void OnAnchorPointChanged(float x, float y, float z)
1634         {
1635             AnchorPoint = new Position(x, y, z);
1636         }
1637
1638         private void OnCellIndexChanged(float x, float y)
1639         {
1640             CellIndex = new Vector2(x, y);
1641         }
1642
1643         private void OnFlexMarginChanged(float x, float y, float z, float w)
1644         {
1645             FlexMargin = new Vector4(x, y, z, w);
1646         }
1647
1648         private void OnPaddingEXChanged(ushort start, ushort end, ushort top, ushort bottom)
1649         {
1650             PaddingEX = new Extents(start, end, top, bottom);
1651         }
1652
1653         private void OnSizeModeFactorChanged(float x, float y, float z)
1654         {
1655             SizeModeFactor = new Vector3(x, y, z);
1656         }
1657
1658         private bool EmptyOnTouch(object target, TouchEventArgs args)
1659         {
1660             return false;
1661         }
1662
1663         [EditorBrowsable(EditorBrowsableState.Never)]
1664         protected virtual bool CheckResourceReady()
1665         {
1666             return true;
1667         }
1668
1669         private ViewSelectorData EnsureSelectorData()
1670         {
1671             if (themeData == null) themeData = new ThemeData();
1672
1673             return themeData.selectorData ?? (themeData.selectorData = new ViewSelectorData());
1674         }
1675
1676         [Conditional("NUI_DISPOSE_DEBUG_ON")]
1677         private void disposeDebugging(DisposeTypes type)
1678         {
1679             DebugFileLogging.Instance.WriteLog($"View.Dispose({type}) START");
1680             DebugFileLogging.Instance.WriteLog($"type:{GetType()} copyNativeHandle:{GetBaseHandleCPtrHandleRef.Handle.ToString("X8")}");
1681             if (HasBody())
1682             {
1683                 DebugFileLogging.Instance.WriteLog($"ID:{Interop.Actor.GetId(GetBaseHandleCPtrHandleRef)} Name:{Interop.Actor.GetName(GetBaseHandleCPtrHandleRef)}");
1684             }
1685             else
1686             {
1687                 DebugFileLogging.Instance.WriteLog($"has no native body!");
1688             }
1689         }
1690
1691     }
1692 }