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