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