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

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