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

   1 /*
   2  * Copyright(c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17 using System;
  18 using System.Collections.Generic;
  19 using System.ComponentModel;
  20 using System.IO;
  21 using System.Runtime.InteropServices;
  22 using Tizen.NUI.Binding;
  23 using Tizen.NUI.Xaml;
  24
  25 namespace Tizen.NUI.BaseComponents
  26 {
  27     /// <summary>
  28     /// The View layout Direction type.
  29     /// </summary>
  30     /// <since_tizen> 4 </since_tizen>
  31     public enum ViewLayoutDirectionType
  32     {
  33         /// <summary>
  34         /// Left to right.
  35         /// </summary>
  36         /// <since_tizen> 4 </since_tizen>
  37         LTR,
  38         /// <summary>
  39         /// Right to left.
  40         /// </summary>
  41         /// <since_tizen> 4 </since_tizen>
  42         RTL
  43     }
  44
  45     /// <summary>
  46     /// [Draft] Available policies for layout parameters
  47     /// </summary>
  48     /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  49     [EditorBrowsable(EditorBrowsableState.Never)]
  50     public static class LayoutParamPolicies
  51     {
  52         /// <summary>
  53         /// Constant which indicates child size should match parent size
  54         /// </summary>
  55        /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  56        [EditorBrowsable(EditorBrowsableState.Never)]
  57         public const int MatchParent = -1;
  58         /// <summary>
  59         /// Constant which indicates parent should take the smallest size possible to wrap it's children with their desired size
  60         /// </summary>
  61         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  62         [EditorBrowsable(EditorBrowsableState.Never)]
  63         public const int WrapContent = -2;
  64     }
  65
  66     internal enum ResourceLoadingStatusType
  67     {
  68         Invalid = -1,
  69         Preparing = 0,
  70         Ready,
  71         Failed,
  72     }
  73
  74     /// <summary>
  75     /// View is the base class for all views.
  76     /// </summary>
  77     /// <since_tizen> 3 </since_tizen>
  78     public class View : Container, IResourcesProvider
  79     {
  80         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  81         [EditorBrowsable(EditorBrowsableState.Never)]
  82         public static readonly BindableProperty StyleNameProperty = BindableProperty.Create("StyleName", typeof(string), typeof(View), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
  83         {
  84             var view = (View)bindable;
  85             if (newValue != null)
  86             {
  87                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue((string)newValue));
  88             }
  89         },
  90         defaultValueCreator: (bindable) =>
  91         {
  92             var view = (View)bindable;
  93             string temp;
  94             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.STYLE_NAME).Get(out temp);
  95             return temp;
  96         });
  97         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  98         [EditorBrowsable(EditorBrowsableState.Never)]
  99         public static readonly BindableProperty BackgroundColorProperty = BindableProperty.Create("BackgroundColor", typeof(Color), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 100         {
 101             var view = (View)bindable;
 102             if (newValue != null)
 103             {
 104                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((Color)newValue));
 105             }
 106         },
 107         defaultValueCreator: (bindable) =>
 108         {
 109             var view = (View)bindable;
 110             Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
 111
 112             Tizen.NUI.PropertyMap background = view.Background;
 113             int visualType = 0;
 114             background.Find(Visual.Property.Type)?.Get(out visualType);
 115             if (visualType == (int)Visual.Type.Color)
 116             {
 117                 background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
 118             }
 119
 120             return backgroundColor;
 121         });
 122         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 123         [EditorBrowsable(EditorBrowsableState.Never)]
 124         public static readonly BindableProperty BackgroundImageProperty = BindableProperty.Create("BackgroundImage", typeof(string), typeof(View), default(string), propertyChanged: (bindable, oldValue, newValue) =>
 125         {
 126             var view = (View)bindable;
 127             if (newValue != null)
 128             {
 129                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((string)newValue));
 130             }
 131         },
 132         defaultValueCreator: (bindable) =>
 133         {
 134             var view = (View)bindable;
 135             string backgroundImage = "";
 136
 137             Tizen.NUI.PropertyMap background = view.Background;
 138             int visualType = 0;
 139             background.Find(Visual.Property.Type)?.Get(out visualType);
 140             if (visualType == (int)Visual.Type.Image)
 141             {
 142                 background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
 143             }
 144
 145             return backgroundImage;
 146         });
 147         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 148         [EditorBrowsable(EditorBrowsableState.Never)]
 149         public static readonly BindableProperty BackgroundProperty = BindableProperty.Create("Background", typeof(PropertyMap), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 150         {
 151             var view = (View)bindable;
 152             if (newValue != null)
 153             {
 154                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 155             }
 156         },
 157         defaultValueCreator: (bindable) =>
 158         {
 159             var view = (View)bindable;
 160             Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 161             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.BACKGROUND).Get(temp);
 162             return temp;
 163         });
 164         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 165         [EditorBrowsable(EditorBrowsableState.Never)]
 166         public static readonly BindableProperty StateProperty = BindableProperty.Create("State", typeof(States), typeof(View), States.Normal, propertyChanged: (bindable, oldValue, newValue) =>
 167         {
 168             var view = (View)bindable;
 169             if (newValue != null)
 170             {
 171                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.STATE, new Tizen.NUI.PropertyValue((int)newValue));
 172             }
 173         },
 174         defaultValueCreator: (bindable) =>
 175         {
 176             var view = (View)bindable;
 177             int temp = 0;
 178             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.STATE).Get(out temp) == false)
 179             {
 180                 NUILog.Error("State get error!");
 181             }
 182             switch (temp)
 183             {
 184                 case 0: return States.Normal;
 185                 case 1: return States.Focused;
 186                 case 2: return States.Disabled;
 187                 default: return States.Normal;
 188             }
 189         });
 190         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 191         [EditorBrowsable(EditorBrowsableState.Never)]
 192         public static readonly BindableProperty SubStateProperty = BindableProperty.Create("SubState", typeof(States), typeof(View), States.Normal, propertyChanged: (bindable, oldValue, newValue) =>
 193         {
 194             var view = (View)bindable;
 195             string valueToString = "";
 196             if (newValue != null)
 197             {
 198                 switch ((States)newValue)
 199                 {
 200                     case States.Normal: { valueToString = "NORMAL"; break; }
 201                     case States.Focused: { valueToString = "FOCUSED"; break; }
 202                     case States.Disabled: { valueToString = "DISABLED"; break; }
 203                     default: { valueToString = "NORMAL"; break; }
 204                 }
 205                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
 206             }
 207         },
 208         defaultValueCreator: (bindable) =>
 209         {
 210             var view = (View)bindable;
 211             string temp;
 212             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SUB_STATE).Get(out temp) == false)
 213             {
 214                 NUILog.Error("subState get error!");
 215             }
 216             switch (temp)
 217             {
 218                 case "NORMAL": return States.Normal;
 219                 case "FOCUSED": return States.Focused;
 220                 case "DISABLED": return States.Disabled;
 221                 default: return States.Normal;
 222             }
 223         });
 224         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 225         [EditorBrowsable(EditorBrowsableState.Never)]
 226         public static readonly BindableProperty TooltipProperty = BindableProperty.Create("Tooltip", typeof(PropertyMap), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 227         {
 228             var view = (View)bindable;
 229             if (newValue != null)
 230             {
 231                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.TOOLTIP, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 232             }
 233         },
 234         defaultValueCreator: (bindable) =>
 235         {
 236             var view = (View)bindable;
 237             Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 238             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.TOOLTIP).Get(temp);
 239             return temp;
 240         });
 241
 242         /// Only for XAML property binding. This will be changed as Inhouse API by ACR later.
 243         public static readonly BindableProperty FlexProperty = BindableProperty.Create("Flex", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 244         {
 245             var view = (View)bindable;
 246             if (newValue != null)
 247             {
 248                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue((float)newValue));
 249             }
 250         },
 251         defaultValueCreator: (bindable) =>
 252         {
 253             var view = (View)bindable;
 254             float temp = 0.0f;
 255             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX).Get(out temp);
 256             return temp;
 257         });
 258
 259         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 260         [EditorBrowsable(EditorBrowsableState.Never)]
 261         public static readonly BindableProperty AlignSelfProperty = BindableProperty.Create("AlignSelf", typeof(int), typeof(View), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 262         {
 263             var view = (View)bindable;
 264             if (newValue != null)
 265             {
 266                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue((int)newValue));
 267             }
 268         },
 269         defaultValueCreator: (bindable) =>
 270         {
 271             var view = (View)bindable;
 272             int temp = 0;
 273             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
 274             return temp;
 275         });
 276         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 277         [EditorBrowsable(EditorBrowsableState.Never)]
 278         public static readonly BindableProperty FlexMarginProperty = BindableProperty.Create("FlexMargin", typeof(Vector4), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 279         {
 280             var view = (View)bindable;
 281             if (newValue != null)
 282             {
 283                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue((Vector4)newValue));
 284             }
 285         },
 286         defaultValueCreator: (bindable) =>
 287         {
 288             var view = (View)bindable;
 289             Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 290             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
 291             return temp;
 292         });
 293         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 294         [EditorBrowsable(EditorBrowsableState.Never)]
 295         public static readonly BindableProperty CellIndexProperty = BindableProperty.Create("CellIndex", typeof(Vector2), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 296         {
 297             var view = (View)bindable;
 298             if (newValue != null)
 299             {
 300                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue((Vector2)newValue));
 301             }
 302         },
 303         defaultValueCreator: (bindable) =>
 304         {
 305             var view = (View)bindable;
 306             Vector2 temp = new Vector2(0.0f, 0.0f);
 307             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_INDEX).Get(temp);
 308             return temp;
 309         });
 310         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 311         [EditorBrowsable(EditorBrowsableState.Never)]
 312         public static readonly BindableProperty RowSpanProperty = BindableProperty.Create("RowSpan", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 313         {
 314             var view = (View)bindable;
 315             if (newValue != null)
 316             {
 317                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue((float)newValue));
 318             }
 319         },
 320         defaultValueCreator: (bindable) =>
 321         {
 322             var view = (View)bindable;
 323             float temp = 0.0f;
 324             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.ROW_SPAN).Get(out temp);
 325             return temp;
 326         });
 327         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 328         [EditorBrowsable(EditorBrowsableState.Never)]
 329         public static readonly BindableProperty ColumnSpanProperty = BindableProperty.Create("ColumnSpan", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 330         {
 331             var view = (View)bindable;
 332             if (newValue != null)
 333             {
 334                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue((float)newValue));
 335             }
 336         },
 337         defaultValueCreator: (bindable) =>
 338         {
 339             var view = (View)bindable;
 340             float temp = 0.0f;
 341             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
 342             return temp;
 343         });
 344         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 345         [EditorBrowsable(EditorBrowsableState.Never)]
 346         public static readonly BindableProperty CellHorizontalAlignmentProperty = BindableProperty.Create("CellHorizontalAlignment", typeof(HorizontalAlignmentType), typeof(View), HorizontalAlignmentType.Left, propertyChanged: (bindable, oldValue, newValue) =>
 347         {
 348             var view = (View)bindable;
 349             string valueToString = "";
 350
 351             if (newValue != null)
 352             {
 353                 switch ((HorizontalAlignmentType)newValue)
 354                 {
 355                     case Tizen.NUI.HorizontalAlignmentType.Left: { valueToString = "left"; break; }
 356                     case Tizen.NUI.HorizontalAlignmentType.Center: { valueToString = "center"; break; }
 357                     case Tizen.NUI.HorizontalAlignmentType.Right: { valueToString = "right"; break; }
 358                     default: { valueToString = "left"; break; }
 359                 }
 360                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 361             }
 362         },
 363         defaultValueCreator: (bindable) =>
 364         {
 365             var view = (View)bindable;
 366             string temp;
 367             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
 368             {
 369                 NUILog.Error("CellHorizontalAlignment get error!");
 370             }
 371
 372             switch (temp)
 373             {
 374                 case "left": return Tizen.NUI.HorizontalAlignmentType.Left;
 375                 case "center": return Tizen.NUI.HorizontalAlignmentType.Center;
 376                 case "right": return Tizen.NUI.HorizontalAlignmentType.Right;
 377                 default: return Tizen.NUI.HorizontalAlignmentType.Left;
 378             }
 379         });
 380         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 381         [EditorBrowsable(EditorBrowsableState.Never)]
 382         public static readonly BindableProperty CellVerticalAlignmentProperty = BindableProperty.Create("CellVerticalAlignment", typeof(VerticalAlignmentType), typeof(View), VerticalAlignmentType.Top, propertyChanged: (bindable, oldValue, newValue) =>
 383         {
 384             var view = (View)bindable;
 385             string valueToString = "";
 386
 387             if (newValue != null)
 388             {
 389                 switch ((VerticalAlignmentType)newValue)
 390                 {
 391                     case Tizen.NUI.VerticalAlignmentType.Top: { valueToString = "top"; break; }
 392                     case Tizen.NUI.VerticalAlignmentType.Center: { valueToString = "center"; break; }
 393                     case Tizen.NUI.VerticalAlignmentType.Bottom: { valueToString = "bottom"; break; }
 394                     default: { valueToString = "top"; break; }
 395                 }
 396                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 397             }
 398         },
 399         defaultValueCreator: (bindable) =>
 400         {
 401             var view = (View)bindable;
 402             string temp;
 403             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
 404             {
 405                 NUILog.Error("CellVerticalAlignment get error!");
 406             }
 407
 408             switch (temp)
 409             {
 410                 case "top": return Tizen.NUI.VerticalAlignmentType.Top;
 411                 case "center": return Tizen.NUI.VerticalAlignmentType.Center;
 412                 case "bottom": return Tizen.NUI.VerticalAlignmentType.Bottom;
 413                 default: return Tizen.NUI.VerticalAlignmentType.Top;
 414             }
 415         });
 416
 417         /// <summary>
 418         /// "Please DO NOT use! This will be deprecated! Please use 'View Weight' instead of BindableProperty"
 419         /// This needs to be hidden as inhouse API until all applications using it have been updated.  Do not make public.
 420         /// </summary>
 421         [EditorBrowsable(EditorBrowsableState.Never)]
 422         public static readonly BindableProperty WeightProperty = BindableProperty.Create("Weight", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 423         {
 424             var view = (View)bindable;
 425             if (newValue != null)
 426             {
 427                 view.Weight = (float)newValue;
 428             }
 429         },
 430
 431         defaultValueCreator: (bindable) =>
 432         {
 433             var view = (View)bindable;
 434             return view.Weight;
 435         });
 436
 437         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 438         [EditorBrowsable(EditorBrowsableState.Never)]
 439         public static readonly BindableProperty LeftFocusableViewProperty = BindableProperty.Create(nameof(View.LeftFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 440         {
 441             var view = (View)bindable;
 442             if (newValue != null) { view.LeftFocusableViewId = (int)(newValue as View)?.GetId(); }
 443             else { view.LeftFocusableViewId = -1; }
 444         },
 445         defaultValueCreator: (bindable) =>
 446         {
 447             var view = (View)bindable;
 448             if (view.LeftFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.LeftFocusableViewId); }
 449             return null;
 450         });
 451         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 452         [EditorBrowsable(EditorBrowsableState.Never)]
 453         public static readonly BindableProperty RightFocusableViewProperty = BindableProperty.Create(nameof(View.RightFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 454         {
 455             var view = (View)bindable;
 456             if (newValue != null) { view.RightFocusableViewId = (int)(newValue as View)?.GetId(); }
 457             else { view.RightFocusableViewId = -1; }
 458         },
 459         defaultValueCreator: (bindable) =>
 460         {
 461             var view = (View)bindable;
 462             if (view.RightFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.RightFocusableViewId); }
 463             return null;
 464         });
 465         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 466         [EditorBrowsable(EditorBrowsableState.Never)]
 467         public static readonly BindableProperty UpFocusableViewProperty = BindableProperty.Create(nameof(View.UpFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 468         {
 469             var view = (View)bindable;
 470             if (newValue != null) { view.UpFocusableViewId = (int)(newValue as View)?.GetId(); }
 471             else { view.UpFocusableViewId = -1; }
 472         },
 473         defaultValueCreator: (bindable) =>
 474         {
 475             var view = (View)bindable;
 476             if (view.UpFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.UpFocusableViewId); }
 477             return null;
 478         });
 479         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 480         [EditorBrowsable(EditorBrowsableState.Never)]
 481         public static readonly BindableProperty DownFocusableViewProperty = BindableProperty.Create(nameof(View.DownFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 482         {
 483             var view = (View)bindable;
 484             if (newValue != null) { view.DownFocusableViewId = (int)(newValue as View)?.GetId(); }
 485             else { view.DownFocusableViewId = -1; }
 486         },
 487         defaultValueCreator: (bindable) =>
 488         {
 489             var view = (View)bindable;
 490             if (view.DownFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.DownFocusableViewId); }
 491             return null;
 492         });
 493         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 494         [EditorBrowsable(EditorBrowsableState.Never)]
 495         public static readonly BindableProperty FocusableProperty = BindableProperty.Create("Focusable", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 496         {
 497             var view = (View)bindable;
 498             if (newValue != null) { view.SetKeyboardFocusable((bool)newValue); }
 499         },
 500         defaultValueCreator: (bindable) =>
 501         {
 502             var view = (View)bindable;
 503             return view.IsKeyboardFocusable();
 504         });
 505         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 506         [EditorBrowsable(EditorBrowsableState.Never)]
 507         public static readonly BindableProperty Size2DProperty = BindableProperty.Create("Size2D", typeof(Size2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 508         {
 509             var view = (View)bindable;
 510             if (newValue != null)
 511             {
 512                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size((Size2D)newValue)));
 513             }
 514         },
 515         defaultValueCreator: (bindable) =>
 516         {
 517             var view = (View)bindable;
 518             Size temp = new Size(0.0f, 0.0f, 0.0f);
 519             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE).Get(temp);
 520             Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
 521             return size;
 522         });
 523         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 524         [EditorBrowsable(EditorBrowsableState.Never)]
 525         public static readonly BindableProperty OpacityProperty = BindableProperty.Create("Opacity", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 526         {
 527             var view = (View)bindable;
 528             if (newValue != null)
 529             {
 530                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.OPACITY, new Tizen.NUI.PropertyValue((float)newValue));
 531             }
 532         },
 533         defaultValueCreator: (bindable) =>
 534         {
 535             var view = (View)bindable;
 536             float temp = 0.0f;
 537             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.OPACITY).Get(out temp);
 538             return temp;
 539         });
 540         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 541         [EditorBrowsable(EditorBrowsableState.Never)]
 542         public static readonly BindableProperty Position2DProperty = BindableProperty.Create("Position2D", typeof(Position2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 543         {
 544             var view = (View)bindable;
 545             if (newValue != null)
 546             {
 547                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position((Position2D)newValue)));
 548             }
 549         },
 550         defaultValueCreator: (bindable) =>
 551         {
 552             var view = (View)bindable;
 553             Position temp = new Position(0.0f, 0.0f, 0.0f);
 554             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION).Get(temp);
 555             return new Position2D(temp);
 556         });
 557         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 558         [EditorBrowsable(EditorBrowsableState.Never)]
 559         public static readonly BindableProperty PositionUsesPivotPointProperty = BindableProperty.Create("PositionUsesPivotPoint", typeof(bool), typeof(View), true, propertyChanged: (bindable, oldValue, newValue) =>
 560         {
 561             var view = (View)bindable;
 562             if (newValue != null)
 563             {
 564                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue((bool)newValue));
 565             }
 566         },
 567         defaultValueCreator: (bindable) =>
 568         {
 569             var view = (View)bindable;
 570             bool temp = false;
 571             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
 572             return temp;
 573         });
 574         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 575         [EditorBrowsable(EditorBrowsableState.Never)]
 576         public static readonly BindableProperty SiblingOrderProperty = BindableProperty.Create("SiblingOrder", typeof(int), typeof(View), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 577         {
 578             var view = (View)bindable;
 579             int value;
 580             if (newValue != null)
 581             {
 582                 value = (int)newValue;
 583                 if (value < 0)
 584                 {
 585                     NUILog.Error("SiblingOrder should be bigger than 0 or equal to 0.");
 586                     return;
 587                 }
 588                 var siblings = view.GetParent()?.Children;
 589                 if (siblings != null)
 590                 {
 591                     int currentOrder = siblings.IndexOf(view);
 592                     if (value != currentOrder)
 593                     {
 594                         if (value == 0) { view.LowerToBottom(); }
 595                         else if (value < siblings.Count - 1)
 596                         {
 597                             if (value > currentOrder) { view.RaiseAbove(siblings[value]); }
 598                             else { view.LowerBelow(siblings[value]); }
 599                         }
 600                         else { view.RaiseToTop(); }
 601                     }
 602                 }
 603             }
 604         },
 605         defaultValueCreator: (bindable) =>
 606         {
 607             var view = (View)bindable;
 608             var parentChildren = view.GetParent()?.Children;
 609             int currentOrder = 0;
 610             if (parentChildren != null)
 611             {
 612                 currentOrder = parentChildren.IndexOf(view);
 613
 614                 if (currentOrder < 0) { return 0; }
 615                 else if (currentOrder < parentChildren.Count) { return currentOrder; }
 616             }
 617
 618             return 0;
 619         });
 620         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 621         [EditorBrowsable(EditorBrowsableState.Never)]
 622         public static readonly BindableProperty ParentOriginProperty = BindableProperty.Create("ParentOrigin", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 623         {
 624             var view = (View)bindable;
 625             if (newValue != null)
 626             {
 627                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue((Position)newValue));
 628             }
 629         },
 630         defaultValueCreator: (bindable) =>
 631         {
 632             var view = (View)bindable;
 633             Position temp = new Position(0.0f, 0.0f, 0.0f);
 634             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.PARENT_ORIGIN).Get(temp);
 635             return temp;
 636         }
 637         );
 638         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 639         [EditorBrowsable(EditorBrowsableState.Never)]
 640         public static readonly BindableProperty PivotPointProperty = BindableProperty.Create("PivotPoint", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 641         {
 642             var view = (View)bindable;
 643             if (newValue != null)
 644             {
 645                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue((Position)newValue));
 646             }
 647         },
 648         defaultValueCreator: (bindable) =>
 649         {
 650             var view = (View)bindable;
 651             Position temp = new Position(0.0f, 0.0f, 0.0f);
 652             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.ANCHOR_POINT).Get(temp);
 653             return temp;
 654         });
 655         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 656         [EditorBrowsable(EditorBrowsableState.Never)]
 657         public static readonly BindableProperty SizeWidthProperty = BindableProperty.Create("SizeWidth", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 658         {
 659             var view = (View)bindable;
 660             if (newValue != null)
 661             {
 662                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue((float)newValue));
 663             }
 664         },
 665         defaultValueCreator: (bindable) =>
 666         {
 667             var view = (View)bindable;
 668             float temp = 0.0f;
 669             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_WIDTH).Get(out temp);
 670             return temp;
 671         });
 672         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 673         [EditorBrowsable(EditorBrowsableState.Never)]
 674         public static readonly BindableProperty SizeHeightProperty = BindableProperty.Create("SizeHeight", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 675         {
 676             var view = (View)bindable;
 677             if (newValue != null)
 678             {
 679                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue((float)newValue));
 680             }
 681         },
 682         defaultValueCreator: (bindable) =>
 683         {
 684             var view = (View)bindable;
 685             float temp = 0.0f;
 686             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_HEIGHT).Get(out temp);
 687             return temp;
 688         });
 689         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 690         [EditorBrowsable(EditorBrowsableState.Never)]
 691         public static readonly BindableProperty PositionProperty = BindableProperty.Create("Position", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 692         {
 693             var view = (View)bindable;
 694             if (newValue != null)
 695             {
 696                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION, new Tizen.NUI.PropertyValue((Position)newValue));
 697             }
 698         },
 699         defaultValueCreator: (bindable) =>
 700         {
 701             var view = (View)bindable;
 702             Position temp = new Position(0.0f, 0.0f, 0.0f);
 703             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION).Get(temp);
 704             return temp;
 705         });
 706         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 707         [EditorBrowsable(EditorBrowsableState.Never)]
 708         public static readonly BindableProperty PositionXProperty = BindableProperty.Create("PositionX", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 709         {
 710             var view = (View)bindable;
 711             if (newValue != null)
 712             {
 713                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_X, new Tizen.NUI.PropertyValue((float)newValue));
 714             }
 715         },
 716         defaultValueCreator: (bindable) =>
 717         {
 718             var view = (View)bindable;
 719             float temp = 0.0f;
 720             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_X).Get(out temp);
 721             return temp;
 722         });
 723         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 724         [EditorBrowsable(EditorBrowsableState.Never)]
 725         public static readonly BindableProperty PositionYProperty = BindableProperty.Create("PositionY", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 726         {
 727             var view = (View)bindable;
 728             if (newValue != null)
 729             {
 730                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_Y, new Tizen.NUI.PropertyValue((float)newValue));
 731             }
 732         },
 733         defaultValueCreator: (bindable) =>
 734         {
 735             var view = (View)bindable;
 736             float temp = 0.0f;
 737             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_Y).Get(out temp);
 738             return temp;
 739         });
 740         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 741         [EditorBrowsable(EditorBrowsableState.Never)]
 742         public static readonly BindableProperty PositionZProperty = BindableProperty.Create("PositionZ", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 743         {
 744             var view = (View)bindable;
 745             if (newValue != null)
 746             {
 747                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_Z, new Tizen.NUI.PropertyValue((float)newValue));
 748             }
 749         },
 750         defaultValueCreator: (bindable) =>
 751         {
 752             var view = (View)bindable;
 753             float temp = 0.0f;
 754             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_Z).Get(out temp);
 755             return temp;
 756         });
 757         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 758         [EditorBrowsable(EditorBrowsableState.Never)]
 759         public static readonly BindableProperty OrientationProperty = BindableProperty.Create("Orientation", typeof(Rotation), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 760         {
 761             var view = (View)bindable;
 762             if (newValue != null)
 763             {
 764                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.ORIENTATION, new Tizen.NUI.PropertyValue((Rotation)newValue));
 765             }
 766         },
 767         defaultValueCreator: (bindable) =>
 768         {
 769             var view = (View)bindable;
 770             Rotation temp = new Rotation();
 771             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.ORIENTATION).Get(temp);
 772             return temp;
 773         });
 774         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 775         [EditorBrowsable(EditorBrowsableState.Never)]
 776         public static readonly BindableProperty ScaleProperty = BindableProperty.Create("Scale", typeof(Vector3), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 777         {
 778             var view = (View)bindable;
 779             if (newValue != null)
 780             {
 781                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE, new Tizen.NUI.PropertyValue((Vector3)newValue));
 782             }
 783         },
 784         defaultValueCreator: (bindable) =>
 785         {
 786             var view = (View)bindable;
 787             Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
 788             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE).Get(temp);
 789             return temp;
 790         });
 791         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 792         [EditorBrowsable(EditorBrowsableState.Never)]
 793         public static readonly BindableProperty ScaleXProperty = BindableProperty.Create("ScaleX", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 794         {
 795             var view = (View)bindable;
 796             if (newValue != null)
 797             {
 798                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_X, new Tizen.NUI.PropertyValue((float)newValue));
 799             }
 800         },
 801         defaultValueCreator: (bindable) =>
 802         {
 803             var view = (View)bindable;
 804             float temp = 0.0f;
 805             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_X).Get(out temp);
 806             return temp;
 807         });
 808         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 809         [EditorBrowsable(EditorBrowsableState.Never)]
 810         public static readonly BindableProperty ScaleYProperty = BindableProperty.Create("ScaleY", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 811         {
 812             var view = (View)bindable;
 813             if (newValue != null)
 814             {
 815                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_Y, new Tizen.NUI.PropertyValue((float)newValue));
 816             }
 817         },
 818         defaultValueCreator: (bindable) =>
 819         {
 820             var view = (View)bindable;
 821             float temp = 0.0f;
 822             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_Y).Get(out temp);
 823             return temp;
 824         });
 825         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 826         [EditorBrowsable(EditorBrowsableState.Never)]
 827         public static readonly BindableProperty ScaleZProperty = BindableProperty.Create("ScaleZ", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 828         {
 829             var view = (View)bindable;
 830             if (newValue != null)
 831             {
 832                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_Z, new Tizen.NUI.PropertyValue((float)newValue));
 833             }
 834         },
 835         defaultValueCreator: (bindable) =>
 836         {
 837             var view = (View)bindable;
 838             float temp = 0.0f;
 839             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_Z).Get(out temp);
 840             return temp;
 841         });
 842         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 843         [EditorBrowsable(EditorBrowsableState.Never)]
 844         public static readonly BindableProperty NameProperty = BindableProperty.Create("Name", typeof(string), typeof(View), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
 845         {
 846             var view = (View)bindable;
 847             if (newValue != null)
 848             {
 849                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.NAME, new Tizen.NUI.PropertyValue((string)newValue));
 850             }
 851         },
 852         defaultValueCreator: (bindable) =>
 853         {
 854             var view = (View)bindable;
 855             string temp;
 856             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.NAME).Get(out temp);
 857             return temp;
 858         });
 859         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 860         [EditorBrowsable(EditorBrowsableState.Never)]
 861         public static readonly BindableProperty SensitiveProperty = BindableProperty.Create("Sensitive", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 862         {
 863             var view = (View)bindable;
 864             if (newValue != null)
 865             {
 866                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SENSITIVE, new Tizen.NUI.PropertyValue((bool)newValue));
 867             }
 868         },
 869         defaultValueCreator: (bindable) =>
 870         {
 871             var view = (View)bindable;
 872             bool temp = false;
 873             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SENSITIVE).Get(out temp);
 874             return temp;
 875         });
 876         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 877         [EditorBrowsable(EditorBrowsableState.Never)]
 878         public static readonly BindableProperty LeaveRequiredProperty = BindableProperty.Create("LeaveRequired", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 879         {
 880             var view = (View)bindable;
 881             if (newValue != null)
 882             {
 883                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue((bool)newValue));
 884             }
 885         },
 886         defaultValueCreator: (bindable) =>
 887         {
 888             var view = (View)bindable;
 889             bool temp = false;
 890             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.LEAVE_REQUIRED).Get(out temp);
 891             return temp;
 892         });
 893         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 894         [EditorBrowsable(EditorBrowsableState.Never)]
 895         public static readonly BindableProperty InheritOrientationProperty = BindableProperty.Create("InheritOrientation", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 896         {
 897             var view = (View)bindable;
 898             if (newValue != null)
 899             {
 900                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue((bool)newValue));
 901             }
 902         },
 903         defaultValueCreator: (bindable) =>
 904         {
 905             var view = (View)bindable;
 906             bool temp = false;
 907             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_ORIENTATION).Get(out temp);
 908             return temp;
 909         });
 910         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 911         [EditorBrowsable(EditorBrowsableState.Never)]
 912         public static readonly BindableProperty InheritScaleProperty = BindableProperty.Create("InheritScale", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 913         {
 914             var view = (View)bindable;
 915             if (newValue != null)
 916             {
 917                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue((bool)newValue));
 918             }
 919         },
 920         defaultValueCreator: (bindable) =>
 921         {
 922             var view = (View)bindable;
 923             bool temp = false;
 924             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_SCALE).Get(out temp);
 925             return temp;
 926         });
 927         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 928         [EditorBrowsable(EditorBrowsableState.Never)]
 929         public static readonly BindableProperty DrawModeProperty = BindableProperty.Create("DrawMode", typeof(DrawModeType), typeof(View), DrawModeType.Normal, propertyChanged: (bindable, oldValue, newValue) =>
 930         {
 931             var view = (View)bindable;
 932             if (newValue != null)
 933             {
 934                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)newValue));
 935             }
 936         },
 937         defaultValueCreator: (bindable) =>
 938         {
 939             var view = (View)bindable;
 940             string temp;
 941             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.DRAW_MODE).Get(out temp) == false)
 942             {
 943                 NUILog.Error("DrawMode get error!");
 944             }
 945             switch (temp)
 946             {
 947                 case "NORMAL": return DrawModeType.Normal;
 948                 case "OVERLAY_2D": return DrawModeType.Overlay2D;
 949 #pragma warning disable CS0618 // Disable deprecated warning as we do need to use the deprecated API here.
 950                 case "STENCIL": return DrawModeType.Stencil;
 951 #pragma warning restore CS0618
 952                 default: return DrawModeType.Normal;
 953             }
 954         });
 955         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 956         [EditorBrowsable(EditorBrowsableState.Never)]
 957         public static readonly BindableProperty SizeModeFactorProperty = BindableProperty.Create("SizeModeFactor", typeof(Vector3), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 958         {
 959             var view = (View)bindable;
 960             if (newValue != null)
 961             {
 962                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue((Vector3)newValue));
 963             }
 964         },
 965         defaultValueCreator: (bindable) =>
 966         {
 967             var view = (View)bindable;
 968             Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
 969             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_MODE_FACTOR).Get(temp);
 970             return temp;
 971         });
 972         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 973         [EditorBrowsable(EditorBrowsableState.Never)]
 974         public static readonly BindableProperty WidthResizePolicyProperty = BindableProperty.Create("WidthResizePolicy", typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed, propertyChanged: (bindable, oldValue, newValue) =>
 975         {
 976             var view = (View)bindable;
 977             if (newValue != null)
 978             {
 979                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)newValue));
 980             }
 981         },
 982         defaultValueCreator: (bindable) =>
 983         {
 984             var view = (View)bindable;
 985             string temp;
 986             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
 987             {
 988                 NUILog.Error("WidthResizePolicy get error!");
 989             }
 990             switch (temp)
 991             {
 992                 case "FIXED": return ResizePolicyType.Fixed;
 993                 case "USE_NATURAL_SIZE": return ResizePolicyType.UseNaturalSize;
 994                 case "FILL_TO_PARENT": return ResizePolicyType.FillToParent;
 995                 case "SIZE_RELATIVE_TO_PARENT": return ResizePolicyType.SizeRelativeToParent;
 996                 case "SIZE_FIXED_OFFSET_FROM_PARENT": return ResizePolicyType.SizeFixedOffsetFromParent;
 997                 case "FIT_TO_CHILDREN": return ResizePolicyType.FitToChildren;
 998                 case "DIMENSION_DEPENDENCY": return ResizePolicyType.DimensionDependency;
 999                 case "USE_ASSIGNED_SIZE": return ResizePolicyType.UseAssignedSize;
1000                 default: return ResizePolicyType.Fixed;
1001             }
1002         });
1003         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1004         [EditorBrowsable(EditorBrowsableState.Never)]
1005         public static readonly BindableProperty HeightResizePolicyProperty = BindableProperty.Create("HeightResizePolicy", typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed, propertyChanged: (bindable, oldValue, newValue) =>
1006         {
1007             var view = (View)bindable;
1008             if (newValue != null)
1009             {
1010                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)newValue));
1011             }
1012         },
1013         defaultValueCreator: (bindable) =>
1014         {
1015             var view = (View)bindable;
1016             string temp;
1017             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
1018             {
1019                 NUILog.Error("HeightResizePolicy get error!");
1020             }
1021             switch (temp)
1022             {
1023                 case "FIXED": return ResizePolicyType.Fixed;
1024                 case "USE_NATURAL_SIZE": return ResizePolicyType.UseNaturalSize;
1025                 case "FILL_TO_PARENT": return ResizePolicyType.FillToParent;
1026                 case "SIZE_RELATIVE_TO_PARENT": return ResizePolicyType.SizeRelativeToParent;
1027                 case "SIZE_FIXED_OFFSET_FROM_PARENT": return ResizePolicyType.SizeFixedOffsetFromParent;
1028                 case "FIT_TO_CHILDREN": return ResizePolicyType.FitToChildren;
1029                 case "DIMENSION_DEPENDENCY": return ResizePolicyType.DimensionDependency;
1030                 case "USE_ASSIGNED_SIZE": return ResizePolicyType.UseAssignedSize;
1031                 default: return ResizePolicyType.Fixed;
1032             }
1033         });
1034         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1035         [EditorBrowsable(EditorBrowsableState.Never)]
1036         public static readonly BindableProperty SizeScalePolicyProperty = BindableProperty.Create("SizeScalePolicy", typeof(SizeScalePolicyType), typeof(View), SizeScalePolicyType.UseSizeSet, propertyChanged: (bindable, oldValue, newValue) =>
1037         {
1038             var view = (View)bindable;
1039             string valueToString = "";
1040             if (newValue != null)
1041             {
1042                 switch ((SizeScalePolicyType)newValue)
1043                 {
1044                     case SizeScalePolicyType.UseSizeSet: { valueToString = "USE_SIZE_SET"; break; }
1045                     case SizeScalePolicyType.FitWithAspectRatio: { valueToString = "FIT_WITH_ASPECT_RATIO"; break; }
1046                     case SizeScalePolicyType.FillWithAspectRatio: { valueToString = "FILL_WITH_ASPECT_RATIO"; break; }
1047                     default: { valueToString = "USE_SIZE_SET"; break; }
1048                 }
1049                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
1050             }
1051         },
1052         defaultValueCreator: (bindable) =>
1053         {
1054             var view = (View)bindable;
1055             string temp;
1056             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
1057             {
1058                 NUILog.Error("SizeScalePolicy get error!");
1059             }
1060             switch (temp)
1061             {
1062                 case "USE_SIZE_SET": return SizeScalePolicyType.UseSizeSet;
1063                 case "FIT_WITH_ASPECT_RATIO": return SizeScalePolicyType.FitWithAspectRatio;
1064                 case "FILL_WITH_ASPECT_RATIO": return SizeScalePolicyType.FillWithAspectRatio;
1065                 default: return SizeScalePolicyType.UseSizeSet;
1066             }
1067         });
1068         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1069         [EditorBrowsable(EditorBrowsableState.Never)]
1070         public static readonly BindableProperty WidthForHeightProperty = BindableProperty.Create("WidthForHeight", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1071         {
1072             var view = (View)bindable;
1073             if (newValue != null)
1074             {
1075                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue((bool)newValue));
1076             }
1077         },
1078         defaultValueCreator: (bindable) =>
1079         {
1080             var view = (View)bindable;
1081             bool temp = false;
1082             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
1083             return temp;
1084         });
1085         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1086         [EditorBrowsable(EditorBrowsableState.Never)]
1087         public static readonly BindableProperty HeightForWidthProperty = BindableProperty.Create("HeightForWidth", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1088         {
1089             var view = (View)bindable;
1090             if (newValue != null)
1091             {
1092                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue((bool)newValue));
1093             }
1094         },
1095         defaultValueCreator: (bindable) =>
1096         {
1097             var view = (View)bindable;
1098             bool temp = false;
1099             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
1100             return temp;
1101         });
1102         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1103         [EditorBrowsable(EditorBrowsableState.Never)]
1104         public static readonly BindableProperty PaddingProperty = BindableProperty.Create("Padding", typeof(Extents), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1105         {
1106             var view = (View)bindable;
1107             if (newValue != null)
1108             {
1109                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.PADDING, new Tizen.NUI.PropertyValue((Extents)newValue));
1110             }
1111         },
1112         defaultValueCreator: (bindable) =>
1113         {
1114             var view = (View)bindable;
1115             Extents temp = new Extents(0, 0, 0, 0);
1116             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.PADDING).Get(temp);
1117             return temp;
1118         });
1119         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1120         [EditorBrowsable(EditorBrowsableState.Never)]
1121         public static readonly BindableProperty SizeProperty = BindableProperty.Create("Size", typeof(Size), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1122         {
1123             var view = (View)bindable;
1124             if (newValue != null)
1125             {
1126                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE, new Tizen.NUI.PropertyValue((Size)newValue));
1127             }
1128         },
1129         defaultValueCreator: (bindable) =>
1130         {
1131             var view = (View)bindable;
1132             Size temp = new Size(0, 0, 0);
1133             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE).Get(temp);
1134             return temp;
1135         });
1136         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1137         [EditorBrowsable(EditorBrowsableState.Never)]
1138         public static readonly BindableProperty MinimumSizeProperty = BindableProperty.Create("MinimumSize", typeof(Size2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1139         {
1140             var view = (View)bindable;
1141             if (newValue != null)
1142             {
1143                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue((Size2D)newValue));
1144             }
1145         },
1146         defaultValueCreator: (bindable) =>
1147         {
1148             var view = (View)bindable;
1149             Size2D temp = new Size2D(0, 0);
1150             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MINIMUM_SIZE).Get(temp);
1151             return temp;
1152         });
1153         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1154         [EditorBrowsable(EditorBrowsableState.Never)]
1155         public static readonly BindableProperty MaximumSizeProperty = BindableProperty.Create("MaximumSize", typeof(Size2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1156         {
1157             var view = (View)bindable;
1158             if (newValue != null)
1159             {
1160                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue((Size2D)newValue));
1161             }
1162         },
1163         defaultValueCreator: (bindable) =>
1164         {
1165             var view = (View)bindable;
1166             Size2D temp = new Size2D(0, 0);
1167             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MAXIMUM_SIZE).Get(temp);
1168             return temp;
1169         });
1170         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1171         [EditorBrowsable(EditorBrowsableState.Never)]
1172         public static readonly BindableProperty InheritPositionProperty = BindableProperty.Create("InheritPosition", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1173         {
1174             var view = (View)bindable;
1175             if (newValue != null)
1176             {
1177                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue((bool)newValue));
1178             }
1179         },
1180         defaultValueCreator: (bindable) =>
1181         {
1182             var view = (View)bindable;
1183             bool temp = false;
1184             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_POSITION).Get(out temp);
1185             return temp;
1186         });
1187         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1188         [EditorBrowsable(EditorBrowsableState.Never)]
1189         public static readonly BindableProperty ClippingModeProperty = BindableProperty.Create("ClippingMode", typeof(ClippingModeType), typeof(View), ClippingModeType.Disabled, propertyChanged: (bindable, oldValue, newValue) =>
1190         {
1191             var view = (View)bindable;
1192             if (newValue != null)
1193             {
1194                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)newValue));
1195             }
1196         },
1197         defaultValueCreator: (bindable) =>
1198         {
1199             var view = (View)bindable;
1200             int temp = 0;
1201             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.CLIPPING_MODE).Get(out temp) == false)
1202             {
1203                 NUILog.Error("ClippingMode get error!");
1204             }
1205             return (ClippingModeType)temp;
1206         });
1207         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1208         [EditorBrowsable(EditorBrowsableState.Never)]
1209         public static readonly BindableProperty InheritLayoutDirectionProperty = BindableProperty.Create("InheritLayoutDirection", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1210         {
1211             var view = (View)bindable;
1212             if (newValue != null)
1213             {
1214                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((bool)newValue));
1215             }
1216         },
1217         defaultValueCreator: (bindable) =>
1218         {
1219             var view = (View)bindable;
1220             bool temp = false;
1221             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_LAYOUT_DIRECTION).Get(out temp);
1222             return temp;
1223         });
1224         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1225         [EditorBrowsable(EditorBrowsableState.Never)]
1226         public static readonly BindableProperty LayoutDirectionProperty = BindableProperty.Create("LayoutDirection", typeof(ViewLayoutDirectionType), typeof(View), ViewLayoutDirectionType.LTR, propertyChanged: (bindable, oldValue, newValue) =>
1227         {
1228             var view = (View)bindable;
1229             if (newValue != null)
1230             {
1231                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((int)newValue));
1232             }
1233         },
1234         defaultValueCreator: (bindable) =>
1235         {
1236             var view = (View)bindable;
1237             int temp;
1238             if (false == Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.LAYOUT_DIRECTION).Get(out temp))
1239             {
1240                 NUILog.Error("LAYOUT_DIRECTION get error!");
1241             }
1242             return (ViewLayoutDirectionType)temp;
1243         });
1244         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1245         [EditorBrowsable(EditorBrowsableState.Never)]
1246         public static readonly BindableProperty MarginProperty = BindableProperty.Create("Margin", typeof(Extents), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1247         {
1248             var view = (View)bindable;
1249             if (newValue != null)
1250             {
1251                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MARGIN, new Tizen.NUI.PropertyValue((Extents)newValue));
1252             }
1253         },
1254         defaultValueCreator: (bindable) =>
1255         {
1256             var view = (View)bindable;
1257             Extents temp = new Extents(0, 0, 0, 0);
1258             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MARGIN).Get(temp);
1259             return temp;
1260         });
1261         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1262         [EditorBrowsable(EditorBrowsableState.Never)]
1263         public static readonly BindableProperty XamlStyleProperty = BindableProperty.Create("XamlStyle", typeof(Style), typeof(View), default(Style), propertyChanged: (bindable, oldvalue, newvalue) => ((View)bindable)._mergedStyle.Style = (Style)newvalue);
1264
1265         /// <summary>
1266         /// Flag to indicate if layout set explicitly via API call or View was automatically given a Layout.
1267         /// </summary>
1268         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1269         [EditorBrowsable(EditorBrowsableState.Never)]
1270         public bool layoutSet = false;
1271
1272         /// <summary>
1273         /// Flag to allow Layouting to be disabled for Views.
1274         /// Once a View has a Layout set then any children added to Views from then on will receive
1275         /// automatic Layouts.
1276         /// </summary>
1277         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
1278         [EditorBrowsable(EditorBrowsableState.Never)]
1279         public static bool layoutingDisabled{get; set;} = true;
1280
1281         private MergedStyle mergedStyle = null;
1282         internal MergedStyle _mergedStyle
1283         {
1284             get
1285             {
1286                 if (null == mergedStyle)
1287                 {
1288                     mergedStyle = new MergedStyle(GetType(), this);
1289                 }
1290
1291                 return mergedStyle;
1292             }
1293         }
1294
1295         private global::System.Runtime.InteropServices.HandleRef swigCPtr;
1296         private LayoutItem _layout; // Exclusive layout assigned to this View.
1297
1298         // List of transitions paired with the condition that uses the transition.
1299         private Dictionary<TransitionCondition, TransitionList> _layoutTransitions;
1300         private int _widthPolicy = LayoutParamPolicies.WrapContent; // Layout width policy
1301         private int _heightPolicy = LayoutParamPolicies.WrapContent; // Layout height policy
1302         private float _weight = 0.0f; // Weighting of child View in a Layout
1303         private MeasureSpecification _measureSpecificationWidth; // Layout width and internal Mode
1304         private MeasureSpecification _measureSpecificationHeight; // Layout height and internal Mode
1305         private bool _backgroundImageSynchronosLoading = false;
1306         private EventHandler _offWindowEventHandler;
1307         private OffWindowEventCallbackType _offWindowEventCallback;
1308         private EventHandlerWithReturnType<object, WheelEventArgs, bool> _wheelEventHandler;
1309         private WheelEventCallbackType _wheelEventCallback;
1310         private EventHandlerWithReturnType<object, KeyEventArgs, bool> _keyEventHandler;
1311         private KeyCallbackType _keyCallback;
1312         private EventHandlerWithReturnType<object, TouchEventArgs, bool> _touchDataEventHandler;
1313         private TouchDataCallbackType _touchDataCallback;
1314         private EventHandlerWithReturnType<object, HoverEventArgs, bool> _hoverEventHandler;
1315         private HoverEventCallbackType _hoverEventCallback;
1316         private EventHandler<VisibilityChangedEventArgs> _visibilityChangedEventHandler;
1317         private VisibilityChangedEventCallbackType _visibilityChangedEventCallback;
1318         private EventHandler _keyInputFocusGainedEventHandler;
1319         private KeyInputFocusGainedCallbackType _keyInputFocusGainedCallback;
1320         private EventHandler _keyInputFocusLostEventHandler;
1321         private KeyInputFocusLostCallbackType _keyInputFocusLostCallback;
1322         private EventHandler _onRelayoutEventHandler;
1323         private OnRelayoutEventCallbackType _onRelayoutEventCallback;
1324         private EventHandler _onWindowEventHandler;
1325         private OnWindowEventCallbackType _onWindowEventCallback;
1326         private EventHandler<LayoutDirectionChangedEventArgs> _layoutDirectionChangedEventHandler;
1327         private LayoutDirectionChangedEventCallbackType _layoutDirectionChangedEventCallback;
1328         // Resource Ready Signal
1329         private EventHandler _resourcesLoadedEventHandler;
1330         private ResourcesLoadedCallbackType _ResourcesLoadedCallback;
1331         private EventHandler<BackgroundResourceLoadedEventArgs> _backgroundResourceLoadedEventHandler;
1332         private _backgroundResourceLoadedCallbackType _backgroundResourceLoadedCallback;
1333
1334         private OnWindowEventCallbackType _onWindowSendEventCallback;
1335
1336         private void SendViewAddedEventToWindow(IntPtr data)
1337         {
1338             Window.Instance?.SendViewAdded(this);
1339         }
1340
1341         /// <summary>
1342         /// Creates a new instance of a view.
1343         /// </summary>
1344         /// <since_tizen> 3 </since_tizen>
1345         public View() : this(Interop.View.View_New(), true)
1346         {
1347             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1348         }
1349
1350         /// <summary>
1351         /// Create a new instance of a View with setting the status of shown or hidden.
1352         /// </summary>
1353         /// <param name="shown">false : Not displayed (hidden), true : displayed (shown)</param>
1354         /// This will be public opened in next release of tizen after ACR done. Before ACR, it is used as HiddenAPI (InhouseAPI).
1355         [EditorBrowsable(EditorBrowsableState.Never)]
1356         public View(bool shown) : this(Interop.View.View_New(), true)
1357         {
1358             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1359             SetVisible(shown);
1360         }
1361
1362         internal View(View uiControl, bool shown = true) : this(Interop.View.new_View__SWIG_1(View.getCPtr(uiControl)), true)
1363         {
1364             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1365             if(!shown)
1366             {
1367                 SetVisible(false);
1368             }
1369         }
1370
1371         internal View(global::System.IntPtr cPtr, bool cMemoryOwn, bool shown = true) : base(Interop.View.View_SWIGUpcast(cPtr), cMemoryOwn)
1372         {
1373             swigCPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
1374             if (HasBody())
1375             {
1376                 PositionUsesPivotPoint = false;
1377             }
1378
1379             _onWindowSendEventCallback = SendViewAddedEventToWindow;
1380             this.OnWindowSignal().Connect(_onWindowSendEventCallback);
1381
1382             if (!shown)
1383             {
1384                 SetVisible(false);
1385             }
1386         }
1387
1388         internal View(ViewImpl implementation, bool shown = true) : this(Interop.View.new_View__SWIG_2(ViewImpl.getCPtr(implementation)), true)
1389         {
1390             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
1391
1392             if (!shown)
1393             {
1394                 SetVisible(false);
1395             }
1396         }
1397
1398         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1399         private delegate void OffWindowEventCallbackType(IntPtr control);
1400         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1401         private delegate bool WheelEventCallbackType(IntPtr view, IntPtr wheelEvent);
1402         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1403         private delegate bool KeyCallbackType(IntPtr control, IntPtr keyEvent);
1404         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1405         private delegate bool TouchDataCallbackType(IntPtr view, IntPtr touchData);
1406         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1407         private delegate bool HoverEventCallbackType(IntPtr view, IntPtr hoverEvent);
1408         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1409         private delegate void VisibilityChangedEventCallbackType(IntPtr data, bool visibility, VisibilityChangeType type);
1410         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1411         private delegate void ResourcesLoadedCallbackType(IntPtr control);
1412         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1413         private delegate void _backgroundResourceLoadedCallbackType(IntPtr view);
1414         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1415         private delegate void KeyInputFocusGainedCallbackType(IntPtr control);
1416         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1417         private delegate void KeyInputFocusLostCallbackType(IntPtr control);
1418         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1419         private delegate void OnRelayoutEventCallbackType(IntPtr control);
1420         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1421         private delegate void OnWindowEventCallbackType(IntPtr control);
1422         [UnmanagedFunctionPointer(CallingConvention.StdCall)]
1423         private delegate void LayoutDirectionChangedEventCallbackType(IntPtr data, ViewLayoutDirectionType type);
1424
1425         /// <summary>
1426         /// Event when a child is removed.
1427         /// </summary>
1428         /// <since_tizen> 5 </since_tizen>
1429         public new event EventHandler<ChildRemovedEventArgs> ChildRemoved;
1430         /// <summary>
1431         /// Event when a child is added.
1432         /// </summary>
1433         /// <since_tizen> 5 </since_tizen>
1434         public new event EventHandler<ChildAddedEventArgs> ChildAdded;
1435
1436         /// <summary>
1437         /// An event for the KeyInputFocusGained signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1438         /// The KeyInputFocusGained signal is emitted when the control gets the key input focus.<br />
1439         /// </summary>
1440         /// <since_tizen> 3 </since_tizen>
1441         public event EventHandler FocusGained
1442         {
1443             add
1444             {
1445                 if (_keyInputFocusGainedEventHandler == null)
1446                 {
1447                     _keyInputFocusGainedCallback = OnKeyInputFocusGained;
1448                     this.KeyInputFocusGainedSignal().Connect(_keyInputFocusGainedCallback);
1449                 }
1450
1451                 _keyInputFocusGainedEventHandler += value;
1452             }
1453
1454             remove
1455             {
1456                 _keyInputFocusGainedEventHandler -= value;
1457
1458                 if (_keyInputFocusGainedEventHandler == null && KeyInputFocusGainedSignal().Empty() == false)
1459                 {
1460                     this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
1461                 }
1462             }
1463         }
1464
1465         /// <summary>
1466         /// An event for the KeyInputFocusLost signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1467         /// The KeyInputFocusLost signal is emitted when the control loses the key input focus.<br />
1468         /// </summary>
1469         /// <since_tizen> 3 </since_tizen>
1470         public event EventHandler FocusLost
1471         {
1472             add
1473             {
1474                 if (_keyInputFocusLostEventHandler == null)
1475                 {
1476                     _keyInputFocusLostCallback = OnKeyInputFocusLost;
1477                     this.KeyInputFocusLostSignal().Connect(_keyInputFocusLostCallback);
1478                 }
1479
1480                 _keyInputFocusLostEventHandler += value;
1481             }
1482
1483             remove
1484             {
1485                 _keyInputFocusLostEventHandler -= value;
1486
1487                 if (_keyInputFocusLostEventHandler == null && KeyInputFocusLostSignal().Empty() == false)
1488                 {
1489                     this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
1490                 }
1491             }
1492         }
1493
1494         /// <summary>
1495         /// An event for the KeyPressed signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1496         /// The KeyPressed signal is emitted when the key event is received.<br />
1497         /// </summary>
1498         /// <since_tizen> 3 </since_tizen>
1499         public event EventHandlerWithReturnType<object, KeyEventArgs, bool> KeyEvent
1500         {
1501             add
1502             {
1503                 if (_keyEventHandler == null)
1504                 {
1505                     _keyCallback = OnKeyEvent;
1506                     this.KeyEventSignal().Connect(_keyCallback);
1507                 }
1508
1509                 _keyEventHandler += value;
1510             }
1511
1512             remove
1513             {
1514                 _keyEventHandler -= value;
1515
1516                 if (_keyEventHandler == null && KeyEventSignal().Empty() == false)
1517                 {
1518                     this.KeyEventSignal().Disconnect(_keyCallback);
1519                 }
1520             }
1521         }
1522
1523         /// <summary>
1524         /// An event for the OnRelayout signal which can be used to subscribe or unsubscribe the event handler.<br />
1525         /// The OnRelayout signal is emitted after the size has been set on the view during relayout.<br />
1526         /// </summary>
1527         /// <since_tizen> 3 </since_tizen>
1528         public event EventHandler Relayout
1529         {
1530             add
1531             {
1532                 if (_onRelayoutEventHandler == null)
1533                 {
1534                     _onRelayoutEventCallback = OnRelayout;
1535                     this.OnRelayoutSignal().Connect(_onRelayoutEventCallback);
1536                 }
1537
1538                 _onRelayoutEventHandler += value;
1539             }
1540
1541             remove
1542             {
1543                 _onRelayoutEventHandler -= value;
1544
1545                 if (_onRelayoutEventHandler == null && OnRelayoutSignal().Empty() == false)
1546                 {
1547                     this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
1548                 }
1549
1550             }
1551         }
1552
1553         /// <summary>
1554         /// An event for the touched signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1555         /// The touched signal is emitted when the touch input is received.<br />
1556         /// </summary>
1557         /// <since_tizen> 3 </since_tizen>
1558         public event EventHandlerWithReturnType<object, TouchEventArgs, bool> TouchEvent
1559         {
1560             add
1561             {
1562                 if (_touchDataEventHandler == null)
1563                 {
1564                     _touchDataCallback = OnTouch;
1565                     this.TouchSignal().Connect(_touchDataCallback);
1566                 }
1567
1568                 _touchDataEventHandler += value;
1569             }
1570
1571             remove
1572             {
1573                 _touchDataEventHandler -= value;
1574
1575                 if (_touchDataEventHandler == null && TouchSignal().Empty() == false)
1576                 {
1577                     this.TouchSignal().Disconnect(_touchDataCallback);
1578                 }
1579
1580             }
1581         }
1582
1583         /// <summary>
1584         /// An event for the hovered signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1585         /// The hovered signal is emitted when the hover input is received.<br />
1586         /// </summary>
1587         /// <since_tizen> 3 </since_tizen>
1588         public event EventHandlerWithReturnType<object, HoverEventArgs, bool> HoverEvent
1589         {
1590             add
1591             {
1592                 if (_hoverEventHandler == null)
1593                 {
1594                     _hoverEventCallback = OnHoverEvent;
1595                     this.HoveredSignal().Connect(_hoverEventCallback);
1596                 }
1597
1598                 _hoverEventHandler += value;
1599             }
1600
1601             remove
1602             {
1603                 _hoverEventHandler -= value;
1604
1605                 if (_hoverEventHandler == null && HoveredSignal().Empty() == false)
1606                 {
1607                     this.HoveredSignal().Disconnect(_hoverEventCallback);
1608                 }
1609
1610             }
1611         }
1612
1613         /// <summary>
1614         /// An event for the WheelMoved signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1615         /// The WheelMoved signal is emitted when the wheel event is received.<br />
1616         /// </summary>
1617         /// <since_tizen> 3 </since_tizen>
1618         public event EventHandlerWithReturnType<object, WheelEventArgs, bool> WheelEvent
1619         {
1620             add
1621             {
1622                 if (_wheelEventHandler == null)
1623                 {
1624                     _wheelEventCallback = OnWheelEvent;
1625                     this.WheelEventSignal().Connect(_wheelEventCallback);
1626                 }
1627
1628                 _wheelEventHandler += value;
1629             }
1630
1631             remove
1632             {
1633                 _wheelEventHandler -= value;
1634
1635                 if (_wheelEventHandler == null && WheelEventSignal().Empty() == false)
1636                 {
1637                     this.WheelEventSignal().Disconnect(_wheelEventCallback);
1638                 }
1639
1640             }
1641         }
1642
1643         /// <summary>
1644         /// An event for the OnWindow signal which can be used to subscribe or unsubscribe the event handler.<br />
1645         /// The OnWindow signal is emitted after the view has been connected to the window.<br />
1646         /// </summary>
1647         /// <since_tizen> 3 </since_tizen>
1648         public event EventHandler AddedToWindow
1649         {
1650             add
1651             {
1652                 if (_onWindowEventHandler == null)
1653                 {
1654                     _onWindowEventCallback = OnWindow;
1655                     this.OnWindowSignal().Connect(_onWindowEventCallback);
1656                 }
1657
1658                 _onWindowEventHandler += value;
1659             }
1660
1661             remove
1662             {
1663                 _onWindowEventHandler -= value;
1664
1665                 if (_onWindowEventHandler == null && OnWindowSignal().Empty() == false)
1666                 {
1667                     this.OnWindowSignal().Disconnect(_onWindowEventCallback);
1668                 }
1669             }
1670         }
1671
1672         /// <summary>
1673         /// An event for the OffWindow signal, which can be used to subscribe or unsubscribe the event handler.<br />
1674         /// OffWindow signal is emitted after the view has been disconnected from the window.<br />
1675         /// </summary>
1676         /// <since_tizen> 3 </since_tizen>
1677         public event EventHandler RemovedFromWindow
1678         {
1679             add
1680             {
1681                 if (_offWindowEventHandler == null)
1682                 {
1683                     _offWindowEventCallback = OffWindow;
1684                     this.OffWindowSignal().Connect(_offWindowEventCallback);
1685                 }
1686
1687                 _offWindowEventHandler += value;
1688             }
1689
1690             remove
1691             {
1692                 _offWindowEventHandler -= value;
1693
1694                 if (_offWindowEventHandler == null && OffWindowSignal().Empty() == false)
1695                 {
1696                     this.OffWindowSignal().Disconnect(_offWindowEventCallback);
1697                 }
1698             }
1699         }
1700
1701         /// <summary>
1702         /// An event for visibility change which can be used to subscribe or unsubscribe the event handler.<br />
1703         /// This signal is emitted when the visible property of this or a parent view is changed.<br />
1704         /// </summary>
1705         /// <since_tizen> 3 </since_tizen>
1706         public event EventHandler<VisibilityChangedEventArgs> VisibilityChanged
1707         {
1708             add
1709             {
1710                 if (_visibilityChangedEventHandler == null)
1711                 {
1712                     _visibilityChangedEventCallback = OnVisibilityChanged;
1713                     VisibilityChangedSignal(this).Connect(_visibilityChangedEventCallback);
1714                 }
1715
1716                 _visibilityChangedEventHandler += value;
1717             }
1718
1719             remove
1720             {
1721                 _visibilityChangedEventHandler -= value;
1722
1723                 if (_visibilityChangedEventHandler == null && VisibilityChangedSignal(this).Empty() == false)
1724                 {
1725                     VisibilityChangedSignal(this).Disconnect(_visibilityChangedEventCallback);
1726                 }
1727             }
1728         }
1729
1730         /// <summary>
1731         /// Event for layout direction change which can be used to subscribe/unsubscribe the event handler.<br />
1732         /// This signal is emitted when the layout direction property of this or a parent view is changed.<br />
1733         /// </summary>
1734         /// <since_tizen> 4 </since_tizen>
1735         public event EventHandler<LayoutDirectionChangedEventArgs> LayoutDirectionChanged
1736         {
1737             add
1738             {
1739                 if (_layoutDirectionChangedEventHandler == null)
1740                 {
1741                     _layoutDirectionChangedEventCallback = OnLayoutDirectionChanged;
1742                     LayoutDirectionChangedSignal(this).Connect(_layoutDirectionChangedEventCallback);
1743                 }
1744
1745                 _layoutDirectionChangedEventHandler += value;
1746             }
1747
1748             remove
1749             {
1750                 _layoutDirectionChangedEventHandler -= value;
1751
1752                 if (_layoutDirectionChangedEventHandler == null && LayoutDirectionChangedSignal(this).Empty() == false)
1753                 {
1754                     LayoutDirectionChangedSignal(this).Disconnect(_layoutDirectionChangedEventCallback);
1755                 }
1756             }
1757         }
1758
1759         /// <summary>
1760         /// An event for the ResourcesLoadedSignal signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
1761         /// This signal is emitted after all resources required by a view are loaded and ready.<br />
1762         /// </summary>
1763         /// <since_tizen> 3 </since_tizen>
1764         public event EventHandler ResourcesLoaded
1765         {
1766             add
1767             {
1768                 if (_resourcesLoadedEventHandler == null)
1769                 {
1770                     _ResourcesLoadedCallback = OnResourcesLoaded;
1771                     this.ResourcesLoadedSignal().Connect(_ResourcesLoadedCallback);
1772                 }
1773
1774                 _resourcesLoadedEventHandler += value;
1775             }
1776
1777             remove
1778             {
1779                 _resourcesLoadedEventHandler -= value;
1780
1781                 if (_resourcesLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false)
1782                 {
1783                     this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback);
1784                 }
1785             }
1786         }
1787
1788         internal event EventHandler<BackgroundResourceLoadedEventArgs> BackgroundResourceLoaded
1789         {
1790             add
1791             {
1792                 if (_backgroundResourceLoadedEventHandler == null)
1793                 {
1794                     _backgroundResourceLoadedCallback = OnBackgroundResourceLoaded;
1795                     this.ResourcesLoadedSignal().Connect(_backgroundResourceLoadedCallback);
1796                 }
1797
1798                 _backgroundResourceLoadedEventHandler += value;
1799             }
1800             remove
1801             {
1802                 _backgroundResourceLoadedEventHandler -= value;
1803
1804                 if (_backgroundResourceLoadedEventHandler == null && ResourcesLoadedSignal().Empty() == false)
1805                 {
1806                     this.ResourcesLoadedSignal().Disconnect(_backgroundResourceLoadedCallback);
1807                 }
1808             }
1809         }
1810
1811         /// <summary>
1812         /// Enumeration for describing the states of the view.
1813         /// </summary>
1814         /// <since_tizen> 3 </since_tizen>
1815         public enum States
1816         {
1817             /// <summary>
1818             /// The normal state.
1819             /// </summary>
1820             Normal,
1821             /// <summary>
1822             /// The focused state.
1823             /// </summary>
1824             Focused,
1825             /// <summary>
1826             /// The disabled state.
1827             /// </summary>
1828             Disabled
1829         }
1830
1831         /// <summary>
1832         /// Describes the direction to move the focus towards.
1833         /// </summary>
1834         /// <since_tizen> 3 </since_tizen>
1835         public enum FocusDirection
1836         {
1837             /// <summary>
1838             /// Move keyboard focus towards the left direction.
1839             /// </summary>
1840             /// <since_tizen> 3 </since_tizen>
1841             Left,
1842             /// <summary>
1843             /// Move keyboard focus towards the right direction.
1844             /// </summary>
1845             /// <since_tizen> 3 </since_tizen>
1846             Right,
1847             /// <summary>
1848             /// Move keyboard focus towards the up direction.
1849             /// </summary>
1850             /// <since_tizen> 3 </since_tizen>
1851             Up,
1852             /// <summary>
1853             /// Move keyboard focus towards the down direction.
1854             /// </summary>
1855             /// <since_tizen> 3 </since_tizen>
1856             Down,
1857             /// <summary>
1858             /// Move keyboard focus towards the previous page direction.
1859             /// </summary>
1860             /// <since_tizen> 3 </since_tizen>
1861             PageUp,
1862             /// <summary>
1863             /// Move keyboard focus towards the next page direction.
1864             /// </summary>
1865             /// <since_tizen> 3 </since_tizen>
1866             PageDown
1867         }
1868
1869         internal enum PropertyRange
1870         {
1871             PROPERTY_START_INDEX = PropertyRanges.PROPERTY_REGISTRATION_START_INDEX,
1872             CONTROL_PROPERTY_START_INDEX = PROPERTY_START_INDEX,
1873             CONTROL_PROPERTY_END_INDEX = CONTROL_PROPERTY_START_INDEX + 1000
1874         }
1875
1876         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1877         [EditorBrowsable(EditorBrowsableState.Never)]
1878         public bool IsResourcesCreated
1879         {
1880             get
1881             {
1882                 return Application.Current.IsResourcesCreated;
1883             }
1884         }
1885
1886         /// This will be public opened in tizen_5.0 after ACR done. Before ACR, need to be hidden as inhouse API.
1887         [EditorBrowsable(EditorBrowsableState.Never)]
1888         public ResourceDictionary XamlResources
1889         {
1890             get
1891             {
1892                 return Application.Current.XamlResources;
1893             }
1894             set
1895             {
1896                 Application.Current.XamlResources = value;
1897             }
1898         }
1899
1900         /// <summary>
1901         /// The StyleName, type string.
1902         /// </summary>
1903         /// <since_tizen> 3 </since_tizen>
1904         public string StyleName
1905         {
1906             get
1907             {
1908                 return (string)GetValue(StyleNameProperty);
1909             }
1910             set
1911             {
1912                 SetValue(StyleNameProperty, value);
1913                 NotifyPropertyChanged();
1914             }
1915         }
1916
1917         /// <summary>
1918         /// The mutually exclusive with BACKGROUND_IMAGE and BACKGROUND type Vector4.
1919         /// </summary>
1920         /// <since_tizen> 3 </since_tizen>
1921         public Color BackgroundColor
1922         {
1923             get
1924             {
1925                 return (Color)GetValue(BackgroundColorProperty);
1926             }
1927             set
1928             {
1929                 SetValue(BackgroundColorProperty, value);
1930                 NotifyPropertyChanged();
1931             }
1932         }
1933
1934         /// <summary>
1935         /// The mutually exclusive with BACKGROUND_COLOR and BACKGROUND type Map.
1936         /// </summary>
1937         /// <since_tizen> 3 </since_tizen>
1938         public string BackgroundImage
1939         {
1940             get
1941             {
1942                 return (string)GetValue(BackgroundImageProperty);
1943             }
1944             set
1945             {
1946                 SetValue(BackgroundImageProperty, value);
1947                 NotifyPropertyChanged();
1948             }
1949         }
1950
1951         /// <summary>
1952         /// The background of view.
1953         /// </summary>
1954         /// <since_tizen> 3 </since_tizen>
1955         public Tizen.NUI.PropertyMap Background
1956         {
1957             get
1958             {
1959                 return (PropertyMap)GetValue(BackgroundProperty);
1960             }
1961             set
1962             {
1963                 SetValue(BackgroundProperty, value);
1964                 NotifyPropertyChanged();
1965             }
1966         }
1967
1968
1969         /// <summary>
1970         /// The current state of the view.
1971         /// </summary>
1972         /// <since_tizen> 3 </since_tizen>
1973         public States State
1974         {
1975             get
1976             {
1977                 return (States)GetValue(StateProperty);
1978             }
1979             set
1980             {
1981                 SetValue(StateProperty, value);
1982                 NotifyPropertyChanged();
1983             }
1984         }
1985
1986         /// <summary>
1987         /// The current sub state of the view.
1988         /// </summary>
1989         /// <since_tizen> 3 </since_tizen>
1990         public States SubState
1991         {
1992             get
1993             {
1994                 return (States)GetValue(SubStateProperty);
1995             }
1996             set
1997             {
1998                 SetValue(SubStateProperty, value);
1999                 NotifyPropertyChanged();
2000             }
2001         }
2002
2003         /// <summary>
2004         /// Displays a tooltip
2005         /// </summary>
2006         /// <since_tizen> 3 </since_tizen>
2007         public Tizen.NUI.PropertyMap Tooltip
2008         {
2009             get
2010             {
2011                 return (PropertyMap)GetValue(TooltipProperty);
2012             }
2013             set
2014             {
2015                 SetValue(TooltipProperty, value);
2016                 NotifyPropertyChanged();
2017             }
2018         }
2019
2020         /// <summary>
2021         /// Displays a tooltip as a text.
2022         /// </summary>
2023         /// <since_tizen> 3 </since_tizen>
2024         public string TooltipText
2025         {
2026             set
2027             {
2028                 SetProperty(View.Property.TOOLTIP, new Tizen.NUI.PropertyValue(value));
2029                 NotifyPropertyChanged();
2030             }
2031         }
2032
2033         /// <summary>
2034         /// The Child property of FlexContainer.<br />
2035         /// The proportion of the free space in the container, the flex item will receive.<br />
2036         /// If all items in the container set this property, their sizes will be proportional to the specified flex factor.<br />
2037         /// </summary>
2038         /// <since_tizen> 3 </since_tizen>
2039         public float Flex
2040         {
2041             get
2042             {
2043                 return (float)GetValue(FlexProperty);
2044             }
2045             set
2046             {
2047                 SetValue(FlexProperty, value);
2048                 NotifyPropertyChanged();
2049             }
2050         }
2051
2052         /// <summary>
2053         /// The Child property of FlexContainer.<br />
2054         /// The alignment of the flex item along the cross axis, which, if set, overides the default alignment for all items in the container.<br />
2055         /// </summary>
2056         /// <since_tizen> 3 </since_tizen>
2057         public int AlignSelf
2058         {
2059             get
2060             {
2061                 return (int)GetValue(AlignSelfProperty);
2062             }
2063             set
2064             {
2065                 SetValue(AlignSelfProperty, value);
2066                 NotifyPropertyChanged();
2067             }
2068         }
2069
2070         /// <summary>
2071         /// The Child property of FlexContainer.<br />
2072         /// The space around the flex item.<br />
2073         /// </summary>
2074         /// <since_tizen> 3 </since_tizen>
2075         public Vector4 FlexMargin
2076         {
2077             get
2078             {
2079                 return (Vector4)GetValue(FlexMarginProperty);
2080             }
2081             set
2082             {
2083                 SetValue(FlexMarginProperty, value);
2084                 NotifyPropertyChanged();
2085             }
2086         }
2087
2088         /// <summary>
2089         /// The top-left cell this child occupies, if not set, the first available cell is used.
2090         /// </summary>
2091         /// <since_tizen> 3 </since_tizen>
2092         public Vector2 CellIndex
2093         {
2094             get
2095             {
2096                 return (Vector2)GetValue(CellIndexProperty);
2097             }
2098             set
2099             {
2100                 SetValue(CellIndexProperty, value);
2101                 NotifyPropertyChanged();
2102             }
2103         }
2104
2105         /// <summary>
2106         /// The number of rows this child occupies, if not set, the default value is 1.
2107         /// </summary>
2108         /// <since_tizen> 3 </since_tizen>
2109         public float RowSpan
2110         {
2111             get
2112             {
2113                 return (float)GetValue(RowSpanProperty);
2114             }
2115             set
2116             {
2117                 SetValue(RowSpanProperty, value);
2118                 NotifyPropertyChanged();
2119             }
2120         }
2121
2122         /// <summary>
2123         /// The number of columns this child occupies, if not set, the default value is 1.
2124         /// </summary>
2125         /// <since_tizen> 3 </since_tizen>
2126         public float ColumnSpan
2127         {
2128             get
2129             {
2130                 return (float)GetValue(ColumnSpanProperty);
2131             }
2132             set
2133             {
2134                 SetValue(ColumnSpanProperty, value);
2135                 NotifyPropertyChanged();
2136             }
2137         }
2138
2139         /// <summary>
2140         /// The horizontal alignment of this child inside the cells, if not set, the default value is 'left'.
2141         /// </summary>
2142         /// <since_tizen> 3 </since_tizen>
2143         public Tizen.NUI.HorizontalAlignmentType CellHorizontalAlignment
2144         {
2145             get
2146             {
2147                 return (HorizontalAlignmentType)GetValue(CellHorizontalAlignmentProperty);
2148             }
2149             set
2150             {
2151                 SetValue(CellHorizontalAlignmentProperty, value);
2152                 NotifyPropertyChanged();
2153             }
2154         }
2155
2156         /// <summary>
2157         /// The vertical alignment of this child inside the cells, if not set, the default value is 'top'.
2158         /// </summary>
2159         /// <since_tizen> 3 </since_tizen>
2160         public Tizen.NUI.VerticalAlignmentType CellVerticalAlignment
2161         {
2162             get
2163             {
2164                 return (VerticalAlignmentType)GetValue(CellVerticalAlignmentProperty);
2165             }
2166             set
2167             {
2168                 SetValue(CellVerticalAlignmentProperty, value);
2169                 NotifyPropertyChanged();
2170             }
2171         }
2172
2173         /// <summary>
2174         /// The left focusable view.<br />
2175         /// This will return null if not set.<br />
2176         /// This will also return null if the specified left focusable view is not on a window.<br />
2177         /// </summary>
2178         /// <since_tizen> 3 </since_tizen>
2179         public View LeftFocusableView
2180         {
2181             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
2182             get
2183             {
2184                 return (View)GetValue(LeftFocusableViewProperty);
2185             }
2186             set
2187             {
2188                 SetValue(LeftFocusableViewProperty, value);
2189                 NotifyPropertyChanged();
2190             }
2191         }
2192
2193         /// <summary>
2194         /// The right focusable view.<br />
2195         /// This will return null if not set.<br />
2196         /// This will also return null if the specified right focusable view is not on a window.<br />
2197         /// </summary>
2198         /// <since_tizen> 3 </since_tizen>
2199         public View RightFocusableView
2200         {
2201             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
2202             get
2203             {
2204                 return (View)GetValue(RightFocusableViewProperty);
2205             }
2206             set
2207             {
2208                 SetValue(RightFocusableViewProperty, value);
2209                 NotifyPropertyChanged();
2210             }
2211         }
2212
2213         /// <summary>
2214         /// The up focusable view.<br />
2215         /// This will return null if not set.<br />
2216         /// This will also return null if the specified up focusable view is not on a window.<br />
2217         /// </summary>
2218         /// <since_tizen> 3 </since_tizen>
2219         public View UpFocusableView
2220         {
2221             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
2222             get
2223             {
2224                 return (View)GetValue(UpFocusableViewProperty);
2225             }
2226             set
2227             {
2228                 SetValue(UpFocusableViewProperty, value);
2229                 NotifyPropertyChanged();
2230             }
2231         }
2232
2233         /// <summary>
2234         /// The down focusable view.<br />
2235         /// This will return null if not set.<br />
2236         /// This will also return null if the specified down focusable view is not on a window.<br />
2237         /// </summary>
2238         /// <since_tizen> 3 </since_tizen>
2239         public View DownFocusableView
2240         {
2241             // As native side will be only storing IDs so need a logic to convert View to ID and vice-versa.
2242             get
2243             {
2244                 return (View)GetValue(DownFocusableViewProperty);
2245             }
2246             set
2247             {
2248                 SetValue(DownFocusableViewProperty, value);
2249                 NotifyPropertyChanged();
2250             }
2251         }
2252
2253         /// <summary>
2254         /// Whether the view should be focusable by keyboard navigation.
2255         /// </summary>
2256         /// <since_tizen> 3 </since_tizen>
2257         public bool Focusable
2258         {
2259             set
2260             {
2261                 SetValue(FocusableProperty, value);
2262                 NotifyPropertyChanged();
2263             }
2264             get
2265             {
2266                 return (bool)GetValue(FocusableProperty);
2267             }
2268         }
2269
2270         /// <summary>
2271         ///  Retrieves the position of the view.<br />
2272         ///  The coordinates are relative to the view's parent.<br />
2273         /// </summary>
2274         /// <since_tizen> 3 </since_tizen>
2275         public Position CurrentPosition
2276         {
2277             get
2278             {
2279                 return GetCurrentPosition();
2280             }
2281         }
2282
2283         /// <summary>
2284         /// Sets the size of a view for the width and the height.<br />
2285         /// Geometry can be scaled to fit within this area.<br />
2286         /// This does not interfere with the view's scale factor.<br />
2287         /// The views default depth is the minimum of width and height.<br />
2288         /// </summary>
2289         /// <remarks>
2290         /// This NUI object (Size2D) typed property can be configured by multiple cascade setting. <br />
2291         /// For example, this code ( view.Size2D.Width = 100; view.Size2D.Height = 100; ) is equivalent to this ( view.Size2D = new Size2D(100, 100); ). <br />
2292         /// Please note that this multi-cascade setting is especially possible for this NUI object (Size2D). <br />
2293         /// This means by default others are impossible so it is recommended that NUI object typed properties are configured by their constructor with parameters. <br />
2294         /// For example, this code is working fine : view.Scale = new Vector3( 2.0f, 1.5f, 0.0f); <br />
2295         /// but this will not work! : view.Scale.X = 2.0f; view.Scale.Y = 1.5f; <br />
2296         /// It may not match the current value in some cases, i.e. when the animation is progressing or the maximum or minimum size is set. <br />
2297         /// </remarks>
2298         /// <since_tizen> 3 </since_tizen>
2299         public Size2D Size2D
2300         {
2301             get
2302             {
2303                 Size2D temp = (Size2D)GetValue(Size2DProperty);
2304                 return new Size2D(OnSize2DChanged, temp.Width, temp.Height);
2305             }
2306             set
2307             {
2308                 SetValue(Size2DProperty, value);
2309                 // Set Specification so when layouts measure this View it matches the value set here.
2310                 // All Views are currently Layouts.
2311                 MeasureSpecificationWidth = new MeasureSpecification(new LayoutLength(value.Width), MeasureSpecification.ModeType.Exactly);
2312                 MeasureSpecificationHeight = new MeasureSpecification(new LayoutLength(value.Height), MeasureSpecification.ModeType.Exactly);
2313                 _widthPolicy = value.Width;
2314                 _heightPolicy = value.Height;
2315                 _layout?.RequestLayout();
2316                 NotifyPropertyChanged();
2317             }
2318         }
2319
2320         /// <summary>
2321         ///  Retrieves the size of the view.<br />
2322         ///  The coordinates are relative to the view's parent.<br />
2323         /// </summary>
2324         /// <since_tizen> 3 </since_tizen>
2325         public Size2D CurrentSize
2326         {
2327             get
2328             {
2329                 return GetCurrentSize();
2330             }
2331         }
2332
2333         /// <summary>
2334         /// Retrieves and sets the view's opacity.<br />
2335         /// </summary>
2336         /// <since_tizen> 3 </since_tizen>
2337         public float Opacity
2338         {
2339             get
2340             {
2341                 return (float)GetValue(OpacityProperty);
2342             }
2343             set
2344             {
2345                 SetValue(OpacityProperty, value);
2346                 NotifyPropertyChanged();
2347             }
2348         }
2349
2350         /// <summary>
2351         /// Sets the position of the view for X and Y.<br />
2352         /// By default, sets the position vector between the parent origin and the pivot point (default).<br />
2353         /// If the position inheritance is disabled, sets the world position.<br />
2354         /// </summary>
2355         /// <remarks>
2356         /// This NUI object (Position2D) typed property can be configured by multiple cascade setting. <br />
2357         /// For example, this code ( view.Position2D.X = 100; view.Position2D.Y = 100; ) is equivalent to this ( view.Position2D = new Position2D(100, 100); ). <br />
2358         /// Please note that this multi-cascade setting is especially possible for this NUI object (Position2D). <br />
2359         /// This means by default others are impossible so it is recommended that NUI object typed properties are configured by their constructor with parameters. <br />
2360         /// For example, this code is working fine : view.Scale = new Vector3( 2.0f, 1.5f, 0.0f); <br />
2361         /// but this will not work! : view.Scale.X = 2.0f; view.Scale.Y = 1.5f; <br />
2362         /// </remarks>
2363         /// <since_tizen> 3 </since_tizen>
2364         public Position2D Position2D
2365         {
2366             get
2367             {
2368                 Position2D temp = (Position2D)GetValue(Position2DProperty);
2369                 return new Position2D(OnPosition2DChanged, temp.X, temp.Y);
2370             }
2371             set
2372             {
2373                 SetValue(Position2DProperty, value);
2374                 NotifyPropertyChanged();
2375             }
2376         }
2377
2378         /// <summary>
2379         /// Retrieves the screen postion of the view.<br />
2380         /// </summary>
2381         /// <since_tizen> 3 </since_tizen>
2382         public Vector2 ScreenPosition
2383         {
2384             get
2385             {
2386                 Vector2 temp = new Vector2(0.0f, 0.0f);
2387                 GetProperty(View.Property.SCREEN_POSITION).Get(temp);
2388                 return temp;
2389             }
2390         }
2391
2392         /// <summary>
2393         /// Determines whether the pivot point should be used to determine the position of the view.
2394         /// This is true by default.
2395         /// </summary>
2396         /// <remarks>If false, then the top-left of the view is used for the position.
2397         /// Setting this to false will allow scaling or rotation around the pivot point without affecting the view's position.
2398         /// </remarks>
2399         /// <since_tizen> 3 </since_tizen>
2400         public bool PositionUsesPivotPoint
2401         {
2402             get
2403             {
2404                 return (bool)GetValue(PositionUsesPivotPointProperty);
2405             }
2406             set
2407             {
2408                 SetValue(PositionUsesPivotPointProperty, value);
2409                 NotifyPropertyChanged();
2410             }
2411         }
2412
2413         /// <summary>
2414         /// Deprecated in API5; Will be removed in API8. Please use PositionUsesPivotPoint instead!
2415         /// </summary>
2416         /// <since_tizen> 3 </since_tizen>
2417         [Obsolete("Deprecated in API5; Will be removed in API8. Please use PositionUsesPivotPoint instead! " +
2418             "Like: " +
2419             "View view = new View(); " +
2420             "view.PivotPoint = PivotPoint.Center; " +
2421             "view.PositionUsesPivotPoint = true;" +
2422             " Deprecated in API5: Will be removed in API8")]
2423         [EditorBrowsable(EditorBrowsableState.Never)]
2424         public bool PositionUsesAnchorPoint
2425         {
2426             get
2427             {
2428                 bool temp = false;
2429                 GetProperty(View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
2430                 return temp;
2431             }
2432             set
2433             {
2434                 SetProperty(View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
2435                 NotifyPropertyChanged();
2436             }
2437         }
2438
2439         /// <summary>
2440         /// Queries whether the view is connected to the stage.<br />
2441         /// When a view is connected, it will be directly or indirectly parented to the root view.<br />
2442         /// </summary>
2443         /// <since_tizen> 3 </since_tizen>
2444         public bool IsOnWindow
2445         {
2446             get
2447             {
2448                 return OnWindow();
2449             }
2450         }
2451
2452         /// <summary>
2453         /// Gets the depth in the hierarchy for the view.
2454         /// </summary>
2455         /// <since_tizen> 3 </since_tizen>
2456         public int HierarchyDepth
2457         {
2458             get
2459             {
2460                 return GetHierarchyDepth();
2461             }
2462         }
2463
2464         /// <summary>
2465         /// Sets the sibling order of the view so the depth position can be defined within the same parent.
2466         /// </summary>
2467         /// <remarks>
2468         /// Note the initial value is 0. SiblingOrder should be bigger than 0 or equal to 0.
2469         /// Raise, Lower, RaiseToTop, LowerToBottom, RaiseAbove, and LowerBelow will override the sibling order.
2470         /// The values set by this property will likely change.
2471         /// </remarks>
2472         /// <since_tizen> 3 </since_tizen>
2473         public int SiblingOrder
2474         {
2475             get
2476             {
2477                 return (int)GetValue(SiblingOrderProperty);
2478             }
2479             set
2480             {
2481                 SetValue(SiblingOrderProperty, value);
2482                 NotifyPropertyChanged();
2483             }
2484         }
2485
2486         /// <summary>
2487         /// Returns the natural size of the view.
2488         /// </summary>
2489         /// <remarks>
2490         /// Deriving classes stipulate the natural size and by default a view has a zero natural size.
2491         /// </remarks>
2492         /// <since_tizen> 5 </since_tizen>
2493         public Vector3 NaturalSize
2494         {
2495             get
2496             {
2497                 Vector3 ret = new Vector3(Interop.Actor.Actor_GetNaturalSize(swigCPtr), true);
2498                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2499                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2500                 return ret;
2501             }
2502         }
2503
2504         /// <summary>
2505         /// Returns the natural size (Size2D) of the view.
2506         /// </summary>
2507         /// <remarks>
2508         /// Deriving classes stipulate the natural size and by default a view has a zero natural size.
2509         /// </remarks>
2510         /// <since_tizen> 4 </since_tizen>
2511         public Size2D NaturalSize2D
2512         {
2513             get
2514             {
2515                 Vector3 temp = new Vector3(Interop.Actor.Actor_GetNaturalSize(swigCPtr), true);
2516                 if (NDalicPINVOKE.SWIGPendingException.Pending)
2517                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
2518
2519                 return new Size2D((int)temp.Width, (int)temp.Height);
2520             }
2521         }
2522
2523         /// <summary>
2524         /// Gets or sets the origin of a view within its parent's area.<br />
2525         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the parent, and (1.0, 1.0, 0.5) is the bottom-right corner.<br />
2526         /// The default parent-origin is ParentOrigin.TopLeft (0.0, 0.0, 0.5).<br />
2527         /// A view's position is the distance between this origin and the view's anchor-point.<br />
2528         /// </summary>
2529         /// <pre>The view has been initialized.</pre>
2530         /// <since_tizen> 3 </since_tizen>
2531         public Position ParentOrigin
2532         {
2533             get
2534             {
2535                 Position tmp = (Position)GetValue(ParentOriginProperty);
2536                 return new Position(OnParentOriginChanged, tmp.X, tmp.Y, tmp.Z);
2537             }
2538             set
2539             {
2540                 SetValue(ParentOriginProperty, value);
2541                 NotifyPropertyChanged();
2542             }
2543         }
2544
2545         /// <summary>
2546         /// Gets or sets the anchor-point of a view.<br />
2547         /// This is expressed in unit coordinates, such that (0.0, 0.0, 0.5) is the top-left corner of the view, and (1.0, 1.0, 0.5) is the bottom-right corner.<br />
2548         /// The default pivot point is PivotPoint.Center (0.5, 0.5, 0.5).<br />
2549         /// A view position is the distance between its parent-origin and this anchor-point.<br />
2550         /// A view's orientation is the rotation from its default orientation, the rotation is centered around its anchor-point.<br />
2551         /// <pre>The view has been initialized.</pre>
2552         /// </summary>
2553         /// <since_tizen> 3 </since_tizen>
2554         public Position PivotPoint
2555         {
2556             get
2557             {
2558                 Position tmp = (Position)GetValue(PivotPointProperty);
2559                 return new Position(OnPivotPointChanged, tmp.X, tmp.Y, tmp.Z);
2560             }
2561             set
2562             {
2563                 SetValue(PivotPointProperty, value);
2564                 NotifyPropertyChanged();
2565             }
2566         }
2567
2568         /// <summary>
2569         /// Gets or sets the size width of the view.
2570         /// </summary>
2571         /// <since_tizen> 3 </since_tizen>
2572         public float SizeWidth
2573         {
2574             get
2575             {
2576                 return (float)GetValue(SizeWidthProperty);
2577             }
2578             set
2579             {
2580                 SetValue(SizeWidthProperty, value);
2581                 WidthSpecification = (int)Math.Ceiling(value);
2582                 NotifyPropertyChanged();
2583             }
2584         }
2585
2586         /// <summary>
2587         /// Gets or sets the size height of the view.
2588         /// </summary>
2589         /// <since_tizen> 3 </since_tizen>
2590         public float SizeHeight
2591         {
2592             get
2593             {
2594                 return (float)GetValue(SizeHeightProperty);
2595             }
2596             set
2597             {
2598                 SetValue(SizeHeightProperty, value);
2599                 HeightSpecification = (int)Math.Ceiling(value);
2600                 NotifyPropertyChanged();
2601             }
2602         }
2603
2604         /// <summary>
2605         /// Gets or sets the position of the view.<br />
2606         /// By default, sets the position vector between the parent origin and pivot point (default).<br />
2607         /// If the position inheritance is disabled, sets the world position.<br />
2608         /// </summary>
2609         /// <since_tizen> 3 </since_tizen>
2610         public Position Position
2611         {
2612             get
2613             {
2614                 Position tmp = (Position)GetValue(PositionProperty);
2615                 return new Position(OnPositionChanged, tmp.X, tmp.Y, tmp.Z);
2616             }
2617             set
2618             {
2619                 SetValue(PositionProperty, value);
2620                 NotifyPropertyChanged();
2621             }
2622         }
2623
2624         /// <summary>
2625         /// Gets or sets the position X of the view.
2626         /// </summary>
2627         /// <since_tizen> 3 </since_tizen>
2628         public float PositionX
2629         {
2630             get
2631             {
2632                 return (float)GetValue(PositionXProperty);
2633             }
2634             set
2635             {
2636                 SetValue(PositionXProperty, value);
2637                 NotifyPropertyChanged();
2638             }
2639         }
2640
2641         /// <summary>
2642         /// Gets or sets the position Y of the view.
2643         /// </summary>
2644         /// <since_tizen> 3 </since_tizen>
2645         public float PositionY
2646         {
2647             get
2648             {
2649                 return (float)GetValue(PositionYProperty);
2650             }
2651             set
2652             {
2653                 SetValue(PositionYProperty, value);
2654                 NotifyPropertyChanged();
2655             }
2656         }
2657
2658         /// <summary>
2659         /// Gets or sets the position Z of the view.
2660         /// </summary>
2661         /// <since_tizen> 3 </since_tizen>
2662         public float PositionZ
2663         {
2664             get
2665             {
2666                 return (float)GetValue(PositionZProperty);
2667             }
2668             set
2669             {
2670                 SetValue(PositionZProperty, value);
2671                 NotifyPropertyChanged();
2672             }
2673         }
2674
2675         /// <summary>
2676         /// Gets or sets the world position of the view.
2677         /// </summary>
2678         /// <since_tizen> 3 </since_tizen>
2679         public Vector3 WorldPosition
2680         {
2681             get
2682             {
2683                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2684                 GetProperty(View.Property.WORLD_POSITION).Get(temp);
2685                 return temp;
2686             }
2687         }
2688
2689         /// <summary>
2690         /// Gets or sets the orientation of the view.<br />
2691         /// The view's orientation is the rotation from its default orientation, and the rotation is centered around its anchor-point.<br />
2692         /// </summary>
2693         /// <remarks>This is an asynchronous method.</remarks>
2694         /// <since_tizen> 3 </since_tizen>
2695         public Rotation Orientation
2696         {
2697             get
2698             {
2699                 return (Rotation)GetValue(OrientationProperty);
2700             }
2701             set
2702             {
2703                 SetValue(OrientationProperty, value);
2704                 NotifyPropertyChanged();
2705             }
2706         }
2707
2708         /// <summary>
2709         /// Gets or sets the world orientation of the view.<br />
2710         /// </summary>
2711         /// <since_tizen> 3 </since_tizen>
2712         public Rotation WorldOrientation
2713         {
2714             get
2715             {
2716                 Rotation temp = new Rotation();
2717                 GetProperty(View.Property.WORLD_ORIENTATION).Get(temp);
2718                 return temp;
2719             }
2720         }
2721
2722         /// <summary>
2723         /// Gets or sets the scale factor applied to the view.<br />
2724         /// </summary>
2725         /// <since_tizen> 3 </since_tizen>
2726         public Vector3 Scale
2727         {
2728             get
2729             {
2730                 return (Vector3)GetValue(ScaleProperty);
2731             }
2732             set
2733             {
2734                 SetValue(ScaleProperty, value);
2735                 NotifyPropertyChanged();
2736             }
2737         }
2738
2739         /// <summary>
2740         /// Gets or sets the scale X factor applied to the view.
2741         /// </summary>
2742         /// <since_tizen> 3 </since_tizen>
2743         public float ScaleX
2744         {
2745             get
2746             {
2747                 return (float)GetValue(ScaleXProperty);
2748             }
2749             set
2750             {
2751                 SetValue(ScaleXProperty, value);
2752                 NotifyPropertyChanged();
2753             }
2754         }
2755
2756         /// <summary>
2757         /// Gets or sets the scale Y factor applied to the view.
2758         /// </summary>
2759         /// <since_tizen> 3 </since_tizen>
2760         public float ScaleY
2761         {
2762             get
2763             {
2764                 return (float)GetValue(ScaleYProperty);
2765             }
2766             set
2767             {
2768                 SetValue(ScaleYProperty, value);
2769                 NotifyPropertyChanged();
2770             }
2771         }
2772
2773         /// <summary>
2774         /// Gets or sets the scale Z factor applied to the view.
2775         /// </summary>
2776         /// <since_tizen> 3 </since_tizen>
2777         public float ScaleZ
2778         {
2779             get
2780             {
2781                 return (float)GetValue(ScaleZProperty);
2782             }
2783             set
2784             {
2785                 SetValue(ScaleZProperty, value);
2786                 NotifyPropertyChanged();
2787             }
2788         }
2789
2790         /// <summary>
2791         /// Gets the world scale of the view.
2792         /// </summary>
2793         /// <since_tizen> 3 </since_tizen>
2794         public Vector3 WorldScale
2795         {
2796             get
2797             {
2798                 Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
2799                 GetProperty(View.Property.WORLD_SCALE).Get(temp);
2800                 return temp;
2801             }
2802         }
2803
2804         /// <summary>
2805         /// Retrieves the visibility flag of the view.
2806         /// </summary>
2807         /// <remarks>
2808         /// If the view is not visible, then the view and its children will not be rendered.
2809         /// This is regardless of the individual visibility values of the children, i.e., the view will only be rendered if all of its parents have visibility set to true.
2810         /// </remarks>
2811         /// <since_tizen> 3 </since_tizen>
2812         public bool Visibility
2813         {
2814             get
2815             {
2816                 bool temp = false;
2817                 GetProperty(View.Property.VISIBLE).Get(out temp);
2818                 return temp;
2819             }
2820         }
2821
2822         /// <summary>
2823         /// Gets the view's world color.
2824         /// </summary>
2825         /// <since_tizen> 3 </since_tizen>
2826         public Vector4 WorldColor
2827         {
2828             get
2829             {
2830                 Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
2831                 GetProperty(View.Property.WORLD_COLOR).Get(temp);
2832                 return temp;
2833             }
2834         }
2835
2836         /// <summary>
2837         /// Gets or sets the view's name.
2838         /// </summary>
2839         /// <since_tizen> 3 </since_tizen>
2840         public string Name
2841         {
2842             get
2843             {
2844                 return (string)GetValue(NameProperty);
2845             }
2846             set
2847             {
2848                 SetValue(NameProperty, value);
2849                 NotifyPropertyChanged();
2850             }
2851         }
2852
2853         /// <summary>
2854         /// Get the number of children held by the view.
2855         /// </summary>
2856         /// <since_tizen> 3 </since_tizen>
2857         public new uint ChildCount
2858         {
2859             get
2860             {
2861                 return GetChildCount();
2862             }
2863         }
2864
2865         /// <summary>
2866         /// Gets the view's ID.
2867         /// Readonly
2868         /// </summary>
2869         /// <since_tizen> 3 </since_tizen>
2870         public uint ID
2871         {
2872             get
2873             {
2874                 return GetId();
2875             }
2876         }
2877
2878         /// <summary>
2879         /// Gets or sets the status of whether the view should emit touch or hover signals.
2880         /// </summary>
2881         /// <since_tizen> 3 </since_tizen>
2882         public bool Sensitive
2883         {
2884             get
2885             {
2886                 return (bool)GetValue(SensitiveProperty);
2887             }
2888             set
2889             {
2890                 SetValue(SensitiveProperty, value);
2891                 NotifyPropertyChanged();
2892             }
2893         }
2894
2895         /// <summary>
2896         /// Gets or sets the status of whether the view should receive a notification when touch or hover motion events leave the boundary of the view.
2897         /// </summary>
2898         /// <since_tizen> 3 </since_tizen>
2899         public bool LeaveRequired
2900         {
2901             get
2902             {
2903                 return (bool)GetValue(LeaveRequiredProperty);
2904             }
2905             set
2906             {
2907                 SetValue(LeaveRequiredProperty, value);
2908                 NotifyPropertyChanged();
2909             }
2910         }
2911
2912         /// <summary>
2913         /// Gets or sets the status of whether a child view inherits it's parent's orientation.
2914         /// </summary>
2915         /// <since_tizen> 3 </since_tizen>
2916         public bool InheritOrientation
2917         {
2918             get
2919             {
2920                 return (bool)GetValue(InheritOrientationProperty);
2921             }
2922             set
2923             {
2924                 SetValue(InheritOrientationProperty, value);
2925                 NotifyPropertyChanged();
2926             }
2927         }
2928
2929         /// <summary>
2930         /// Gets or sets the status of whether a child view inherits it's parent's scale.
2931         /// </summary>
2932         /// <since_tizen> 3 </since_tizen>
2933         public bool InheritScale
2934         {
2935             get
2936             {
2937                 return (bool)GetValue(InheritScaleProperty);
2938             }
2939             set
2940             {
2941                 SetValue(InheritScaleProperty, value);
2942                 NotifyPropertyChanged();
2943             }
2944         }
2945
2946         /// <summary>
2947         /// Gets or sets the status of how the view and its children should be drawn.<br />
2948         /// Not all views are renderable, but DrawMode can be inherited from any view.<br />
2949         /// If an object is in a 3D layer, it will be depth-tested against other objects in the world, i.e., it may be obscured if other objects are in front.<br />
2950         /// If DrawMode.Overlay2D is used, the view and its children will be drawn as a 2D overlay.<br />
2951         /// Overlay views are drawn in a separate pass, after all non-overlay views within the layer.<br />
2952         /// For overlay views, the drawing order is with respect to tree levels of views, and depth-testing will not be used.<br />
2953         /// </summary>
2954         /// <since_tizen> 3 </since_tizen>
2955         public DrawModeType DrawMode
2956         {
2957             get
2958             {
2959                 return (DrawModeType)GetValue(DrawModeProperty);
2960             }
2961             set
2962             {
2963                 SetValue(DrawModeProperty, value);
2964                 NotifyPropertyChanged();
2965             }
2966         }
2967
2968         /// <summary>
2969         /// Gets or sets the relative to parent size factor of the view.<br />
2970         /// This factor is only used when ResizePolicyType is set to either: ResizePolicyType.SizeRelativeToParent or ResizePolicyType.SizeFixedOffsetFromParent.<br />
2971         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicyType.<br />
2972         /// </summary>
2973         /// <since_tizen> 3 </since_tizen>
2974         public Vector3 SizeModeFactor
2975         {
2976             get
2977             {
2978                 return (Vector3)GetValue(SizeModeFactorProperty);
2979             }
2980             set
2981             {
2982                 SetValue(SizeModeFactorProperty, value);
2983                 NotifyPropertyChanged();
2984             }
2985         }
2986
2987         /// <summary>
2988         /// Gets or sets the width resize policy to be used.
2989         /// </summary>
2990         /// <since_tizen> 3 </since_tizen>
2991         public ResizePolicyType WidthResizePolicy
2992         {
2993             get
2994             {
2995                 return (ResizePolicyType)GetValue(WidthResizePolicyProperty);
2996             }
2997             set
2998             {
2999                 SetValue(WidthResizePolicyProperty, value);
3000                 // Match ResizePolicy to new Layouting.
3001                 // Parent relative policies can not be mapped at this point as parent size unknown.
3002                 switch (value)
3003                 {
3004                     case ResizePolicyType.UseNaturalSize:
3005                     {
3006                         WidthSpecification = LayoutParamPolicies.WrapContent;
3007                         break;
3008                     }
3009                     case ResizePolicyType.FillToParent:
3010                     {
3011                         WidthSpecification = LayoutParamPolicies.MatchParent;
3012                         break;
3013                     }
3014                     case ResizePolicyType.FitToChildren:
3015                     {
3016                         WidthSpecification = LayoutParamPolicies.WrapContent;
3017                         break;
3018                     }
3019                     default:
3020                         break;
3021                 }
3022                 NotifyPropertyChanged();
3023             }
3024         }
3025
3026         /// <summary>
3027         /// Gets or sets the height resize policy to be used.
3028         /// </summary>
3029         /// <since_tizen> 3 </since_tizen>
3030         public ResizePolicyType HeightResizePolicy
3031         {
3032             get
3033             {
3034                 return (ResizePolicyType)GetValue(HeightResizePolicyProperty);
3035             }
3036             set
3037             {
3038                 SetValue(HeightResizePolicyProperty, value);
3039                 // Match ResizePolicy to new Layouting.
3040                 // Parent relative policies can not be mapped at this point as parent size unknown.
3041                 switch (value)
3042                 {
3043                     case ResizePolicyType.UseNaturalSize:
3044                     {
3045                         HeightSpecification = LayoutParamPolicies.WrapContent;
3046                         break;
3047                     }
3048                     case ResizePolicyType.FillToParent:
3049                     {
3050                         HeightSpecification = LayoutParamPolicies.MatchParent;
3051                         break;
3052                     }
3053                     case ResizePolicyType.FitToChildren:
3054                     {
3055                         HeightSpecification = LayoutParamPolicies.WrapContent;
3056                         break;
3057                     }
3058                     default:
3059                         break;
3060                 }
3061                 NotifyPropertyChanged();
3062             }
3063         }
3064
3065         /// <summary>
3066         /// Gets or sets the policy to use when setting size with size negotiation.<br />
3067         /// Defaults to SizeScalePolicyType.UseSizeSet.<br />
3068         /// </summary>
3069         /// <since_tizen> 3 </since_tizen>
3070         public SizeScalePolicyType SizeScalePolicy
3071         {
3072             get
3073             {
3074                 return (SizeScalePolicyType)GetValue(SizeScalePolicyProperty);
3075             }
3076             set
3077             {
3078                 SetValue(SizeScalePolicyProperty, value);
3079                 NotifyPropertyChanged();
3080             }
3081         }
3082
3083         /// <summary>
3084         ///  Gets or sets the status of whether the width size is dependent on the height size.
3085         /// </summary>
3086         /// <since_tizen> 3 </since_tizen>
3087         public bool WidthForHeight
3088         {
3089             get
3090             {
3091                 return (bool)GetValue(WidthForHeightProperty);
3092             }
3093             set
3094             {
3095                 SetValue(WidthForHeightProperty, value);
3096                 NotifyPropertyChanged();
3097             }
3098         }
3099
3100         /// <summary>
3101         /// Gets or sets the status of whether the height size is dependent on the width size.
3102         /// </summary>
3103         /// <since_tizen> 3 </since_tizen>
3104         public bool HeightForWidth
3105         {
3106             get
3107             {
3108                 return (bool)GetValue(HeightForWidthProperty);
3109             }
3110             set
3111             {
3112                 SetValue(HeightForWidthProperty, value);
3113                 NotifyPropertyChanged();
3114             }
3115         }
3116
3117         /// <summary>
3118         /// Gets or sets the padding for use in layout.
3119         /// </summary>
3120         /// <since_tizen> 5 </since_tizen>
3121         public Extents Padding
3122         {
3123             get
3124             {
3125                 // If View has a Layout then padding in stored in the base Layout class
3126                 if (Layout !=null)
3127                 {
3128                     return Layout.Padding;
3129                 }
3130                 else
3131                 {
3132                     return (Extents)GetValue(PaddingProperty);
3133                 }
3134                 // Two return points to prevent creating a zeroed Extent native object before assignment
3135             }
3136             set
3137             {
3138                 Extents padding = value;
3139                 if (Layout !=null)
3140                 {
3141                     // Layout set so store Padding in LayoutItem instead of in View.
3142                     // If View stores the Padding value then Legacy Size Negotiation will overwrite
3143                     // the position and sizes measure in the Layouting.
3144                     Layout.Padding = value;
3145                     // If Layout is a LayoutItem then it could be a View that handles it's own padding.
3146                     // Let the View keeps it's padding.  Still store Padding in Layout to reduce code paths.
3147                     if( Layout.GetType() != typeof(LayoutItem)) // If a Layout container of some kind.
3148                     {
3149                         padding =  new Extents(0,0,0,0); // Reset value stored in View.
3150                     }
3151                     _layout?.RequestLayout();
3152                 }
3153                 SetValue(PaddingProperty, padding);
3154                 NotifyPropertyChanged();
3155                 _layout?.RequestLayout();
3156             }
3157         }
3158
3159         /// <summary>
3160         /// Gets or sets the minimum size the view can be assigned in size negotiation.
3161         /// </summary>
3162         /// <since_tizen> 3 </since_tizen>
3163         public Size2D MinimumSize
3164         {
3165             get
3166             {
3167                 Size2D tmp = (Size2D)GetValue(MinimumSizeProperty);
3168                 return new Size2D(OnMinimumSizeChanged, tmp.Width, tmp.Height);
3169             }
3170             set
3171             {
3172                 if (_layout != null)
3173                 {
3174                     // Note: it only works if minimum size is >= than natural size.
3175                     // To force the size it should be done through the width&height spec or Size2D.
3176                     _layout.MinimumWidth = new Tizen.NUI.LayoutLength(value.Width);
3177                     _layout.MinimumHeight = new Tizen.NUI.LayoutLength(value.Height);
3178                     _layout.RequestLayout();
3179                 }
3180                 SetValue(MinimumSizeProperty, value);
3181                 NotifyPropertyChanged();
3182             }
3183         }
3184
3185         /// <summary>
3186         /// Gets or sets the maximum size the view can be assigned in size negotiation.
3187         /// </summary>
3188         /// <since_tizen> 3 </since_tizen>
3189         public Size2D MaximumSize
3190         {
3191             get
3192             {
3193                 Size2D tmp = (Size2D)GetValue(MaximumSizeProperty);
3194                 return new Size2D(OnMaximumSizeChanged, tmp.Width, tmp.Height);
3195             }
3196             set
3197             {
3198                 // We don't have Layout.Maximum(Width|Height) so we cannot apply it to layout.
3199                 // MATCH_PARENT spec + parent container size can be used to limit
3200                 if (_layout != null)
3201                 {
3202                     // Note: it only works if minimum size is >= than natural size.
3203                     // To force the size it should be done through the width&height spec or Size2D.
3204                     _layout.MinimumHeight = new Tizen.NUI.LayoutLength(value.Width);
3205                     _layout.MinimumWidth = new Tizen.NUI.LayoutLength(value.Height);
3206                     _layout.RequestLayout();
3207                 }
3208                 SetValue(MaximumSizeProperty, value);
3209                 NotifyPropertyChanged();
3210             }
3211         }
3212
3213         /// <summary>
3214         /// Gets or sets whether a child view inherits it's parent's position.<br />
3215         /// Default is to inherit.<br />
3216         /// Switching this off means that using position sets the view's world position, i.e., translates from the world origin (0,0,0) to the pivot point of the view.<br />
3217         /// </summary>
3218         /// <since_tizen> 3 </since_tizen>
3219         public bool InheritPosition
3220         {
3221             get
3222             {
3223                 return (bool)GetValue(InheritPositionProperty);
3224             }
3225             set
3226             {
3227                 SetValue(InheritPositionProperty, value);
3228                 NotifyPropertyChanged();
3229             }
3230         }
3231
3232         /// <summary>
3233         /// Gets or sets the clipping behavior (mode) of it's children.
3234         /// </summary>
3235         /// <since_tizen> 3 </since_tizen>
3236         public ClippingModeType ClippingMode
3237         {
3238             get
3239             {
3240                 return (ClippingModeType)GetValue(ClippingModeProperty);
3241             }
3242             set
3243             {
3244                 SetValue(ClippingModeProperty, value);
3245                 NotifyPropertyChanged();
3246             }
3247         }
3248
3249         /// <summary>
3250         /// Gets the number of renderers held by the view.
3251         /// </summary>
3252         /// <since_tizen> 3 </since_tizen>
3253         public uint RendererCount
3254         {
3255             get
3256             {
3257                 return GetRendererCount();
3258             }
3259         }
3260
3261         /// <summary>
3262         /// Deprecated in API5; Will be removed in API8. Please use PivotPoint instead!
3263         /// </summary>
3264         /// <since_tizen> 3 </since_tizen>
3265         [Obsolete("Deprecated in API5; Will be removed in API8. Please use PivotPoint instead! " +
3266             "Like: " +
3267             "View view = new View(); " +
3268             "view.PivotPoint = PivotPoint.Center; " +
3269             "view.PositionUsesPivotPoint = true;")]
3270         [EditorBrowsable(EditorBrowsableState.Never)]
3271         public Position AnchorPoint
3272         {
3273             get
3274             {
3275                 Position temp = new Position(0.0f, 0.0f, 0.0f);
3276                 GetProperty(View.Property.ANCHOR_POINT).Get(temp);
3277                 return temp;
3278             }
3279             set
3280             {
3281                 SetProperty(View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue(value));
3282                 NotifyPropertyChanged();
3283             }
3284         }
3285
3286         /// <summary>
3287         /// Sets the size of a view for the width, the height and the depth.<br />
3288         /// Geometry can be scaled to fit within this area.<br />
3289         /// This does not interfere with the view's scale factor.<br />
3290         /// The views default depth is the minimum of width and height.<br />
3291         /// </summary>
3292         /// <remarks>
3293         /// Please note that multi-cascade setting is not possible for this NUI object. <br />
3294         /// It is recommended that NUI object typed properties are configured by their constructor with parameters. <br />
3295         /// For example, this code is working fine : view.Size = new Size( 1.0f, 1.0f, 0.0f); <br />
3296         /// but this will not work! : view.Size.Width = 2.0f; view.Size.Height = 2.0f; <br />
3297         /// It may not match the current value in some cases, i.e. when the animation is progressing or the maximum or minimu size is set. <br />
3298         /// </remarks>
3299         /// <since_tizen> 5 </since_tizen>
3300         public Size Size
3301         {
3302             get
3303             {
3304                 Size tmp = (Size)GetValue(SizeProperty);
3305                 return new Size(OnSizeChanged, tmp.Width, tmp.Height, tmp.Depth);
3306             }
3307             set
3308             {
3309                 SetValue(SizeProperty, value);
3310                 // Set Specification so when layouts measure this View it matches the value set here.
3311                 // All Views are currently Layouts.
3312                 WidthSpecification = (int)Math.Ceiling(value.Width);
3313                 HeightSpecification = (int)Math.Ceiling(value.Height);
3314                 NotifyPropertyChanged();
3315             }
3316         }
3317
3318         /// <summary>
3319         /// Deprecated in API5; Will be removed in API8. Please use 'Container GetParent() for derived class' instead!
3320         /// </summary>
3321         /// <since_tizen> 3 </since_tizen>
3322         [Obsolete("Deprecated in API5; Will be removed in API8. Please use 'Container GetParent() for derived class' instead! " +
3323             "Like: " +
3324             "Container parent =  view.GetParent(); " +
3325             "View view = parent as View;")]
3326         [EditorBrowsable(EditorBrowsableState.Never)]
3327         public new View Parent
3328         {
3329             get
3330             {
3331                 View ret;
3332                 IntPtr cPtr = Interop.Actor.Actor_GetParent(swigCPtr);
3333                 HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
3334                 BaseHandle basehandle = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle);
3335
3336                 if (basehandle is Layer layer)
3337                 {
3338                     ret = new View(Layer.getCPtr(layer).Handle, false);
3339                     NUILog.Error("This Parent property is deprecated, shoud do not be used");
3340                 }
3341                 else
3342                 {
3343                     ret = basehandle as View;
3344                 }
3345
3346                 Interop.BaseHandle.delete_BaseHandle(CPtr);
3347                 CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
3348
3349                 if (NDalicPINVOKE.SWIGPendingException.Pending)
3350                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3351                 return ret;
3352             }
3353         }
3354
3355         /// <summary>
3356         /// Gets/Sets whether inherit parent's the layout Direction.
3357         /// </summary>
3358         /// <since_tizen> 4 </since_tizen>
3359         public bool InheritLayoutDirection
3360         {
3361             get
3362             {
3363                 return (bool)GetValue(InheritLayoutDirectionProperty);
3364             }
3365             set
3366             {
3367                 SetValue(InheritLayoutDirectionProperty, value);
3368                 NotifyPropertyChanged();
3369             }
3370         }
3371
3372         /// <summary>
3373         /// Gets/Sets the layout Direction.
3374         /// </summary>
3375         /// <since_tizen> 4 </since_tizen>
3376         public ViewLayoutDirectionType LayoutDirection
3377         {
3378             get
3379             {
3380                 return (ViewLayoutDirectionType)GetValue(LayoutDirectionProperty);
3381             }
3382             set
3383             {
3384                 SetValue(LayoutDirectionProperty, value);
3385                 NotifyPropertyChanged();
3386                 _layout?.RequestLayout();
3387             }
3388         }
3389
3390         /// <summary>
3391         /// Gets or sets the Margin for use in layout.
3392         /// </summary>
3393         /// <remarks>
3394         /// Margin property is supported by Layout algorithms and containers.
3395         /// Please Set Layout if you want to use Margin property.
3396         /// </remarks>
3397         /// <since_tizen> 4 </since_tizen>
3398         public Extents Margin
3399         {
3400             get
3401             {
3402                 // If View has a Layout then margin is stored in Layout.
3403                 if (Layout != null)
3404                 {
3405                     return Layout.Margin;
3406                 }
3407                 else
3408                 {
3409                     // If Layout not set then return margin stored in View.
3410                     return (Extents)GetValue(MarginProperty);
3411                 }
3412                 // Two return points to prevent creating a zeroed Extent native object before assignment
3413             }
3414             set
3415             {
3416                 if (Layout != null)
3417                 {
3418                     // Layout set so store Margin in LayoutItem instead of View.
3419                     // If View stores the Margin too then the Legacy Size Negotiation will
3420                     // overwrite the position and size values measured in the Layouting.
3421                     Layout.Margin = value;
3422                     SetValue(MarginProperty, new Extents(0,0,0,0));
3423                     _layout?.RequestLayout();
3424                 }
3425                 else
3426                 {
3427                     SetValue(MarginProperty, value);
3428                 }
3429                 NotifyPropertyChanged();
3430                 _layout?.RequestLayout();
3431             }
3432         }
3433
3434         ///<summary>
3435         /// The required policy for this dimension, LayoutParamPolicies enum or exact value.
3436         ///</summary>
3437         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
3438         /// <remarks>
3439         /// Previously named LayoutWidthSpecification
3440         /// </remarks>
3441         [EditorBrowsable(EditorBrowsableState.Never)]
3442         public int WidthSpecification
3443         {
3444             get
3445             {
3446                 return _widthPolicy;
3447             }
3448             set
3449             {
3450                 _widthPolicy = value;
3451                 if (_widthPolicy >= 0)
3452                 {
3453                     _measureSpecificationWidth = new MeasureSpecification( new LayoutLength(value), MeasureSpecification.ModeType.Exactly );
3454                     //Tizen.NUI.Object.SetProperty(swigCPtr, View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue(value));
3455                     Size2D.Width = _widthPolicy;
3456                 }
3457                 _layout?.RequestLayout();
3458             }
3459         }
3460
3461         ///<summary>
3462         /// The required policy for this dimension, LayoutParamPolicies enum or exact value.
3463         ///</summary>
3464         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
3465         /// <remarks>
3466         /// Previously named LayoutHeightSpecification
3467         /// </remarks>
3468         [EditorBrowsable(EditorBrowsableState.Never)]
3469         public int HeightSpecification
3470         {
3471             get
3472             {
3473                 return _heightPolicy;
3474             }
3475             set
3476             {
3477                 _heightPolicy = value;
3478                 if (_heightPolicy >= 0)
3479                 {
3480                     _measureSpecificationHeight = new MeasureSpecification( new LayoutLength(value), MeasureSpecification.ModeType.Exactly );
3481                     //Tizen.NUI.Object.SetProperty(swigCPtr, View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue(value));
3482                     Size2D.Height = _heightPolicy;
3483                 }
3484                _layout?.RequestLayout();
3485             }
3486         }
3487
3488         ///<summary>
3489         /// Gets the List of transitions for this View.
3490         ///</summary>
3491         /// Hidden-API which is usually used as Inhouse-API. If required to be opened as Public-API, ACR process is needed.
3492         [EditorBrowsable(EditorBrowsableState.Never)]
3493         public Dictionary<TransitionCondition, TransitionList> LayoutTransitions
3494         {
3495             get
3496             {
3497                 if (_layoutTransitions == null)
3498                 {
3499                     _layoutTransitions = new Dictionary<TransitionCondition, TransitionList>();
3500                 }
3501                 return _layoutTransitions;
3502             }
3503         }
3504
3505         internal LayoutTransition LayoutTransition
3506         {
3507             set
3508             {
3509                 if (_layoutTransitions == null)
3510                 {
3511                     _layoutTransitions = new Dictionary<TransitionCondition, TransitionList>();
3512                 }
3513                 LayoutTransitionsHelper.AddTransitionForCondition(_layoutTransitions,value.Condition,value, true);
3514
3515                 AttachTransitionsToChildren(value);
3516             }
3517         }
3518
3519         /// <summary>
3520         /// Deprecated in API5; Will be removed in API8. Please use Padding instead.
3521         /// </summary>
3522         /// <since_tizen> 4 </since_tizen>
3523         [Obsolete("Deprecated in API5; Will be removed in API8. Please use Padding instead.")]
3524         [EditorBrowsable(EditorBrowsableState.Never)]
3525         public Extents PaddingEX
3526         {
3527             get
3528             {
3529                 Extents temp = new Extents(0, 0, 0, 0);
3530                 GetProperty(View.Property.PADDING).Get(temp);
3531                 return temp;
3532             }
3533             set
3534             {
3535                 SetProperty(View.Property.PADDING, new Tizen.NUI.PropertyValue(value));
3536                 NotifyPropertyChanged();
3537                 _layout?.RequestLayout();
3538             }
3539         }
3540
3541         /// <since_tizen> 6 </since_tizen>
3542         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
3543         [EditorBrowsable(EditorBrowsableState.Never)]
3544         public Style XamlStyle
3545         {
3546             get
3547             {
3548                 return (Style)GetValue(XamlStyleProperty);
3549             }
3550             set
3551             {
3552                 SetValue(XamlStyleProperty, value);
3553             }
3554         }
3555
3556         /// <summary>
3557         /// The Color of View. This is an RGBA value.
3558         /// </summary>
3559         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
3560         [EditorBrowsable(EditorBrowsableState.Never)]
3561         public Color Color
3562         {
3563             set
3564             {
3565                 SetColor(value);
3566             }
3567             get
3568             {
3569                 return GetCurrentColor();
3570             }
3571         }
3572
3573         /// <summary>
3574         /// The color mode of View.
3575         /// This specifies whether the View uses its own color, or inherits its parent color.
3576         /// The default is ColorMode.UseOwnMultiplyParentColor.
3577         /// </summary>
3578         internal ColorMode ColorMode
3579         {
3580             set
3581             {
3582                 SetColorMode(value);
3583             }
3584             get
3585             {
3586                 return GetColorMode();
3587             }
3588         }
3589
3590         internal float Weight
3591         {
3592             get
3593             {
3594                 return _weight;
3595             }
3596             set
3597             {
3598                 _weight = value;
3599                 _layout?.RequestLayout();
3600             }
3601         }
3602
3603         /// <summary>
3604         ///  Whether to load the BackgroundImage synchronously.
3605         ///  If not specified, the default is false, i.e. the BackgroundImage is loaded asynchronously.
3606         ///  Note: For Normal Quad images only.
3607         /// </summary>
3608         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
3609         [EditorBrowsable(EditorBrowsableState.Never)]
3610         public bool BackgroundImageSynchronosLoading
3611         {
3612             get
3613             {
3614                 return _backgroundImageSynchronosLoading;
3615             }
3616             set
3617             {
3618                 if (value != _backgroundImageSynchronosLoading)
3619                 {
3620                     string bgUrl = "";
3621                     PropertyMap bgMap = this.Background;
3622                     int visualType = 0;
3623                     bgMap.Find(Visual.Property.Type)?.Get(out visualType);
3624                     if (visualType == (int)Visual.Type.Image)
3625                     {
3626                         bgMap.Find(ImageVisualProperty.URL)?.Get(out bgUrl);
3627                     }
3628                     if (bgUrl.Length != 0)
3629                     {
3630                         _backgroundImageSynchronosLoading = value;
3631                         bgMap.Add("synchronousLoading", new PropertyValue(_backgroundImageSynchronosLoading));
3632                         this.Background = bgMap;
3633                     }
3634                 }
3635             }
3636         }
3637
3638         internal float WorldPositionX
3639         {
3640             get
3641             {
3642                 float temp = 0.0f;
3643                 GetProperty(View.Property.WORLD_POSITION_X).Get(out temp);
3644                 return temp;
3645             }
3646         }
3647
3648         internal float WorldPositionY
3649         {
3650             get
3651             {
3652                 float temp = 0.0f;
3653                 GetProperty(View.Property.WORLD_POSITION_Y).Get(out temp);
3654                 return temp;
3655             }
3656         }
3657
3658         internal float WorldPositionZ
3659         {
3660             get
3661             {
3662                 float temp = 0.0f;
3663                 GetProperty(View.Property.WORLD_POSITION_Z).Get(out temp);
3664                 return temp;
3665             }
3666         }
3667
3668         internal bool FocusState
3669         {
3670             get
3671             {
3672                 return IsKeyboardFocusable();
3673             }
3674             set
3675             {
3676                 SetKeyboardFocusable(value);
3677             }
3678         }
3679
3680         /// <summary>
3681         /// Set the layout on this View. Replaces any existing Layout.
3682         /// </summary>
3683         internal LayoutItem Layout
3684         {
3685             get
3686             {
3687                 return _layout;
3688             }
3689             set
3690             {
3691                 // Do nothing if layout provided is already set on this View.
3692                 if (value == _layout)
3693                 {
3694                     return;
3695                 }
3696
3697                 Log.Info("NUI", "Setting Layout on:" + Name + "\n");
3698                 layoutingDisabled = false;
3699                 layoutSet = true;
3700
3701                 // If new layout being set already has a owner then that owner receives a replacement default layout.
3702                 // First check if the layout to be set already has a owner.
3703                 if (value?.Owner != null)
3704                 {
3705                     Log.Info("NUI", "Set layout already in use by another View: " + value.Owner.Name + "will get a LayoutGroup\n");
3706                     // Previous owner of the layout gets a default layout as a replacement.
3707                     value.Owner.Layout = new LayoutGroup();
3708
3709                     // Copy Margin and Padding to replacement LayoutGroup.
3710                     value.Owner.Layout.Margin = value.Margin;
3711                     value.Owner.Layout.Padding = value.Padding;
3712                 }
3713
3714                 // Copy Margin and Padding to new layout being set or restore padding and margin back to
3715                 // View if no replacement. Previously margin and padding values would have been moved from
3716                 // the View to the layout.
3717                 if (_layout != null ) // Existing layout
3718                 {
3719                     if (value != null)
3720                     {
3721                         // Existing layout being replaced so copy over margin and padding values.
3722                         value.Margin = _layout.Margin;
3723                         value.Padding = _layout.Padding;
3724                     }
3725                     else
3726                     {
3727                       // Layout not being replaced so restore margin and padding to View.
3728                       SetValue(MarginProperty, _layout.Margin);
3729                       SetValue(PaddingProperty, _layout.Padding);
3730                       NotifyPropertyChanged();
3731                     }
3732                 }
3733                 else
3734                 {
3735                     // First Layout to be added to the View hence copy
3736
3737                     // Do not try to set Margins or Padding on a null Layout (when a layout is being removed from a View)
3738                     if (value !=null)
3739                     {
3740                         if (Margin.Top != 0 || Margin.Bottom !=0 || Margin.Start !=0 || Margin.End != 0)
3741                         {
3742                             // If View already has a margin set then store it in Layout instead.
3743                             value.Margin = Margin;
3744                             SetValue(MarginProperty, new Extents(0,0,0,0));
3745                             NotifyPropertyChanged();
3746                         }
3747
3748                         if (Padding.Top != 0 || Padding.Bottom !=0 || Padding.Start !=0 || Padding.End != 0)
3749                         {
3750                             // If View already has a padding set then store it in Layout instead.
3751                             value.Padding = Padding;
3752                             SetValue(PaddingProperty, new Extents(0,0,0,0));
3753                             NotifyPropertyChanged();
3754                         }
3755                     }
3756                 }
3757
3758                 // Remove existing layout from it's parent layout group.
3759                 _layout?.Unparent();
3760
3761                 // Set layout to this view
3762                 SetLayout(value);
3763             }
3764         }
3765
3766         internal void SetLayout(LayoutItem layout)
3767         {
3768             _layout = layout;
3769             _layout?.AttachToOwner(this);
3770             _layout?.RequestLayout();
3771         }
3772
3773         /// <summary>
3774         /// Stores the calculated width value and its ModeType. Width component.
3775         /// </summary>
3776         internal MeasureSpecification MeasureSpecificationWidth
3777         {
3778             set
3779             {
3780                 _measureSpecificationWidth = value;
3781                 _layout?.RequestLayout();
3782             }
3783             get
3784             {
3785                 return _measureSpecificationWidth;
3786             }
3787         }
3788
3789         /// <summary>
3790         /// Stores the calculated width value and its ModeType. Height component.
3791         /// </summary>
3792         internal MeasureSpecification MeasureSpecificationHeight
3793         {
3794             set
3795             {
3796                 _measureSpecificationHeight = value;
3797                 _layout?.RequestLayout();
3798             }
3799             get
3800             {
3801                 return _measureSpecificationHeight;
3802             }
3803         }
3804
3805         internal void AttachTransitionsToChildren(LayoutTransition transition)
3806         {
3807             // Iterate children, adding the transition unless a transition
3808             // for the same condition and property has already been
3809             // explicitly added.
3810             foreach (View view in Children)
3811             {
3812                 LayoutTransitionsHelper.AddTransitionForCondition(view.LayoutTransitions,transition.Condition, transition, false);
3813             }
3814         }
3815
3816         internal float ParentOriginX
3817         {
3818             get
3819             {
3820                 float temp = 0.0f;
3821                 GetProperty(View.Property.PARENT_ORIGIN_X).Get(out temp);
3822                 return temp;
3823             }
3824             set
3825             {
3826                 SetProperty(View.Property.PARENT_ORIGIN_X, new Tizen.NUI.PropertyValue(value));
3827                 NotifyPropertyChanged();
3828             }
3829         }
3830
3831         internal float ParentOriginY
3832         {
3833             get
3834             {
3835                 float temp = 0.0f;
3836                 GetProperty(View.Property.PARENT_ORIGIN_Y).Get(out temp);
3837                 return temp;
3838             }
3839             set
3840             {
3841                 SetProperty(View.Property.PARENT_ORIGIN_Y, new Tizen.NUI.PropertyValue(value));
3842                 NotifyPropertyChanged();
3843             }
3844         }
3845
3846         internal float ParentOriginZ
3847         {
3848             get
3849             {
3850                 float temp = 0.0f;
3851                 GetProperty(View.Property.PARENT_ORIGIN_Z).Get(out temp);
3852                 return temp;
3853             }
3854             set
3855             {
3856                 SetProperty(View.Property.PARENT_ORIGIN_Z, new Tizen.NUI.PropertyValue(value));
3857                 NotifyPropertyChanged();
3858             }
3859         }
3860
3861         internal float PivotPointX
3862         {
3863             get
3864             {
3865                 float temp = 0.0f;
3866                 GetProperty(View.Property.ANCHOR_POINT_X).Get(out temp);
3867                 return temp;
3868             }
3869             set
3870             {
3871                 SetProperty(View.Property.ANCHOR_POINT_X, new Tizen.NUI.PropertyValue(value));
3872             }
3873         }
3874
3875         internal float PivotPointY
3876         {
3877             get
3878             {
3879                 float temp = 0.0f;
3880                 GetProperty(View.Property.ANCHOR_POINT_Y).Get(out temp);
3881                 return temp;
3882             }
3883             set
3884             {
3885                 SetProperty(View.Property.ANCHOR_POINT_Y, new Tizen.NUI.PropertyValue(value));
3886             }
3887         }
3888
3889         internal float PivotPointZ
3890         {
3891             get
3892             {
3893                 float temp = 0.0f;
3894                 GetProperty(View.Property.ANCHOR_POINT_Z).Get(out temp);
3895                 return temp;
3896             }
3897             set
3898             {
3899                 SetProperty(View.Property.ANCHOR_POINT_Z, new Tizen.NUI.PropertyValue(value));
3900             }
3901         }
3902
3903         internal Matrix WorldMatrix
3904         {
3905             get
3906             {
3907                 Matrix temp = new Matrix();
3908                 GetProperty(View.Property.WORLD_MATRIX).Get(temp);
3909                 return temp;
3910             }
3911         }
3912
3913         private int LeftFocusableViewId
3914         {
3915             get
3916             {
3917                 int temp = 0;
3918                 GetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID).Get(out temp);
3919                 return temp;
3920             }
3921             set
3922             {
3923                 SetProperty(View.Property.LEFT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
3924             }
3925         }
3926
3927         private int RightFocusableViewId
3928         {
3929             get
3930             {
3931                 int temp = 0;
3932                 GetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID).Get(out temp);
3933                 return temp;
3934             }
3935             set
3936             {
3937                 SetProperty(View.Property.RIGHT_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
3938             }
3939         }
3940
3941         private int UpFocusableViewId
3942         {
3943             get
3944             {
3945                 int temp = 0;
3946                 GetProperty(View.Property.UP_FOCUSABLE_VIEW_ID).Get(out temp);
3947                 return temp;
3948             }
3949             set
3950             {
3951                 SetProperty(View.Property.UP_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
3952             }
3953         }
3954
3955         private int DownFocusableViewId
3956         {
3957             get
3958             {
3959                 int temp = 0;
3960                 GetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID).Get(out temp);
3961                 return temp;
3962             }
3963             set
3964             {
3965                 SetProperty(View.Property.DOWN_FOCUSABLE_VIEW_ID, new Tizen.NUI.PropertyValue(value));
3966             }
3967         }
3968
3969         /// <summary>
3970         /// Perform an action on a visual registered to this view. <br />
3971         /// Visuals will have actions. This API is used to perform one of these actions with the given attributes.
3972         /// </summary>
3973         /// <param name="propertyIndexOfVisual">The Property index of the visual.</param>
3974         /// <param name="propertyIndexOfActionId">The action to perform. See Visual to find the supported actions.</param>
3975         /// <param name="attributes">Optional attributes for the action.</param>
3976         /// <since_tizen> 5 </since_tizen>
3977         public void DoAction(int propertyIndexOfVisual, int propertyIndexOfActionId, PropertyValue attributes)
3978         {
3979             Interop.View.View_DoAction(swigCPtr, propertyIndexOfVisual, propertyIndexOfActionId, PropertyValue.getCPtr(attributes));
3980             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
3981         }
3982
3983         /// <summary>
3984         /// Creates an animation to animate the background color visual. If there is no
3985         /// background visual, creates one with transparent black as it's mixColor.
3986         /// </summary>
3987         /// <since_tizen> 3 </since_tizen>
3988         public Animation AnimateBackgroundColor(object destinationValue,
3989                                                  int startTime,
3990                                                  int endTime,
3991                                                  AlphaFunction.BuiltinFunctions? alphaFunction = null,
3992                                                  object initialValue = null)
3993         {
3994             Tizen.NUI.PropertyMap background = Background;
3995
3996             if (background.Empty())
3997             {
3998                 // If there is no background yet, ensure there is a transparent
3999                 // color visual
4000                 BackgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
4001                 background = Background;
4002             }
4003             return AnimateColor("background", destinationValue, startTime, endTime, alphaFunction, initialValue);
4004         }
4005
4006         /// <summary>
4007         /// Creates an animation to animate the mixColor of the named visual.
4008         /// </summary>
4009         /// <since_tizen> 3 </since_tizen>
4010         public Animation AnimateColor(string targetVisual, object destinationColor, int startTime, int endTime, AlphaFunction.BuiltinFunctions? alphaFunction = null, object initialColor = null)
4011         {
4012             Animation animation = null;
4013             {
4014                 PropertyMap _animator = new PropertyMap();
4015                 if (alphaFunction != null)
4016                 {
4017                     _animator.Add("alphaFunction", new PropertyValue(AlphaFunction.BuiltinToPropertyKey(alphaFunction)));
4018                 }
4019
4020                 PropertyMap _timePeriod = new PropertyMap();
4021                 _timePeriod.Add("duration", new PropertyValue((endTime - startTime) / 1000.0f));
4022                 _timePeriod.Add("delay", new PropertyValue(startTime / 1000.0f));
4023                 _animator.Add("timePeriod", new PropertyValue(_timePeriod));
4024
4025                 PropertyMap _transition = new PropertyMap();
4026                 _transition.Add("animator", new PropertyValue(_animator));
4027                 _transition.Add("target", new PropertyValue(targetVisual));
4028                 _transition.Add("property", new PropertyValue("mixColor"));
4029
4030                 if (initialColor != null)
4031                 {
4032                     PropertyValue initValue = PropertyValue.CreateFromObject(initialColor);
4033                     _transition.Add("initialValue", initValue);
4034                 }
4035
4036                 PropertyValue destValue = PropertyValue.CreateFromObject(destinationColor);
4037                 _transition.Add("targetValue", destValue);
4038                 TransitionData _transitionData = new TransitionData(_transition);
4039
4040                 animation = new Animation(Interop.View.View_CreateTransition(swigCPtr, TransitionData.getCPtr(_transitionData)), true);
4041                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4042                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4043             }
4044             return animation;
4045         }
4046
4047         // From Container Base class
4048         /// <summary>
4049         /// Adds a child view to this view.
4050         /// </summary>
4051         /// <seealso cref="Container.Add" />
4052         /// <since_tizen> 4 </since_tizen>
4053         public override void Add(View child)
4054         {
4055             bool hasLayout = (_layout != null);
4056             Log.Info("NUI", "Add:" + child.Name + " to View:" + Name + " which has layout[" + hasLayout + "] + \n");
4057
4058             if (null == child)
4059             {
4060                 Tizen.Log.Fatal("NUI", "Child is null");
4061                 return;
4062             }
4063
4064             Container oldParent = child.GetParent();
4065             if (oldParent != this)
4066             {
4067                 // If child already has a parent then re-parent child
4068                 if (oldParent != null)
4069                 {
4070                     oldParent.Remove(child);
4071                 }
4072                 child.InternalParent = this;
4073
4074                 Interop.Actor.Actor_Add(swigCPtr, View.getCPtr(child));
4075
4076                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4077                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4078                 Children.Add(child);
4079
4080                 if (ChildAdded != null)
4081                 {
4082                     ChildAddedEventArgs e = new ChildAddedEventArgs
4083                     {
4084                         Added = child
4085                     };
4086                     ChildAdded(this, e);
4087                 }
4088                 BindableObject.SetInheritedBindingContext(child, this?.BindingContext);
4089             }
4090         }
4091
4092         /// <summary>
4093         /// Removes a child view from this View. If the view was not a child of this view, this is a no-op.
4094         /// </summary>
4095         /// <seealso cref="Container.Remove" />
4096         /// <since_tizen> 4 </since_tizen>
4097         public override void Remove(View child)
4098         {
4099             if (!child || child.GetParent()==null) // Early out if child null.
4100                 return;
4101
4102             bool hasLayout = (_layout != null);
4103             Log.Info("NUI","Removing View:" + child.Name + " layout[" + hasLayout.ToString() +"]\n");
4104
4105             // If View has a layout then do a deferred child removal
4106             // Actual child removal is performed by the layouting system so
4107             // transitions can be completed.
4108             if (hasLayout)
4109             {
4110                 (_layout as LayoutGroup)?.RemoveChildFromLayoutGroup( child );
4111             }
4112             else
4113             {
4114                 RemoveChild(child);
4115             }
4116         }
4117
4118         /// <summary>
4119         /// Retrieves a child view by index.
4120         /// </summary>
4121         /// <seealso cref="Container.GetChildAt" />
4122         /// <since_tizen> 4 </since_tizen>
4123         public override View GetChildAt(uint index)
4124         {
4125             if (index < Children.Count)
4126             {
4127                 return Children[Convert.ToInt32(index)];
4128             }
4129             else
4130             {
4131                 return null;
4132             }
4133         }
4134
4135         /// <summary>
4136         /// Retrieves the number of children held by the view.
4137         /// </summary>
4138         /// <seealso cref="Container.GetChildCount" />
4139         /// <since_tizen> 4 </since_tizen>
4140         public override uint GetChildCount()
4141         {
4142             return Convert.ToUInt32(Children.Count);
4143         }
4144
4145         /// <summary>
4146         /// Gets the views parent.
4147         /// </summary>
4148         /// <seealso cref="Container.GetParent()" />
4149         /// <since_tizen> 4 </since_tizen>
4150         public override Container GetParent()
4151         {
4152             return this.InternalParent as Container;
4153         }
4154
4155         /// <summary>
4156         /// Queries whether the view has a focus.
4157         /// </summary>
4158         /// <returns>True if this view has a focus.</returns>
4159         /// <since_tizen> 3 </since_tizen>
4160         public bool HasFocus()
4161         {
4162             bool ret = false;
4163             if (swigCPtr.Handle != global::System.IntPtr.Zero)
4164             {
4165                 ret = Interop.View.View_HasKeyInputFocus(swigCPtr);
4166                                 if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4167             }
4168             else
4169             {
4170                 Tizen.Log.Error("NUI", "swigCPtr of view is aleady disposed.");
4171             }
4172             return ret;
4173         }
4174
4175         /// <summary>
4176         /// Sets the name of the style to be applied to the view.
4177         /// </summary>
4178         /// <param name="styleName">A string matching a style described in a stylesheet.</param>
4179         /// <since_tizen> 3 </since_tizen>
4180         public void SetStyleName(string styleName)
4181         {
4182             Interop.View.View_SetStyleName(swigCPtr, styleName);
4183             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4184         }
4185
4186         /// <summary>
4187         /// Retrieves the name of the style to be applied to the view (if any).
4188         /// </summary>
4189         /// <returns>A string matching a style, or an empty string.</returns>
4190         /// <since_tizen> 3 </since_tizen>
4191         public string GetStyleName()
4192         {
4193             string ret = Interop.View.View_GetStyleName(swigCPtr);
4194             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4195             return ret;
4196         }
4197
4198         /// <summary>
4199         /// Clears the background.
4200         /// </summary>
4201         /// <since_tizen> 3 </since_tizen>
4202         public void ClearBackground()
4203         {
4204             Interop.View.View_ClearBackground(swigCPtr);
4205             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4206         }
4207
4208         /// <summary>
4209         /// Shows the view.
4210         /// </summary>
4211         /// <remarks>
4212         /// This is an asynchronous method.
4213         /// </remarks>
4214         /// <since_tizen> 3 </since_tizen>
4215         public void Show()
4216         {
4217             SetVisible(true);
4218         }
4219
4220         /// <summary>
4221         /// Hides the view.
4222         /// </summary>
4223         /// <remarks>
4224         /// This is an asynchronous method.
4225         /// If the view is hidden, then the view and its children will not be rendered.
4226         /// 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.
4227         /// </remarks>
4228         /// <since_tizen> 3 </since_tizen>
4229         public void Hide()
4230         {
4231             SetVisible(false);
4232         }
4233
4234         /// <summary>
4235         /// Raises the view above all other views.
4236         /// </summary>
4237         /// <remarks>
4238         /// Sibling order of views within the parent will be updated automatically.
4239         /// Once a raise or lower API is used, that view will then have an exclusive sibling order independent of insertion.
4240         /// </remarks>
4241         /// <since_tizen> 3 </since_tizen>
4242         public void RaiseToTop()
4243         {
4244             var parentChildren = GetParent()?.Children;
4245
4246             if (parentChildren != null)
4247             {
4248                 parentChildren.Remove(this);
4249                 parentChildren.Add(this);
4250
4251                 Interop.NDalic.RaiseToTop(swigCPtr);
4252                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4253                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4254             }
4255
4256         }
4257
4258         /// <summary>
4259         /// Lowers the view to the bottom of all views.
4260         /// </summary>
4261         /// <remarks>
4262         /// The sibling order of views within the parent will be updated automatically.
4263         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
4264         /// </remarks>
4265         /// <since_tizen> 3 </since_tizen>
4266         public void LowerToBottom()
4267         {
4268             var parentChildren = GetParent()?.Children;
4269
4270             if (parentChildren != null)
4271             {
4272                 parentChildren.Remove(this);
4273                 parentChildren.Insert(0, this);
4274
4275                 Interop.NDalic.LowerToBottom(swigCPtr);
4276                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4277                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4278             }
4279         }
4280
4281         /// <summary>
4282         /// Queries if all resources required by a view are loaded and ready.
4283         /// </summary>
4284         /// <remarks>Most resources are only loaded when the control is placed on the stage.
4285         /// </remarks>
4286         /// <since_tizen> 3 </since_tizen>
4287         public bool IsResourceReady()
4288         {
4289             bool ret = Interop.View.IsResourceReady(swigCPtr);
4290             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4291             return ret;
4292         }
4293
4294         /// <summary>
4295         /// Gets the parent layer of this view.If a view has no parent, this method does not do anything.
4296         /// </summary>
4297         /// <pre>The view has been initialized. </pre>
4298         /// <returns>The parent layer of view </returns>
4299         /// <since_tizen> 5 </since_tizen>
4300         public Layer GetLayer()
4301         {
4302             //to fix memory leak issue, match the handle count with native side.
4303             IntPtr cPtr = Interop.Actor.Actor_GetLayer(swigCPtr);
4304             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
4305             Layer ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as Layer;
4306             Interop.BaseHandle.delete_BaseHandle(CPtr);
4307             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
4308
4309             if (NDalicPINVOKE.SWIGPendingException.Pending)
4310                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4311             return ret;
4312         }
4313
4314         /// <summary>
4315         /// Removes a view from its parent view or layer. If a view has no parent, this method does nothing.
4316         /// </summary>
4317         /// <pre>The (child) view has been initialized. </pre>
4318         /// <since_tizen> 4 </since_tizen>
4319         public void Unparent()
4320         {
4321             GetParent()?.Remove(this);
4322         }
4323
4324         /// <summary>
4325         /// Search through this view's hierarchy for a view with the given name.
4326         /// The view itself is also considered in the search.
4327         /// </summary>
4328         /// <pre>The view has been initialized.</pre>
4329         /// <param name="viewName">The name of the view to find.</param>
4330         /// <returns>A handle to the view if found, or an empty handle if not.</returns>
4331         /// <since_tizen> 3 </since_tizen>
4332         public View FindChildByName(string viewName)
4333         {
4334             //to fix memory leak issue, match the handle count with native side.
4335             IntPtr cPtr = Interop.Actor.Actor_FindChildByName(swigCPtr, viewName);
4336             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
4337             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
4338             Interop.BaseHandle.delete_BaseHandle(CPtr);
4339             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
4340
4341             if (NDalicPINVOKE.SWIGPendingException.Pending)
4342                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4343             return ret;
4344         }
4345
4346         /// <summary>
4347         /// Converts screen coordinates into the view's coordinate system using the default camera.
4348         /// </summary>
4349         /// <pre>The view has been initialized.</pre>
4350         /// <remarks>The view coordinates are relative to the top-left(0.0, 0.0, 0.5).</remarks>
4351         /// <param name="localX">On return, the X-coordinate relative to the view.</param>
4352         /// <param name="localY">On return, the Y-coordinate relative to the view.</param>
4353         /// <param name="screenX">The screen X-coordinate.</param>
4354         /// <param name="screenY">The screen Y-coordinate.</param>
4355         /// <returns>True if the conversion succeeded.</returns>
4356         /// <since_tizen> 3 </since_tizen>
4357         public bool ScreenToLocal(out float localX, out float localY, float screenX, float screenY)
4358         {
4359             bool ret = Interop.Actor.Actor_ScreenToLocal(swigCPtr, out localX, out localY, screenX, screenY);
4360             if (NDalicPINVOKE.SWIGPendingException.Pending)
4361                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4362             return ret;
4363         }
4364
4365         /// <summary>
4366         /// Sets the relative to parent size factor of the view.<br />
4367         /// This factor is only used when ResizePolicy is set to either:
4368         /// ResizePolicy::SIZE_RELATIVE_TO_PARENT or ResizePolicy::SIZE_FIXED_OFFSET_FROM_PARENT.<br />
4369         /// This view's size is set to the view's size multiplied by or added to this factor, depending on ResizePolicy.<br />
4370         /// </summary>
4371         /// <pre>The view has been initialized.</pre>
4372         /// <param name="factor">A Vector3 representing the relative factor to be applied to each axis.</param>
4373         /// <since_tizen> 3 </since_tizen>
4374         public void SetSizeModeFactor(Vector3 factor)
4375         {
4376             Interop.Actor.Actor_SetSizeModeFactor(swigCPtr, Vector3.getCPtr(factor));
4377             if (NDalicPINVOKE.SWIGPendingException.Pending)
4378                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4379         }
4380         /// <summary>
4381         /// Calculates the height of the view given a width.<br />
4382         /// The natural size is used for default calculation.<br />
4383         /// Size 0 is treated as aspect ratio 1:1.<br />
4384         /// </summary>
4385         /// <param name="width">The width to use.</param>
4386         /// <returns>The height based on the width.</returns>
4387         /// <since_tizen> 3 </since_tizen>
4388         public float GetHeightForWidth(float width)
4389         {
4390             float ret = Interop.Actor.Actor_GetHeightForWidth(swigCPtr, width);
4391             if (NDalicPINVOKE.SWIGPendingException.Pending)
4392                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4393             return ret;
4394         }
4395
4396         /// <summary>
4397         /// Calculates the width of the view given a height.<br />
4398         /// The natural size is used for default calculation.<br />
4399         /// Size 0 is treated as aspect ratio 1:1.<br />
4400         /// </summary>
4401         /// <param name="height">The height to use.</param>
4402         /// <returns>The width based on the height.</returns>
4403         /// <since_tizen> 3 </since_tizen>
4404         public float GetWidthForHeight(float height)
4405         {
4406             float ret = Interop.Actor.Actor_GetWidthForHeight(swigCPtr, height);
4407             if (NDalicPINVOKE.SWIGPendingException.Pending)
4408                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4409             return ret;
4410         }
4411
4412         /// <summary>
4413         /// Return the amount of size allocated for relayout.
4414         /// </summary>
4415         /// <param name="dimension">The dimension to retrieve.</param>
4416         /// <returns>Return the size.</returns>
4417         /// <since_tizen> 3 </since_tizen>
4418         public float GetRelayoutSize(DimensionType dimension)
4419         {
4420             float ret = Interop.Actor.Actor_GetRelayoutSize(swigCPtr, (int)dimension);
4421             if (NDalicPINVOKE.SWIGPendingException.Pending)
4422                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4423             return ret;
4424         }
4425
4426         /// <summary>
4427         /// Set the padding for the view.
4428         /// </summary>
4429         /// <param name="padding">Padding for the view.</param>
4430         /// <since_tizen> 3 </since_tizen>
4431         public void SetPadding(PaddingType padding)
4432         {
4433             Interop.Actor.Actor_SetPadding(swigCPtr, PaddingType.getCPtr(padding));
4434             if (NDalicPINVOKE.SWIGPendingException.Pending)
4435                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4436         }
4437
4438         /// <summary>
4439         /// Return the value of padding for the view.
4440         /// </summary>
4441         /// <param name="paddingOut">the value of padding for the view</param>
4442         /// <since_tizen> 3 </since_tizen>
4443         public void GetPadding(PaddingType paddingOut)
4444         {
4445             Interop.Actor.Actor_GetPadding(swigCPtr, PaddingType.getCPtr(paddingOut));
4446             if (NDalicPINVOKE.SWIGPendingException.Pending)
4447                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4448         }
4449
4450         /// <since_tizen> 3 </since_tizen>
4451         public uint AddRenderer(Renderer renderer)
4452         {
4453             uint ret = Interop.Actor.Actor_AddRenderer(swigCPtr, Renderer.getCPtr(renderer));
4454             if (NDalicPINVOKE.SWIGPendingException.Pending)
4455                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4456             return ret;
4457         }
4458
4459         /// <since_tizen> 3 </since_tizen>
4460         public Renderer GetRendererAt(uint index)
4461         {
4462             //to fix memory leak issue, match the handle count with native side.
4463             IntPtr cPtr = Interop.Actor.Actor_GetRendererAt(swigCPtr, index);
4464             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
4465             Renderer ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as Renderer;
4466             if (cPtr != null && ret == null)
4467             {
4468                 ret = new Renderer(cPtr, false);
4469                 if (NDalicPINVOKE.SWIGPendingException.Pending)
4470                     throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4471                 return ret;
4472             }
4473             Interop.BaseHandle.delete_BaseHandle(CPtr);
4474             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
4475
4476             if (NDalicPINVOKE.SWIGPendingException.Pending)
4477                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4478             return ret;
4479         }
4480
4481         /// <since_tizen> 3 </since_tizen>
4482         public void RemoveRenderer(Renderer renderer)
4483         {
4484             Interop.Actor.Actor_RemoveRenderer__SWIG_0(swigCPtr, Renderer.getCPtr(renderer));
4485             if (NDalicPINVOKE.SWIGPendingException.Pending)
4486                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4487         }
4488
4489         /// <since_tizen> 3 </since_tizen>
4490         public void RemoveRenderer(uint index)
4491         {
4492             Interop.Actor.Actor_RemoveRenderer__SWIG_1(swigCPtr, index);
4493             if (NDalicPINVOKE.SWIGPendingException.Pending)
4494                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4495         }
4496
4497         internal void Raise()
4498         {
4499             var parentChildren = GetParent()?.Children;
4500
4501             if (parentChildren != null)
4502             {
4503                 int currentIndex = parentChildren.IndexOf(this);
4504
4505                 // If the view is not already the last item in the list.
4506                 if (currentIndex >= 0 && currentIndex < parentChildren.Count - 1)
4507                 {
4508                     View temp = parentChildren[currentIndex + 1];
4509                     parentChildren[currentIndex + 1] = this;
4510                     parentChildren[currentIndex] = temp;
4511
4512                     Interop.NDalic.Raise(swigCPtr);
4513                     if (NDalicPINVOKE.SWIGPendingException.Pending)
4514                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4515                 }
4516             }
4517         }
4518
4519         internal void Lower()
4520         {
4521             var parentChildren = GetParent()?.Children;
4522
4523             if (parentChildren != null)
4524             {
4525                 int currentIndex = parentChildren.IndexOf(this);
4526
4527                 // If the view is not already the first item in the list.
4528                 if (currentIndex > 0 && currentIndex < parentChildren.Count)
4529                 {
4530                     View temp = parentChildren[currentIndex - 1];
4531                     parentChildren[currentIndex - 1] = this;
4532                     parentChildren[currentIndex] = temp;
4533
4534                     Interop.NDalic.Lower(swigCPtr);
4535                     if (NDalicPINVOKE.SWIGPendingException.Pending)
4536                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4537                 }
4538             }
4539         }
4540
4541         /// <summary>
4542         /// Raises the view to above the target view.
4543         /// </summary>
4544         /// <remarks>The sibling order of views within the parent will be updated automatically.
4545         /// Views on the level above the target view will still be shown above this view.
4546         /// Raising this view above views with the same sibling order as each other will raise this view above them.
4547         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
4548         /// </remarks>
4549         /// <param name="target">Will be raised above this view.</param>
4550         internal void RaiseAbove(View target)
4551         {
4552             var parentChildren = GetParent()?.Children;
4553
4554             if (parentChildren != null)
4555             {
4556                 int currentIndex = parentChildren.IndexOf(this);
4557                 int targetIndex = parentChildren.IndexOf(target);
4558
4559                 if (currentIndex < 0 || targetIndex < 0 ||
4560                     currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
4561                 {
4562                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
4563                     return;
4564                 }
4565                 // If the currentIndex is less than the target index and the target has the same parent.
4566                 if (currentIndex < targetIndex)
4567                 {
4568                     parentChildren.Remove(this);
4569                     parentChildren.Insert(targetIndex, this);
4570
4571                     Interop.NDalic.RaiseAbove(swigCPtr, View.getCPtr(target));
4572                     if (NDalicPINVOKE.SWIGPendingException.Pending)
4573                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4574                 }
4575             }
4576
4577         }
4578
4579         /// <summary>
4580         /// Lowers the view to below the target view.
4581         /// </summary>
4582         /// <remarks>The sibling order of views within the parent will be updated automatically.
4583         /// Lowering this view below views with the same sibling order as each other will lower this view above them.
4584         /// Once a raise or lower API is used that view will then have an exclusive sibling order independent of insertion.
4585         /// </remarks>
4586         /// <param name="target">Will be lowered below this view.</param>
4587         internal void LowerBelow(View target)
4588         {
4589             var parentChildren = GetParent()?.Children;
4590
4591             if (parentChildren != null)
4592             {
4593                 int currentIndex = parentChildren.IndexOf(this);
4594                 int targetIndex = parentChildren.IndexOf(target);
4595                 if (currentIndex < 0 || targetIndex < 0 ||
4596                    currentIndex >= parentChildren.Count || targetIndex >= parentChildren.Count)
4597                 {
4598                     NUILog.Error("index should be bigger than 0 and less than children of layer count");
4599                     return;
4600                 }
4601
4602                 // If the currentIndex is not already the 0th index and the target has the same parent.
4603                 if ((currentIndex != 0) && (targetIndex != -1) &&
4604                     (currentIndex > targetIndex))
4605                 {
4606                     parentChildren.Remove(this);
4607                     parentChildren.Insert(targetIndex, this);
4608
4609                     Interop.NDalic.LowerBelow(swigCPtr, View.getCPtr(target));
4610                     if (NDalicPINVOKE.SWIGPendingException.Pending)
4611                         throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4612                 }
4613             }
4614
4615         }
4616
4617         internal string GetName()
4618         {
4619             string ret = Interop.Actor.Actor_GetName(swigCPtr);
4620             if (NDalicPINVOKE.SWIGPendingException.Pending)
4621                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4622             return ret;
4623         }
4624
4625         internal void SetName(string name)
4626         {
4627             Interop.Actor.Actor_SetName(swigCPtr, name);
4628             if (NDalicPINVOKE.SWIGPendingException.Pending)
4629                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4630         }
4631
4632         internal uint GetId()
4633         {
4634             uint ret = Interop.Actor.Actor_GetId(swigCPtr);
4635             if (NDalicPINVOKE.SWIGPendingException.Pending)
4636                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4637             return ret;
4638         }
4639
4640         internal bool IsRoot()
4641         {
4642             bool ret = Interop.ActorInternal.Actor_IsRoot(swigCPtr);
4643             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4644             return ret;
4645         }
4646
4647         internal bool OnWindow()
4648         {
4649             bool ret = Interop.Actor.Actor_OnStage(swigCPtr);
4650             if (NDalicPINVOKE.SWIGPendingException.Pending)
4651                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4652             return ret;
4653         }
4654
4655         internal View FindChildById(uint id)
4656         {
4657             //to fix memory leak issue, match the handle count with native side.
4658             IntPtr cPtr = Interop.Actor.Actor_FindChildById(swigCPtr, id);
4659             HandleRef CPtr = new global::System.Runtime.InteropServices.HandleRef(this, cPtr);
4660             View ret = Registry.GetManagedBaseHandleFromNativePtr(CPtr.Handle) as View;
4661             Interop.BaseHandle.delete_BaseHandle(CPtr);
4662             CPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
4663
4664             if (NDalicPINVOKE.SWIGPendingException.Pending)
4665                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4666             return ret;
4667         }
4668
4669         internal override View FindCurrentChildById(uint id)
4670         {
4671             return FindChildById(id);
4672         }
4673
4674         internal void SetParentOrigin(Vector3 origin)
4675         {
4676             Interop.ActorInternal.Actor_SetParentOrigin(swigCPtr, Vector3.getCPtr(origin));
4677             if (NDalicPINVOKE.SWIGPendingException.Pending)
4678                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4679         }
4680
4681         internal Vector3 GetCurrentParentOrigin()
4682         {
4683             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentParentOrigin(swigCPtr), true);
4684             if (NDalicPINVOKE.SWIGPendingException.Pending)
4685                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4686             return ret;
4687         }
4688
4689         internal void SetAnchorPoint(Vector3 anchorPoint)
4690         {
4691             Interop.Actor.Actor_SetAnchorPoint(swigCPtr, Vector3.getCPtr(anchorPoint));
4692             if (NDalicPINVOKE.SWIGPendingException.Pending)
4693                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4694         }
4695
4696         internal Vector3 GetCurrentAnchorPoint()
4697         {
4698             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentAnchorPoint(swigCPtr), true);
4699             if (NDalicPINVOKE.SWIGPendingException.Pending)
4700                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4701             return ret;
4702         }
4703
4704         internal void SetSize(float width, float height)
4705         {
4706             Interop.ActorInternal.Actor_SetSize__SWIG_0(swigCPtr, width, height);
4707             if (NDalicPINVOKE.SWIGPendingException.Pending)
4708                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4709         }
4710
4711         internal void SetSize(float width, float height, float depth)
4712         {
4713             Interop.ActorInternal.Actor_SetSize__SWIG_1(swigCPtr, width, height, depth);
4714             if (NDalicPINVOKE.SWIGPendingException.Pending)
4715                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4716         }
4717
4718         internal void SetSize(Vector2 size)
4719         {
4720             Interop.ActorInternal.Actor_SetSize__SWIG_2(swigCPtr, Vector2.getCPtr(size));
4721             if (NDalicPINVOKE.SWIGPendingException.Pending)
4722                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4723         }
4724
4725         internal void SetSize(Vector3 size)
4726         {
4727             Interop.ActorInternal.Actor_SetSize__SWIG_3(swigCPtr, Vector3.getCPtr(size));
4728             if (NDalicPINVOKE.SWIGPendingException.Pending)
4729                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4730         }
4731
4732         internal Vector3 GetTargetSize()
4733         {
4734             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetTargetSize(swigCPtr), true);
4735             if (NDalicPINVOKE.SWIGPendingException.Pending)
4736                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4737             return ret;
4738         }
4739
4740         internal Size2D GetCurrentSize()
4741         {
4742             Size ret = new Size(Interop.Actor.Actor_GetCurrentSize(swigCPtr), true);
4743             if (NDalicPINVOKE.SWIGPendingException.Pending)
4744                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4745             Size2D size = new Size2D((int)ret.Width, (int)ret.Height);
4746             return size;
4747         }
4748
4749         internal Vector3 GetNaturalSize()
4750         {
4751             Vector3 ret = new Vector3(Interop.Actor.Actor_GetNaturalSize(swigCPtr), true);
4752             if (NDalicPINVOKE.SWIGPendingException.Pending)
4753                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4754             return ret;
4755         }
4756
4757         internal void SetPosition(float x, float y)
4758         {
4759             Interop.ActorInternal.Actor_SetPosition__SWIG_0(swigCPtr, x, y);
4760             if (NDalicPINVOKE.SWIGPendingException.Pending)
4761                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4762         }
4763
4764         internal void SetPosition(float x, float y, float z)
4765         {
4766             Interop.ActorInternal.Actor_SetPosition__SWIG_1(swigCPtr, x, y, z);
4767             if (NDalicPINVOKE.SWIGPendingException.Pending)
4768                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4769         }
4770
4771         internal void SetPosition(Vector3 position)
4772         {
4773             Interop.ActorInternal.Actor_SetPosition__SWIG_2(swigCPtr, Vector3.getCPtr(position));
4774             if (NDalicPINVOKE.SWIGPendingException.Pending)
4775                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4776         }
4777
4778         internal void SetX(float x)
4779         {
4780             Interop.ActorInternal.Actor_SetX(swigCPtr, x);
4781             if (NDalicPINVOKE.SWIGPendingException.Pending)
4782                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4783         }
4784
4785         internal void SetY(float y)
4786         {
4787             Interop.ActorInternal.Actor_SetY(swigCPtr, y);
4788             if (NDalicPINVOKE.SWIGPendingException.Pending)
4789                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4790         }
4791
4792         internal void SetZ(float z)
4793         {
4794             Interop.ActorInternal.Actor_SetZ(swigCPtr, z);
4795             if (NDalicPINVOKE.SWIGPendingException.Pending)
4796                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4797         }
4798
4799         internal void TranslateBy(Vector3 distance)
4800         {
4801             Interop.ActorInternal.Actor_TranslateBy(swigCPtr, Vector3.getCPtr(distance));
4802             if (NDalicPINVOKE.SWIGPendingException.Pending)
4803                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4804         }
4805
4806         internal Position GetCurrentPosition()
4807         {
4808             Position ret = new Position(Interop.Actor.Actor_GetCurrentPosition(swigCPtr), true);
4809             if (NDalicPINVOKE.SWIGPendingException.Pending)
4810                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4811             return ret;
4812         }
4813
4814         internal Vector3 GetCurrentWorldPosition()
4815         {
4816             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentWorldPosition(swigCPtr), true);
4817             if (NDalicPINVOKE.SWIGPendingException.Pending)
4818                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4819             return ret;
4820         }
4821
4822         internal void SetInheritPosition(bool inherit)
4823         {
4824             Interop.ActorInternal.Actor_SetInheritPosition(swigCPtr, inherit);
4825             if (NDalicPINVOKE.SWIGPendingException.Pending)
4826                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4827         }
4828
4829         internal bool IsPositionInherited()
4830         {
4831             bool ret = Interop.ActorInternal.Actor_IsPositionInherited(swigCPtr);
4832             if (NDalicPINVOKE.SWIGPendingException.Pending)
4833                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4834             return ret;
4835         }
4836
4837         internal void SetOrientation(Degree angle, Vector3 axis)
4838         {
4839             Interop.ActorInternal.Actor_SetOrientation__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
4840             if (NDalicPINVOKE.SWIGPendingException.Pending)
4841                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4842         }
4843
4844         internal void SetOrientation(Radian angle, Vector3 axis)
4845         {
4846             Interop.ActorInternal.Actor_SetOrientation__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
4847             if (NDalicPINVOKE.SWIGPendingException.Pending)
4848                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4849         }
4850
4851         internal void SetOrientation(Rotation orientation)
4852         {
4853             Interop.ActorInternal.Actor_SetOrientation__SWIG_2(swigCPtr, Rotation.getCPtr(orientation));
4854             if (NDalicPINVOKE.SWIGPendingException.Pending)
4855                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4856         }
4857
4858         internal void RotateBy(Degree angle, Vector3 axis)
4859         {
4860             Interop.ActorInternal.Actor_RotateBy__SWIG_0(swigCPtr, Degree.getCPtr(angle), Vector3.getCPtr(axis));
4861             if (NDalicPINVOKE.SWIGPendingException.Pending)
4862                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4863         }
4864
4865         internal void RotateBy(Radian angle, Vector3 axis)
4866         {
4867             Interop.ActorInternal.Actor_RotateBy__SWIG_1(swigCPtr, Radian.getCPtr(angle), Vector3.getCPtr(axis));
4868             if (NDalicPINVOKE.SWIGPendingException.Pending)
4869                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4870         }
4871
4872         internal void RotateBy(Rotation relativeRotation)
4873         {
4874             Interop.ActorInternal.Actor_RotateBy__SWIG_2(swigCPtr, Rotation.getCPtr(relativeRotation));
4875             if (NDalicPINVOKE.SWIGPendingException.Pending)
4876                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4877         }
4878
4879         internal Rotation GetCurrentOrientation()
4880         {
4881             Rotation ret = new Rotation(Interop.ActorInternal.Actor_GetCurrentOrientation(swigCPtr), true);
4882             if (NDalicPINVOKE.SWIGPendingException.Pending)
4883                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4884             return ret;
4885         }
4886
4887         internal void SetInheritOrientation(bool inherit)
4888         {
4889             Interop.ActorInternal.Actor_SetInheritOrientation(swigCPtr, inherit);
4890             if (NDalicPINVOKE.SWIGPendingException.Pending)
4891                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4892         }
4893
4894         internal bool IsOrientationInherited()
4895         {
4896             bool ret = Interop.ActorInternal.Actor_IsOrientationInherited(swigCPtr);
4897             if (NDalicPINVOKE.SWIGPendingException.Pending)
4898                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4899             return ret;
4900         }
4901
4902         internal Rotation GetCurrentWorldOrientation()
4903         {
4904             Rotation ret = new Rotation(Interop.ActorInternal.Actor_GetCurrentWorldOrientation(swigCPtr), true);
4905             if (NDalicPINVOKE.SWIGPendingException.Pending)
4906                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4907             return ret;
4908         }
4909
4910         internal void SetScale(float scale)
4911         {
4912             Interop.ActorInternal.Actor_SetScale__SWIG_0(swigCPtr, scale);
4913             if (NDalicPINVOKE.SWIGPendingException.Pending)
4914                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4915         }
4916
4917         internal void SetScale(float scaleX, float scaleY, float scaleZ)
4918         {
4919             Interop.ActorInternal.Actor_SetScale__SWIG_1(swigCPtr, scaleX, scaleY, scaleZ);
4920             if (NDalicPINVOKE.SWIGPendingException.Pending)
4921                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4922         }
4923
4924         internal void SetScale(Vector3 scale)
4925         {
4926             Interop.ActorInternal.Actor_SetScale__SWIG_2(swigCPtr, Vector3.getCPtr(scale));
4927             if (NDalicPINVOKE.SWIGPendingException.Pending)
4928                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4929         }
4930
4931         internal void ScaleBy(Vector3 relativeScale)
4932         {
4933             Interop.ActorInternal.Actor_ScaleBy(swigCPtr, Vector3.getCPtr(relativeScale));
4934             if (NDalicPINVOKE.SWIGPendingException.Pending)
4935                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4936         }
4937
4938         internal Vector3 GetCurrentScale()
4939         {
4940             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentScale(swigCPtr), true);
4941             if (NDalicPINVOKE.SWIGPendingException.Pending)
4942                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4943             return ret;
4944         }
4945
4946         internal Vector3 GetCurrentWorldScale()
4947         {
4948             Vector3 ret = new Vector3(Interop.ActorInternal.Actor_GetCurrentWorldScale(swigCPtr), true);
4949             if (NDalicPINVOKE.SWIGPendingException.Pending)
4950                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4951             return ret;
4952         }
4953
4954         internal void SetInheritScale(bool inherit)
4955         {
4956             Interop.ActorInternal.Actor_SetInheritScale(swigCPtr, inherit);
4957             if (NDalicPINVOKE.SWIGPendingException.Pending)
4958                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4959         }
4960
4961         internal bool IsScaleInherited()
4962         {
4963             bool ret = Interop.ActorInternal.Actor_IsScaleInherited(swigCPtr);
4964             if (NDalicPINVOKE.SWIGPendingException.Pending)
4965                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4966             return ret;
4967         }
4968
4969         internal Matrix GetCurrentWorldMatrix()
4970         {
4971             Matrix ret = new Matrix(Interop.ActorInternal.Actor_GetCurrentWorldMatrix(swigCPtr), true);
4972             if (NDalicPINVOKE.SWIGPendingException.Pending)
4973                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4974             return ret;
4975         }
4976
4977         internal void SetVisible(bool visible)
4978         {
4979             Interop.Actor.Actor_SetVisible(swigCPtr, visible);
4980             if (NDalicPINVOKE.SWIGPendingException.Pending)
4981                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4982         }
4983
4984         internal bool IsVisible()
4985         {
4986             bool ret = Interop.ActorInternal.Actor_IsVisible(swigCPtr);
4987             if (NDalicPINVOKE.SWIGPendingException.Pending)
4988                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4989             return ret;
4990         }
4991
4992         internal void SetOpacity(float opacity)
4993         {
4994             Interop.ActorInternal.Actor_SetOpacity(swigCPtr, opacity);
4995             if (NDalicPINVOKE.SWIGPendingException.Pending)
4996                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
4997         }
4998
4999         internal float GetCurrentOpacity()
5000         {
5001             float ret = Interop.ActorInternal.Actor_GetCurrentOpacity(swigCPtr);
5002             if (NDalicPINVOKE.SWIGPendingException.Pending)
5003                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5004             return ret;
5005         }
5006
5007         internal void SetColor(Vector4 color)
5008         {
5009             Interop.ActorInternal.Actor_SetColor(swigCPtr, Vector4.getCPtr(color));
5010             if (NDalicPINVOKE.SWIGPendingException.Pending)
5011                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5012         }
5013
5014         internal Vector4 GetCurrentColor()
5015         {
5016             Vector4 ret = new Vector4(Interop.ActorInternal.Actor_GetCurrentColor(swigCPtr), true);
5017             if (NDalicPINVOKE.SWIGPendingException.Pending)
5018                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5019             return ret;
5020         }
5021
5022         /// This will be public opened in next tizen after ACR done. Before ACR, need to be hidden as inhouse API.
5023         [EditorBrowsable(EditorBrowsableState.Never)]
5024         public void SetColorMode(ColorMode colorMode)
5025         {
5026             Interop.ActorInternal.Actor_SetColorMode(swigCPtr, (int)colorMode);
5027             if (NDalicPINVOKE.SWIGPendingException.Pending)
5028                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5029         }
5030
5031         internal ColorMode GetColorMode()
5032         {
5033             ColorMode ret = (ColorMode)Interop.ActorInternal.Actor_GetColorMode(swigCPtr);
5034             if (NDalicPINVOKE.SWIGPendingException.Pending)
5035                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5036             return ret;
5037         }
5038
5039         internal Vector4 GetCurrentWorldColor()
5040         {
5041             Vector4 ret = new Vector4(Interop.ActorInternal.Actor_GetCurrentWorldColor(swigCPtr), true);
5042             if (NDalicPINVOKE.SWIGPendingException.Pending)
5043                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5044             return ret;
5045         }
5046
5047         internal void SetDrawMode(DrawModeType drawMode)
5048         {
5049             Interop.ActorInternal.Actor_SetDrawMode(swigCPtr, (int)drawMode);
5050             if (NDalicPINVOKE.SWIGPendingException.Pending)
5051                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5052         }
5053
5054         internal DrawModeType GetDrawMode()
5055         {
5056             DrawModeType ret = (DrawModeType)Interop.ActorInternal.Actor_GetDrawMode(swigCPtr);
5057             if (NDalicPINVOKE.SWIGPendingException.Pending)
5058                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5059             return ret;
5060         }
5061
5062         internal void SetKeyboardFocusable(bool focusable)
5063         {
5064             Interop.ActorInternal.Actor_SetKeyboardFocusable(swigCPtr, focusable);
5065             if (NDalicPINVOKE.SWIGPendingException.Pending)
5066                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5067         }
5068
5069         internal bool IsKeyboardFocusable()
5070         {
5071             bool ret = Interop.ActorInternal.Actor_IsKeyboardFocusable(swigCPtr);
5072             if (NDalicPINVOKE.SWIGPendingException.Pending)
5073                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5074             return ret;
5075         }
5076
5077         internal void SetResizePolicy(ResizePolicyType policy, DimensionType dimension)
5078         {
5079             Interop.Actor.Actor_SetResizePolicy(swigCPtr, (int)policy, (int)dimension);
5080             if (NDalicPINVOKE.SWIGPendingException.Pending)
5081                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5082         }
5083
5084         internal ResizePolicyType GetResizePolicy(DimensionType dimension)
5085         {
5086             ResizePolicyType ret = (ResizePolicyType)Interop.Actor.Actor_GetResizePolicy(swigCPtr, (int)dimension);
5087             if (NDalicPINVOKE.SWIGPendingException.Pending)
5088                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5089             return ret;
5090         }
5091
5092         internal Vector3 GetSizeModeFactor()
5093         {
5094             Vector3 ret = new Vector3(Interop.Actor.Actor_GetSizeModeFactor(swigCPtr), true);
5095             if (NDalicPINVOKE.SWIGPendingException.Pending)
5096                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5097             return ret;
5098         }
5099
5100         internal void SetMinimumSize(Vector2 size)
5101         {
5102             Interop.ActorInternal.Actor_SetMinimumSize(swigCPtr, Vector2.getCPtr(size));
5103             if (NDalicPINVOKE.SWIGPendingException.Pending)
5104                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5105         }
5106
5107         internal Vector2 GetMinimumSize()
5108         {
5109             Vector2 ret = new Vector2(Interop.ActorInternal.Actor_GetMinimumSize(swigCPtr), true);
5110             if (NDalicPINVOKE.SWIGPendingException.Pending)
5111                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5112             return ret;
5113         }
5114
5115         internal void SetMaximumSize(Vector2 size)
5116         {
5117             Interop.ActorInternal.Actor_SetMaximumSize(swigCPtr, Vector2.getCPtr(size));
5118             if (NDalicPINVOKE.SWIGPendingException.Pending)
5119                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5120         }
5121
5122         internal Vector2 GetMaximumSize()
5123         {
5124             Vector2 ret = new Vector2(Interop.ActorInternal.Actor_GetMaximumSize(swigCPtr), true);
5125             if (NDalicPINVOKE.SWIGPendingException.Pending)
5126                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5127             return ret;
5128         }
5129
5130         internal int GetHierarchyDepth()
5131         {
5132             int ret = Interop.Actor.Actor_GetHierarchyDepth(swigCPtr);
5133             if (NDalicPINVOKE.SWIGPendingException.Pending)
5134                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5135             return ret;
5136         }
5137
5138         internal uint GetRendererCount()
5139         {
5140             uint ret = Interop.Actor.Actor_GetRendererCount(swigCPtr);
5141             if (NDalicPINVOKE.SWIGPendingException.Pending)
5142                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5143             return ret;
5144         }
5145
5146         internal TouchDataSignal TouchSignal()
5147         {
5148             TouchDataSignal ret = new TouchDataSignal(Interop.ActorSignal.Actor_TouchSignal(swigCPtr), false);
5149             if (NDalicPINVOKE.SWIGPendingException.Pending)
5150                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5151             return ret;
5152         }
5153
5154         internal HoverSignal HoveredSignal()
5155         {
5156             HoverSignal ret = new HoverSignal(Interop.ActorSignal.Actor_HoveredSignal(swigCPtr), false);
5157             if (NDalicPINVOKE.SWIGPendingException.Pending)
5158                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5159             return ret;
5160         }
5161
5162         internal WheelSignal WheelEventSignal()
5163         {
5164             WheelSignal ret = new WheelSignal(Interop.ActorSignal.Actor_WheelEventSignal(swigCPtr), false);
5165             if (NDalicPINVOKE.SWIGPendingException.Pending)
5166                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5167             return ret;
5168         }
5169
5170         internal ViewSignal OnWindowSignal()
5171         {
5172             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnStageSignal(swigCPtr), false);
5173             if (NDalicPINVOKE.SWIGPendingException.Pending)
5174                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5175             return ret;
5176         }
5177
5178         internal ViewSignal OffWindowSignal()
5179         {
5180             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OffStageSignal(swigCPtr), false);
5181             if (NDalicPINVOKE.SWIGPendingException.Pending)
5182                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5183             return ret;
5184         }
5185
5186         internal ViewSignal OnRelayoutSignal()
5187         {
5188             ViewSignal ret = new ViewSignal(Interop.ActorSignal.Actor_OnRelayoutSignal(swigCPtr), false);
5189             if (NDalicPINVOKE.SWIGPendingException.Pending)
5190                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5191             return ret;
5192         }
5193
5194         internal ViewVisibilityChangedSignal VisibilityChangedSignal(View view)
5195         {
5196             ViewVisibilityChangedSignal ret = new ViewVisibilityChangedSignal(Interop.NDalic.VisibilityChangedSignal(View.getCPtr(view)), false);
5197             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5198             return ret;
5199         }
5200
5201         internal ViewLayoutDirectionChangedSignal LayoutDirectionChangedSignal(View view)
5202         {
5203             ViewLayoutDirectionChangedSignal ret = new ViewLayoutDirectionChangedSignal(Interop.Layout.LayoutDirectionChangedSignal(View.getCPtr(view)), false);
5204             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5205             return ret;
5206         }
5207
5208         internal ViewSignal ResourcesLoadedSignal()
5209         {
5210             ViewSignal ret = new ViewSignal(Interop.View.ResourceReadySignal(swigCPtr), false);
5211             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5212             return ret;
5213         }
5214
5215         internal static global::System.Runtime.InteropServices.HandleRef getCPtr(View obj)
5216         {
5217             return (obj == null) ? new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero) : obj.swigCPtr;
5218         }
5219
5220         internal bool IsTopLevelView()
5221         {
5222             if (GetParent() is Layer)
5223             {
5224                 return true;
5225             }
5226             return false;
5227         }
5228
5229         internal void SetKeyInputFocus()
5230         {
5231             Interop.ViewInternal.View_SetKeyInputFocus(swigCPtr);
5232             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5233         }
5234
5235         internal void ClearKeyInputFocus()
5236         {
5237             Interop.ViewInternal.View_ClearKeyInputFocus(swigCPtr);
5238             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5239         }
5240
5241         internal PinchGestureDetector GetPinchGestureDetector()
5242         {
5243             PinchGestureDetector ret = new PinchGestureDetector(Interop.ViewInternal.View_GetPinchGestureDetector(swigCPtr), true);
5244             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5245             return ret;
5246         }
5247
5248         internal PanGestureDetector GetPanGestureDetector()
5249         {
5250             PanGestureDetector ret = new PanGestureDetector(Interop.ViewInternal.View_GetPanGestureDetector(swigCPtr), true);
5251             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5252             return ret;
5253         }
5254
5255         internal TapGestureDetector GetTapGestureDetector()
5256         {
5257             TapGestureDetector ret = new TapGestureDetector(Interop.ViewInternal.View_GetTapGestureDetector(swigCPtr), true);
5258             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5259             return ret;
5260         }
5261
5262         internal LongPressGestureDetector GetLongPressGestureDetector()
5263         {
5264             LongPressGestureDetector ret = new LongPressGestureDetector(Interop.ViewInternal.View_GetLongPressGestureDetector(swigCPtr), true);
5265             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5266             return ret;
5267         }
5268
5269         internal ControlKeySignal KeyEventSignal()
5270         {
5271             ControlKeySignal ret = new ControlKeySignal(Interop.ViewSignal.View_KeyEventSignal(swigCPtr), false);
5272             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5273             return ret;
5274         }
5275
5276         internal KeyInputFocusSignal KeyInputFocusGainedSignal()
5277         {
5278             KeyInputFocusSignal ret = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusGainedSignal(swigCPtr), false);
5279             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5280             return ret;
5281         }
5282
5283         internal KeyInputFocusSignal KeyInputFocusLostSignal()
5284         {
5285             KeyInputFocusSignal ret = new KeyInputFocusSignal(Interop.ViewSignal.View_KeyInputFocusLostSignal(swigCPtr), false);
5286             if (NDalicPINVOKE.SWIGPendingException.Pending) throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5287             return ret;
5288         }
5289
5290         internal IntPtr GetPtrfromView()
5291         {
5292             return (IntPtr)swigCPtr;
5293         }
5294
5295         internal void RemoveChild(View child)
5296         {
5297             // Do actual child removal
5298             Interop.Actor.Actor_Remove(swigCPtr, View.getCPtr(child));
5299             if (NDalicPINVOKE.SWIGPendingException.Pending)
5300                 throw NDalicPINVOKE.SWIGPendingException.Retrieve();
5301
5302             Children.Remove(child);
5303             child.InternalParent = null;
5304
5305             if (ChildRemoved != null)
5306             {
5307                 ChildRemovedEventArgs e = new ChildRemovedEventArgs
5308                 {
5309                     Removed = child
5310                 };
5311                 ChildRemoved(this, e);
5312             }
5313         }
5314
5315         /// <summary>
5316         /// Removes the layout from this View.
5317         /// </summary>
5318         internal void ResetLayout()
5319         {
5320             _layout = null;
5321         }
5322
5323         internal ResourceLoadingStatusType GetBackgroundResourceStatus()
5324         {
5325             return (ResourceLoadingStatusType)Interop.View.View_GetVisualResourceStatus(this.swigCPtr, Property.BACKGROUND);
5326         }
5327
5328         /// <summary>
5329         /// you can override it to clean-up your own resources.
5330         /// </summary>
5331         /// <param name="type">DisposeTypes</param>
5332         /// <since_tizen> 3 </since_tizen>
5333         protected override void Dispose(DisposeTypes type)
5334         {
5335             if (disposed)
5336             {
5337                 return;
5338             }
5339
5340             //_mergedStyle = null;
5341
5342             if (type == DisposeTypes.Explicit)
5343             {
5344                 //Called by User
5345                 //Release your own managed resources here.
5346                 //You should release all of your own disposable objects here.
5347             }
5348
5349             //Release your own unmanaged resources here.
5350             //You should not access any managed member here except static instance.
5351             //because the execution order of Finalizes is non-deterministic.
5352             if (this != null)
5353             {
5354                 DisConnectFromSignals();
5355             }
5356
5357             if (swigCPtr.Handle != global::System.IntPtr.Zero)
5358             {
5359                 if (swigCMemOwn)
5360                 {
5361                     swigCMemOwn = false;
5362                     Interop.View.delete_View(swigCPtr);
5363                 }
5364                 swigCPtr = new global::System.Runtime.InteropServices.HandleRef(null, global::System.IntPtr.Zero);
5365             }
5366
5367             foreach (View view in Children)
5368             {
5369                 view.InternalParent = null;
5370             }
5371
5372             base.Dispose(type);
5373
5374         }
5375
5376         private void OnSize2DChanged(int width, int height)
5377         {
5378             Size2D = new Size2D(width, height);
5379         }
5380
5381         private void OnMinimumSizeChanged(int width, int height)
5382         {
5383             MinimumSize = new Size2D(width, height);
5384         }
5385
5386         private void OnMaximumSizeChanged(int width, int height)
5387         {
5388             MaximumSize = new Size2D(width, height);
5389         }
5390
5391         private void OnPosition2DChanged(int x, int y)
5392         {
5393             Position2D = new Position2D(x, y);
5394         }
5395
5396         private void OnSizeChanged(float width, float height, float depth)
5397         {
5398             Size = new Size(width, height, depth);
5399         }
5400
5401         private void OnPositionChanged(float x, float y, float z)
5402         {
5403             Position = new Position(x, y, z);
5404         }
5405
5406         private void OnParentOriginChanged(float x, float y, float z)
5407         {
5408             ParentOrigin = new Position(x, y, z);
5409         }
5410
5411         private void OnPivotPointChanged(float x, float y, float z)
5412         {
5413             PivotPoint = new Position(x, y, z);
5414         }
5415
5416         private void DisConnectFromSignals()
5417         {
5418             // Save current CPtr.
5419             global::System.Runtime.InteropServices.HandleRef currentCPtr = swigCPtr;
5420
5421             // Use BaseHandle CPtr as current might have been deleted already in derived classes.
5422             swigCPtr = GetBaseHandleCPtrHandleRef;
5423
5424             if (_onRelayoutEventCallback != null)
5425             {
5426                 this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
5427             }
5428
5429             if (_offWindowEventCallback != null)
5430             {
5431                 this.OffWindowSignal().Disconnect(_offWindowEventCallback);
5432             }
5433
5434             if (_onWindowEventCallback != null)
5435             {
5436                 this.OnWindowSignal().Disconnect(_onWindowEventCallback);
5437             }
5438
5439             if (_wheelEventCallback != null)
5440             {
5441                 this.WheelEventSignal().Disconnect(_wheelEventCallback);
5442             }
5443
5444             if (_hoverEventCallback != null)
5445             {
5446                 this.HoveredSignal().Disconnect(_hoverEventCallback);
5447             }
5448
5449             if (_touchDataCallback != null)
5450             {
5451                 this.TouchSignal().Disconnect(_touchDataCallback);
5452             }
5453
5454             if (_ResourcesLoadedCallback != null)
5455             {
5456                 this.ResourcesLoadedSignal().Disconnect(_ResourcesLoadedCallback);
5457             }
5458
5459             if (_offWindowEventCallback != null)
5460             {
5461                 this.OffWindowSignal().Disconnect(_offWindowEventCallback);
5462             }
5463
5464             if (_onWindowEventCallback != null)
5465             {
5466                 this.OnWindowSignal().Disconnect(_onWindowEventCallback);
5467             }
5468
5469             if (_wheelEventCallback != null)
5470             {
5471                 this.WheelEventSignal().Disconnect(_wheelEventCallback);
5472             }
5473
5474             if (_hoverEventCallback != null)
5475             {
5476                 this.HoveredSignal().Disconnect(_hoverEventCallback);
5477             }
5478
5479             if (_touchDataCallback != null)
5480             {
5481                 this.TouchSignal().Disconnect(_touchDataCallback);
5482             }
5483
5484             if (_onRelayoutEventCallback != null)
5485             {
5486                 this.OnRelayoutSignal().Disconnect(_onRelayoutEventCallback);
5487             }
5488
5489             if (_keyCallback != null)
5490             {
5491                 this.KeyEventSignal().Disconnect(_keyCallback);
5492             }
5493
5494             if (_keyInputFocusLostCallback != null)
5495             {
5496                 this.KeyInputFocusLostSignal().Disconnect(_keyInputFocusLostCallback);
5497             }
5498
5499             if (_keyInputFocusGainedCallback != null)
5500             {
5501                 this.KeyInputFocusGainedSignal().Disconnect(_keyInputFocusGainedCallback);
5502             }
5503
5504             if (_backgroundResourceLoadedCallback != null)
5505             {
5506                 this.ResourcesLoadedSignal().Disconnect(_backgroundResourceLoadedCallback);
5507             }
5508
5509             if (_onWindowSendEventCallback != null)
5510             {
5511                 this.OnWindowSignal().Disconnect(_onWindowSendEventCallback);
5512             }
5513
5514             // BaseHandle CPtr is used in Registry and there is danger of deletion if we keep using it here.
5515             // Restore current CPtr.
5516             swigCPtr = currentCPtr;
5517         }
5518
5519         private void OnKeyInputFocusGained(IntPtr view)
5520         {
5521             if (_keyInputFocusGainedEventHandler != null)
5522             {
5523                 _keyInputFocusGainedEventHandler(this, null);
5524             }
5525         }
5526
5527         private void OnKeyInputFocusLost(IntPtr view)
5528         {
5529             if (_keyInputFocusLostEventHandler != null)
5530             {
5531                 _keyInputFocusLostEventHandler(this, null);
5532             }
5533         }
5534
5535         private bool OnKeyEvent(IntPtr view, IntPtr keyEvent)
5536         {
5537             if (keyEvent == global::System.IntPtr.Zero)
5538             {
5539                 NUILog.Error("keyEvent should not be null!");
5540                 return true;
5541             }
5542
5543             KeyEventArgs e = new KeyEventArgs();
5544
5545             bool result = false;
5546
5547             e.Key = Tizen.NUI.Key.GetKeyFromPtr(keyEvent);
5548
5549             if (_keyEventHandler != null)
5550             {
5551                 Delegate[] delegateList = _keyEventHandler.GetInvocationList();
5552
5553                 // Oring the result of each callback.
5554                 foreach (EventHandlerWithReturnType<object, KeyEventArgs, bool> del in delegateList)
5555                 {
5556                     result |= del(this, e);
5557                 }
5558             }
5559
5560             return result;
5561         }
5562
5563         // Callback for View OnRelayout signal
5564         private void OnRelayout(IntPtr data)
5565         {
5566             if (_onRelayoutEventHandler != null)
5567             {
5568                 _onRelayoutEventHandler(this, null);
5569             }
5570         }
5571
5572         // Callback for View TouchSignal
5573         private bool OnTouch(IntPtr view, IntPtr touchData)
5574         {
5575             if (touchData == global::System.IntPtr.Zero)
5576             {
5577                 NUILog.Error("touchData should not be null!");
5578                 return true;
5579             }
5580
5581             TouchEventArgs e = new TouchEventArgs();
5582
5583             e.Touch = Tizen.NUI.Touch.GetTouchFromPtr(touchData);
5584
5585             if (_touchDataEventHandler != null)
5586             {
5587                 return _touchDataEventHandler(this, e);
5588             }
5589             return false;
5590         }
5591
5592         // Callback for View Hover signal
5593         private bool OnHoverEvent(IntPtr view, IntPtr hoverEvent)
5594         {
5595             if (hoverEvent == global::System.IntPtr.Zero)
5596             {
5597                 NUILog.Error("hoverEvent should not be null!");
5598                 return true;
5599             }
5600
5601             HoverEventArgs e = new HoverEventArgs();
5602
5603             e.Hover = Tizen.NUI.Hover.GetHoverFromPtr(hoverEvent);
5604
5605             if (_hoverEventHandler != null)
5606             {
5607                 return _hoverEventHandler(this, e);
5608             }
5609             return false;
5610         }
5611
5612         // Callback for View Wheel signal
5613         private bool OnWheelEvent(IntPtr view, IntPtr wheelEvent)
5614         {
5615             if (wheelEvent == global::System.IntPtr.Zero)
5616             {
5617                 NUILog.Error("wheelEvent should not be null!");
5618                 return true;
5619             }
5620
5621             WheelEventArgs e = new WheelEventArgs();
5622
5623             e.Wheel = Tizen.NUI.Wheel.GetWheelFromPtr(wheelEvent);
5624
5625             if (_wheelEventHandler != null)
5626             {
5627                 return _wheelEventHandler(this, e);
5628             }
5629             return false;
5630         }
5631
5632         // Callback for View OnWindow signal
5633         private void OnWindow(IntPtr data)
5634         {
5635             if (_onWindowEventHandler != null)
5636             {
5637                 _onWindowEventHandler(this, null);
5638             }
5639         }
5640
5641         // Callback for View OffWindow signal
5642         private void OffWindow(IntPtr data)
5643         {
5644             if (_offWindowEventHandler != null)
5645             {
5646                 _offWindowEventHandler(this, null);
5647             }
5648         }
5649
5650         // Callback for View visibility change signal
5651         private void OnVisibilityChanged(IntPtr data, bool visibility, VisibilityChangeType type)
5652         {
5653             VisibilityChangedEventArgs e = new VisibilityChangedEventArgs();
5654             if (data != null)
5655             {
5656                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
5657             }
5658             e.Visibility = visibility;
5659             e.Type = type;
5660
5661             if (_visibilityChangedEventHandler != null)
5662             {
5663                 _visibilityChangedEventHandler(this, e);
5664             }
5665         }
5666
5667         // Callback for View layout direction change signal
5668         private void OnLayoutDirectionChanged(IntPtr data, ViewLayoutDirectionType type)
5669         {
5670             LayoutDirectionChangedEventArgs e = new LayoutDirectionChangedEventArgs();
5671             if (data != null)
5672             {
5673                 e.View = Registry.GetManagedBaseHandleFromNativePtr(data) as View;
5674             }
5675             e.Type = type;
5676
5677             if (_layoutDirectionChangedEventHandler != null)
5678             {
5679                 _layoutDirectionChangedEventHandler(this, e);
5680             }
5681         }
5682
5683         private void OnResourcesLoaded(IntPtr view)
5684         {
5685             if (_resourcesLoadedEventHandler != null)
5686             {
5687                 _resourcesLoadedEventHandler(this, null);
5688             }
5689         }
5690
5691         private View ConvertIdToView(uint id)
5692         {
5693             View view = GetParent()?.FindCurrentChildById(id);
5694
5695             //If we can't find the parent's children, find in the top layer.
5696             if (!view)
5697             {
5698                 Container parent = GetParent();
5699                 while ((parent is View) && (parent != null))
5700                 {
5701                     parent = parent.GetParent();
5702                     if (parent is Layer)
5703                     {
5704                         view = parent.FindCurrentChildById(id);
5705                         break;
5706                     }
5707                 }
5708             }
5709
5710             return view;
5711         }
5712
5713         private void OnBackgroundResourceLoaded(IntPtr view)
5714         {
5715             BackgroundResourceLoadedEventArgs e = new BackgroundResourceLoadedEventArgs();
5716             e.Status = (ResourceLoadingStatusType)Interop.View.View_GetVisualResourceStatus(this.swigCPtr, Property.BACKGROUND);
5717
5718             if (_backgroundResourceLoadedEventHandler != null)
5719             {
5720                 _backgroundResourceLoadedEventHandler(this, e);
5721             }
5722         }
5723
5724         /// <summary>
5725         /// Event argument passed through the ChildAdded event.
5726         /// </summary>
5727         /// <since_tizen> 5 </since_tizen>
5728         public class ChildAddedEventArgs : EventArgs
5729         {
5730             /// <summary>
5731             /// Added child view at moment.
5732             /// </summary>
5733             /// <since_tizen> 5 </since_tizen>
5734             public View Added { get; set; }
5735         }
5736
5737         /// <summary>
5738         /// Event argument passed through the ChildRemoved event.
5739         /// </summary>
5740         /// <since_tizen> 5 </since_tizen>
5741         public class ChildRemovedEventArgs : EventArgs
5742         {
5743             /// <summary>
5744             /// Removed child view at moment.
5745             /// </summary>
5746             /// <since_tizen> 5 </since_tizen>
5747             public View Removed { get; set; }
5748         }
5749
5750         /// <summary>
5751         /// Event arguments that passed via the KeyEvent signal.
5752         /// </summary>
5753         /// <since_tizen> 3 </since_tizen>
5754         public class KeyEventArgs : EventArgs
5755         {
5756             private Key _key;
5757
5758             /// <summary>
5759             /// Key - is the key sent to the view.
5760             /// </summary>
5761             /// <since_tizen> 3 </since_tizen>
5762             public Key Key
5763             {
5764                 get
5765                 {
5766                     return _key;
5767                 }
5768                 set
5769                 {
5770                     _key = value;
5771                 }
5772             }
5773         }
5774
5775         /// <summary>
5776         /// Event arguments that passed via the touch signal.
5777         /// </summary>
5778         /// <since_tizen> 3 </since_tizen>
5779         public class TouchEventArgs : EventArgs
5780         {
5781             private Touch _touch;
5782
5783             /// <summary>
5784             /// Touch - contains the information of touch points.
5785             /// </summary>
5786             /// <since_tizen> 3 </since_tizen>
5787             public Touch Touch
5788             {
5789                 get
5790                 {
5791                     return _touch;
5792                 }
5793                 set
5794                 {
5795                     _touch = value;
5796                 }
5797             }
5798         }
5799
5800         /// <summary>
5801         /// Event arguments that passed via the hover signal.
5802         /// </summary>
5803         /// <since_tizen> 3 </since_tizen>
5804         public class HoverEventArgs : EventArgs
5805         {
5806             private Hover _hover;
5807
5808             /// <summary>
5809             /// Hover - contains touch points that represent the points that are currently being hovered or the points where a hover has stopped.
5810             /// </summary>
5811             /// <since_tizen> 3 </since_tizen>
5812             public Hover Hover
5813             {
5814                 get
5815                 {
5816                     return _hover;
5817                 }
5818                 set
5819                 {
5820                     _hover = value;
5821                 }
5822             }
5823         }
5824
5825         /// <summary>
5826         /// Event arguments that passed via the wheel signal.
5827         /// </summary>
5828         /// <since_tizen> 3 </since_tizen>
5829         public class WheelEventArgs : EventArgs
5830         {
5831             private Wheel _wheel;
5832
5833             /// <summary>
5834             /// WheelEvent - store a wheel rolling type: MOUSE_WHEEL or CUSTOM_WHEEL.
5835             /// </summary>
5836             /// <since_tizen> 3 </since_tizen>
5837             public Wheel Wheel
5838             {
5839                 get
5840                 {
5841                     return _wheel;
5842                 }
5843                 set
5844                 {
5845                     _wheel = value;
5846                 }
5847             }
5848         }
5849
5850         /// <summary>
5851         /// Event arguments of visibility changed.
5852         /// </summary>
5853         /// <since_tizen> 3 </since_tizen>
5854         public class VisibilityChangedEventArgs : EventArgs
5855         {
5856             private View _view;
5857             private bool _visibility;
5858             private VisibilityChangeType _type;
5859
5860             /// <summary>
5861             /// The view, or child of view, whose visibility has changed.
5862             /// </summary>
5863             /// <since_tizen> 3 </since_tizen>
5864             public View View
5865             {
5866                 get
5867                 {
5868                     return _view;
5869                 }
5870                 set
5871                 {
5872                     _view = value;
5873                 }
5874             }
5875
5876             /// <summary>
5877             /// Whether the view is now visible or not.
5878             /// </summary>
5879             /// <since_tizen> 3 </since_tizen>
5880             public bool Visibility
5881             {
5882                 get
5883                 {
5884                     return _visibility;
5885                 }
5886                 set
5887                 {
5888                     _visibility = value;
5889                 }
5890             }
5891
5892             /// <summary>
5893             /// Whether the view's visible property has changed or a parent's.
5894             /// </summary>
5895             /// <since_tizen> 3 </since_tizen>
5896             public VisibilityChangeType Type
5897             {
5898                 get
5899                 {
5900                     return _type;
5901                 }
5902                 set
5903                 {
5904                     _type = value;
5905                 }
5906             }
5907         }
5908
5909         /// <summary>
5910         /// Event arguments of layout direction changed.
5911         /// </summary>
5912         /// <since_tizen> 4 </since_tizen>
5913         public class LayoutDirectionChangedEventArgs : EventArgs
5914         {
5915             private View _view;
5916             private ViewLayoutDirectionType _type;
5917
5918             /// <summary>
5919             /// The view, or child of view, whose layout direction has changed.
5920             /// </summary>
5921             /// <since_tizen> 4 </since_tizen>
5922             public View View
5923             {
5924                 get
5925                 {
5926                     return _view;
5927                 }
5928                 set
5929                 {
5930                     _view = value;
5931                 }
5932             }
5933
5934             /// <summary>
5935             /// Whether the view's layout direction property has changed or a parent's.
5936             /// </summary>
5937             /// <since_tizen> 4 </since_tizen>
5938             public ViewLayoutDirectionType Type
5939             {
5940                 get
5941                 {
5942                     return _type;
5943                 }
5944                 set
5945                 {
5946                     _type = value;
5947                 }
5948             }
5949         }
5950
5951
5952         private Dictionary<string, Transition> transDictionary = new Dictionary<string, Transition>();
5953
5954         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
5955         [EditorBrowsable(EditorBrowsableState.Never)]
5956         public Transition GetTransition(string transitionName)
5957         {
5958             Transition trans = null;
5959             transDictionary.TryGetValue(transitionName, out trans);
5960             return trans;
5961         }
5962
5963         private void LoadTransitions()
5964         {
5965             foreach (string str in transitionNames)
5966             {
5967                 string resourceName = str + ".xaml";
5968                 Transition trans = null;
5969
5970                 string resource = Tizen.Applications.Application.Current.DirectoryInfo.Resource;
5971
5972                 string likelyResourcePath = resource + "animation/" + resourceName;
5973
5974                 if (File.Exists(likelyResourcePath))
5975                 {
5976                     trans = Extensions.LoadObject<Transition>(likelyResourcePath);
5977                 }
5978                 if (trans)
5979                 {
5980                     transDictionary.Add(trans.Name, trans);
5981                 }
5982             }
5983         }
5984
5985         /// This will be public opened in tizen_next after ACR done. Before ACR, need to be hidden as inhouse API.
5986         [EditorBrowsable(EditorBrowsableState.Never)]
5987         public string[] TransitionNames
5988         {
5989             get
5990             {
5991                 return transitionNames;
5992             }
5993             set
5994             {
5995                 transitionNames = value;
5996                 LoadTransitions();
5997             }
5998         }
5999         private string[] transitionNames;
6000
6001         internal class BackgroundResourceLoadedEventArgs : EventArgs
6002         {
6003             private ResourceLoadingStatusType status = ResourceLoadingStatusType.Invalid;
6004             public ResourceLoadingStatusType Status
6005             {
6006                 get
6007                 {
6008                     return status;
6009                 }
6010                 set
6011                 {
6012                     status = value;
6013                 }
6014             }
6015         }
6016
6017         internal class Property
6018         {
6019             internal static readonly int TOOLTIP = Interop.ViewProperty.View_Property_TOOLTIP_get();
6020             internal static readonly int STATE = Interop.ViewProperty.View_Property_STATE_get();
6021             internal static readonly int SUB_STATE = Interop.ViewProperty.View_Property_SUB_STATE_get();
6022             internal static readonly int LEFT_FOCUSABLE_VIEW_ID = Interop.ViewProperty.View_Property_LEFT_FOCUSABLE_ACTOR_ID_get();
6023             internal static readonly int RIGHT_FOCUSABLE_VIEW_ID = Interop.ViewProperty.View_Property_RIGHT_FOCUSABLE_ACTOR_ID_get();
6024             internal static readonly int UP_FOCUSABLE_VIEW_ID = Interop.ViewProperty.View_Property_UP_FOCUSABLE_ACTOR_ID_get();
6025             internal static readonly int DOWN_FOCUSABLE_VIEW_ID = Interop.ViewProperty.View_Property_DOWN_FOCUSABLE_ACTOR_ID_get();
6026             internal static readonly int STYLE_NAME = Interop.ViewProperty.View_Property_STYLE_NAME_get();
6027             internal static readonly int BACKGROUND = Interop.ViewProperty.View_Property_BACKGROUND_get();
6028             internal static readonly int SIBLING_ORDER = Interop.ActorProperty.Actor_Property_SIBLING_ORDER_get();
6029             internal static readonly int OPACITY = Interop.ActorProperty.Actor_Property_OPACITY_get();
6030             internal static readonly int SCREEN_POSITION = Interop.ActorProperty.Actor_Property_SCREEN_POSITION_get();
6031             internal static readonly int POSITION_USES_ANCHOR_POINT = Interop.ActorProperty.Actor_Property_POSITION_USES_ANCHOR_POINT_get();
6032             internal static readonly int PARENT_ORIGIN = Interop.ActorProperty.Actor_Property_PARENT_ORIGIN_get();
6033             internal static readonly int PARENT_ORIGIN_X = Interop.ActorProperty.Actor_Property_PARENT_ORIGIN_X_get();
6034             internal static readonly int PARENT_ORIGIN_Y = Interop.ActorProperty.Actor_Property_PARENT_ORIGIN_Y_get();
6035             internal static readonly int PARENT_ORIGIN_Z = Interop.ActorProperty.Actor_Property_PARENT_ORIGIN_Z_get();
6036             internal static readonly int ANCHOR_POINT = Interop.ActorProperty.Actor_Property_ANCHOR_POINT_get();
6037             internal static readonly int ANCHOR_POINT_X = Interop.ActorProperty.Actor_Property_ANCHOR_POINT_X_get();
6038             internal static readonly int ANCHOR_POINT_Y = Interop.ActorProperty.Actor_Property_ANCHOR_POINT_Y_get();
6039             internal static readonly int ANCHOR_POINT_Z = Interop.ActorProperty.Actor_Property_ANCHOR_POINT_Z_get();
6040             internal static readonly int SIZE = Interop.ActorProperty.Actor_Property_SIZE_get();
6041             internal static readonly int SIZE_WIDTH = Interop.ActorProperty.Actor_Property_SIZE_WIDTH_get();
6042             internal static readonly int SIZE_HEIGHT = Interop.ActorProperty.Actor_Property_SIZE_HEIGHT_get();
6043             internal static readonly int SIZE_DEPTH = Interop.ActorProperty.Actor_Property_SIZE_DEPTH_get();
6044             internal static readonly int POSITION = Interop.ActorProperty.Actor_Property_POSITION_get();
6045             internal static readonly int POSITION_X = Interop.ActorProperty.Actor_Property_POSITION_X_get();
6046             internal static readonly int POSITION_Y = Interop.ActorProperty.Actor_Property_POSITION_Y_get();
6047             internal static readonly int POSITION_Z = Interop.ActorProperty.Actor_Property_POSITION_Z_get();
6048             internal static readonly int WORLD_POSITION = Interop.ActorProperty.Actor_Property_WORLD_POSITION_get();
6049             internal static readonly int WORLD_POSITION_X = Interop.ActorProperty.Actor_Property_WORLD_POSITION_X_get();
6050             internal static readonly int WORLD_POSITION_Y = Interop.ActorProperty.Actor_Property_WORLD_POSITION_Y_get();
6051             internal static readonly int WORLD_POSITION_Z = Interop.ActorProperty.Actor_Property_WORLD_POSITION_Z_get();
6052             internal static readonly int ORIENTATION = Interop.ActorProperty.Actor_Property_ORIENTATION_get();
6053             internal static readonly int WORLD_ORIENTATION = Interop.ActorProperty.Actor_Property_WORLD_ORIENTATION_get();
6054             internal static readonly int SCALE = Interop.ActorProperty.Actor_Property_SCALE_get();
6055             internal static readonly int SCALE_X = Interop.ActorProperty.Actor_Property_SCALE_X_get();
6056             internal static readonly int SCALE_Y = Interop.ActorProperty.Actor_Property_SCALE_Y_get();
6057             internal static readonly int SCALE_Z = Interop.ActorProperty.Actor_Property_SCALE_Z_get();
6058             internal static readonly int WORLD_SCALE = Interop.ActorProperty.Actor_Property_WORLD_SCALE_get();
6059             internal static readonly int VISIBLE = Interop.ActorProperty.Actor_Property_VISIBLE_get();
6060             internal static readonly int WORLD_COLOR = Interop.ActorProperty.Actor_Property_WORLD_COLOR_get();
6061             internal static readonly int WORLD_MATRIX = Interop.ActorProperty.Actor_Property_WORLD_MATRIX_get();
6062             internal static readonly int NAME = Interop.ActorProperty.Actor_Property_NAME_get();
6063             internal static readonly int SENSITIVE = Interop.ActorProperty.Actor_Property_SENSITIVE_get();
6064             internal static readonly int LEAVE_REQUIRED = Interop.ActorProperty.Actor_Property_LEAVE_REQUIRED_get();
6065             internal static readonly int INHERIT_ORIENTATION = Interop.ActorProperty.Actor_Property_INHERIT_ORIENTATION_get();
6066             internal static readonly int INHERIT_SCALE = Interop.ActorProperty.Actor_Property_INHERIT_SCALE_get();
6067             internal static readonly int DRAW_MODE = Interop.ActorProperty.Actor_Property_DRAW_MODE_get();
6068             internal static readonly int SIZE_MODE_FACTOR = Interop.ActorProperty.Actor_Property_SIZE_MODE_FACTOR_get();
6069             internal static readonly int WIDTH_RESIZE_POLICY = Interop.ActorProperty.Actor_Property_WIDTH_RESIZE_POLICY_get();
6070             internal static readonly int HEIGHT_RESIZE_POLICY = Interop.ActorProperty.Actor_Property_HEIGHT_RESIZE_POLICY_get();
6071             internal static readonly int SIZE_SCALE_POLICY = Interop.ActorProperty.Actor_Property_SIZE_SCALE_POLICY_get();
6072             internal static readonly int WIDTH_FOR_HEIGHT = Interop.ActorProperty.Actor_Property_WIDTH_FOR_HEIGHT_get();
6073             internal static readonly int HEIGHT_FOR_WIDTH = Interop.ActorProperty.Actor_Property_HEIGHT_FOR_WIDTH_get();
6074             internal static readonly int MINIMUM_SIZE = Interop.ActorProperty.Actor_Property_MINIMUM_SIZE_get();
6075             internal static readonly int MAXIMUM_SIZE = Interop.ActorProperty.Actor_Property_MAXIMUM_SIZE_get();
6076             internal static readonly int INHERIT_POSITION = Interop.ActorProperty.Actor_Property_INHERIT_POSITION_get();
6077             internal static readonly int CLIPPING_MODE = Interop.ActorProperty.Actor_Property_CLIPPING_MODE_get();
6078             internal static readonly int INHERIT_LAYOUT_DIRECTION = Interop.ActorProperty.Actor_Property_INHERIT_LAYOUT_DIRECTION_get();
6079             internal static readonly int LAYOUT_DIRECTION = Interop.ActorProperty.Actor_Property_LAYOUT_DIRECTION_get();
6080             internal static readonly int MARGIN = Interop.ViewProperty.View_Property_MARGIN_get();
6081             internal static readonly int PADDING = Interop.ViewProperty.View_Property_PADDING_get();
6082         }
6083     }
6084 }