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