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