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