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

   1 /*
   2  * Copyright(c) 2019 Samsung Electronics Co., Ltd.
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 using System.ComponentModel;
  19 using Tizen.NUI.Binding;
  20
  21 namespace Tizen.NUI.BaseComponents
  22 {
  23     /// <summary>
  24     /// View is the base class for all views.
  25     /// </summary>
  26     /// <since_tizen> 3 </since_tizen>
  27     public partial class View
  28     {
  29         /// <summary>
  30         /// StyleNameProperty
  31         /// </summary>
  32         [EditorBrowsable(EditorBrowsableState.Never)]
  33         public static readonly BindableProperty StyleNameProperty = BindableProperty.Create("StyleName", typeof(string), typeof(View), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
  34         {
  35             var view = (View)bindable;
  36             if (newValue != null)
  37             {
  38                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.STYLE_NAME, new Tizen.NUI.PropertyValue((string)newValue));
  39             }
  40         },
  41         defaultValueCreator: (bindable) =>
  42         {
  43             var view = (View)bindable;
  44             string temp;
  45             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.STYLE_NAME).Get(out temp);
  46             return temp;
  47         });
  48
  49         /// <summary>
  50         /// BackgroundColorProperty
  51         /// </summary>
  52         [EditorBrowsable(EditorBrowsableState.Never)]
  53         public static readonly BindableProperty BackgroundColorProperty = BindableProperty.Create("BackgroundColor", typeof(Color), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
  54         {
  55             var view = (View)bindable;
  56             if (newValue != null)
  57             {
  58                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((Color)newValue));
  59             }
  60         },
  61         defaultValueCreator: (bindable) =>
  62         {
  63             var view = (View)bindable;
  64             Color backgroundColor = new Color(0.0f, 0.0f, 0.0f, 0.0f);
  65
  66             Tizen.NUI.PropertyMap background = view.Background;
  67             int visualType = 0;
  68             background.Find(Visual.Property.Type)?.Get(out visualType);
  69             if (visualType == (int)Visual.Type.Color)
  70             {
  71                 background.Find(ColorVisualProperty.MixColor)?.Get(backgroundColor);
  72             }
  73
  74             return backgroundColor;
  75         });
  76
  77         /// <summary>
  78         /// BackgroundImageProperty
  79         /// </summary>
  80         [EditorBrowsable(EditorBrowsableState.Never)]
  81         public static readonly BindableProperty BackgroundImageProperty = BindableProperty.Create("BackgroundImage", typeof(string), typeof(View), default(string), propertyChanged: (bindable, oldValue, newValue) =>
  82         {
  83             var view = (View)bindable;
  84             if (newValue != null)
  85             {
  86                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((string)newValue));
  87                 view.BackgroundImageSynchronosLoading = view._backgroundImageSynchronosLoading;
  88             }
  89         },
  90         defaultValueCreator: (bindable) =>
  91         {
  92             var view = (View)bindable;
  93             string backgroundImage = "";
  94
  95             Tizen.NUI.PropertyMap background = view.Background;
  96             int visualType = 0;
  97             background.Find(Visual.Property.Type)?.Get(out visualType);
  98             if (visualType == (int)Visual.Type.Image)
  99             {
 100                 background.Find(ImageVisualProperty.URL)?.Get(out backgroundImage);
 101             }
 102
 103             return backgroundImage;
 104         });
 105
 106         /// <summary>
 107         /// BackgroundProperty
 108         /// </summary>
 109         [EditorBrowsable(EditorBrowsableState.Never)]
 110         public static readonly BindableProperty BackgroundProperty = BindableProperty.Create("Background", typeof(PropertyMap), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 111         {
 112             var view = (View)bindable;
 113             if (newValue != null)
 114             {
 115                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.BACKGROUND, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 116             }
 117         },
 118         defaultValueCreator: (bindable) =>
 119         {
 120             var view = (View)bindable;
 121             Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 122             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.BACKGROUND).Get(temp);
 123             return temp;
 124         });
 125
 126         /// <summary>
 127         /// StateProperty
 128         /// </summary>
 129         [EditorBrowsable(EditorBrowsableState.Never)]
 130         public static readonly BindableProperty StateProperty = BindableProperty.Create("State", typeof(States), typeof(View), States.Normal, propertyChanged: (bindable, oldValue, newValue) =>
 131         {
 132             var view = (View)bindable;
 133             if (newValue != null)
 134             {
 135                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.STATE, new Tizen.NUI.PropertyValue((int)newValue));
 136             }
 137         },
 138         defaultValueCreator: (bindable) =>
 139         {
 140             var view = (View)bindable;
 141             int temp = 0;
 142             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.STATE).Get(out temp) == false)
 143             {
 144                 NUILog.Error("State get error!");
 145             }
 146             switch (temp)
 147             {
 148                 case 0: return States.Normal;
 149                 case 1: return States.Focused;
 150                 case 2: return States.Disabled;
 151                 default: return States.Normal;
 152             }
 153         });
 154
 155         /// <summary>
 156         /// SubStateProperty
 157         /// </summary>
 158         [EditorBrowsable(EditorBrowsableState.Never)]
 159         public static readonly BindableProperty SubStateProperty = BindableProperty.Create("SubState", typeof(States), typeof(View), States.Normal, propertyChanged: (bindable, oldValue, newValue) =>
 160         {
 161             var view = (View)bindable;
 162             string valueToString = "";
 163             if (newValue != null)
 164             {
 165                 switch ((States)newValue)
 166                 {
 167                     case States.Normal: { valueToString = "NORMAL"; break; }
 168                     case States.Focused: { valueToString = "FOCUSED"; break; }
 169                     case States.Disabled: { valueToString = "DISABLED"; break; }
 170                     default: { valueToString = "NORMAL"; break; }
 171                 }
 172                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SUB_STATE, new Tizen.NUI.PropertyValue(valueToString));
 173             }
 174         },
 175         defaultValueCreator: (bindable) =>
 176         {
 177             var view = (View)bindable;
 178             string temp;
 179             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SUB_STATE).Get(out temp) == false)
 180             {
 181                 NUILog.Error("subState get error!");
 182             }
 183             switch (temp)
 184             {
 185                 case "NORMAL": return States.Normal;
 186                 case "FOCUSED": return States.Focused;
 187                 case "DISABLED": return States.Disabled;
 188                 default: return States.Normal;
 189             }
 190         });
 191
 192         /// <summary>
 193         /// TooltipProperty
 194         /// </summary>
 195         [EditorBrowsable(EditorBrowsableState.Never)]
 196         public static readonly BindableProperty TooltipProperty = BindableProperty.Create("Tooltip", typeof(PropertyMap), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 197         {
 198             var view = (View)bindable;
 199             if (newValue != null)
 200             {
 201                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.TOOLTIP, new Tizen.NUI.PropertyValue((PropertyMap)newValue));
 202             }
 203         },
 204         defaultValueCreator: (bindable) =>
 205         {
 206             var view = (View)bindable;
 207             Tizen.NUI.PropertyMap temp = new Tizen.NUI.PropertyMap();
 208             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.TOOLTIP).Get(temp);
 209             return temp;
 210         });
 211
 212         /// <summary>
 213         /// FlexProperty
 214         /// </summary>
 215         [EditorBrowsable(EditorBrowsableState.Never)]
 216         public static readonly BindableProperty FlexProperty = BindableProperty.Create("Flex", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 217         {
 218             var view = (View)bindable;
 219             if (newValue != null)
 220             {
 221                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX, new Tizen.NUI.PropertyValue((float)newValue));
 222             }
 223         },
 224         defaultValueCreator: (bindable) =>
 225         {
 226             var view = (View)bindable;
 227             float temp = 0.0f;
 228             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX).Get(out temp);
 229             return temp;
 230         });
 231
 232         /// <summary>
 233         /// AlignSelfProperty
 234         /// </summary>
 235         [EditorBrowsable(EditorBrowsableState.Never)]
 236         public static readonly BindableProperty AlignSelfProperty = BindableProperty.Create("AlignSelf", typeof(int), typeof(View), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 237         {
 238             var view = (View)bindable;
 239             if (newValue != null)
 240             {
 241                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.ALIGN_SELF, new Tizen.NUI.PropertyValue((int)newValue));
 242             }
 243         },
 244         defaultValueCreator: (bindable) =>
 245         {
 246             var view = (View)bindable;
 247             int temp = 0;
 248             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.ALIGN_SELF).Get(out temp);
 249             return temp;
 250         });
 251
 252         /// <summary>
 253         /// FlexMarginProperty
 254         /// </summary>
 255         [EditorBrowsable(EditorBrowsableState.Never)]
 256         public static readonly BindableProperty FlexMarginProperty = BindableProperty.Create("FlexMargin", typeof(Vector4), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 257         {
 258             var view = (View)bindable;
 259             if (newValue != null)
 260             {
 261                 Tizen.NUI.Object.SetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX_MARGIN, new Tizen.NUI.PropertyValue((Vector4)newValue));
 262             }
 263         },
 264         defaultValueCreator: (bindable) =>
 265         {
 266             var view = (View)bindable;
 267             Vector4 temp = new Vector4(0.0f, 0.0f, 0.0f, 0.0f);
 268             Tizen.NUI.Object.GetProperty(view.swigCPtr, FlexContainer.ChildProperty.FLEX_MARGIN).Get(temp);
 269             return temp;
 270         });
 271
 272         /// <summary>
 273         /// CellIndexProperty
 274         /// </summary>
 275         [EditorBrowsable(EditorBrowsableState.Never)]
 276         public static readonly BindableProperty CellIndexProperty = BindableProperty.Create("CellIndex", typeof(Vector2), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 277         {
 278             var view = (View)bindable;
 279             if (newValue != null)
 280             {
 281                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_INDEX, new Tizen.NUI.PropertyValue((Vector2)newValue));
 282             }
 283         },
 284         defaultValueCreator: (bindable) =>
 285         {
 286             var view = (View)bindable;
 287             Vector2 temp = new Vector2(0.0f, 0.0f);
 288             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_INDEX).Get(temp);
 289             return temp;
 290         });
 291
 292         /// <summary>
 293         /// RowSpanProperty
 294         /// </summary>
 295         [EditorBrowsable(EditorBrowsableState.Never)]
 296         public static readonly BindableProperty RowSpanProperty = BindableProperty.Create("RowSpan", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 297         {
 298             var view = (View)bindable;
 299             if (newValue != null)
 300             {
 301                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.ROW_SPAN, new Tizen.NUI.PropertyValue((float)newValue));
 302             }
 303         },
 304         defaultValueCreator: (bindable) =>
 305         {
 306             var view = (View)bindable;
 307             float temp = 0.0f;
 308             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.ROW_SPAN).Get(out temp);
 309             return temp;
 310         });
 311
 312         /// <summary>
 313         /// ColumnSpanProperty
 314         /// </summary>
 315         [EditorBrowsable(EditorBrowsableState.Never)]
 316         public static readonly BindableProperty ColumnSpanProperty = BindableProperty.Create("ColumnSpan", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 317         {
 318             var view = (View)bindable;
 319             if (newValue != null)
 320             {
 321                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.COLUMN_SPAN, new Tizen.NUI.PropertyValue((float)newValue));
 322             }
 323         },
 324         defaultValueCreator: (bindable) =>
 325         {
 326             var view = (View)bindable;
 327             float temp = 0.0f;
 328             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.COLUMN_SPAN).Get(out temp);
 329             return temp;
 330         });
 331
 332         /// <summary>
 333         /// CellHorizontalAlignmentProperty
 334         /// </summary>
 335         [EditorBrowsable(EditorBrowsableState.Never)]
 336         public static readonly BindableProperty CellHorizontalAlignmentProperty = BindableProperty.Create("CellHorizontalAlignment", typeof(HorizontalAlignmentType), typeof(View), HorizontalAlignmentType.Left, propertyChanged: (bindable, oldValue, newValue) =>
 337         {
 338             var view = (View)bindable;
 339             string valueToString = "";
 340
 341             if (newValue != null)
 342             {
 343                 switch ((HorizontalAlignmentType)newValue)
 344                 {
 345                     case Tizen.NUI.HorizontalAlignmentType.Left: { valueToString = "left"; break; }
 346                     case Tizen.NUI.HorizontalAlignmentType.Center: { valueToString = "center"; break; }
 347                     case Tizen.NUI.HorizontalAlignmentType.Right: { valueToString = "right"; break; }
 348                     default: { valueToString = "left"; break; }
 349                 }
 350                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 351             }
 352         },
 353         defaultValueCreator: (bindable) =>
 354         {
 355             var view = (View)bindable;
 356             string temp;
 357             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_HORIZONTAL_ALIGNMENT).Get(out temp) == false)
 358             {
 359                 NUILog.Error("CellHorizontalAlignment get error!");
 360             }
 361
 362             switch (temp)
 363             {
 364                 case "left": return Tizen.NUI.HorizontalAlignmentType.Left;
 365                 case "center": return Tizen.NUI.HorizontalAlignmentType.Center;
 366                 case "right": return Tizen.NUI.HorizontalAlignmentType.Right;
 367                 default: return Tizen.NUI.HorizontalAlignmentType.Left;
 368             }
 369         });
 370
 371         /// <summary>
 372         /// CellVerticalAlignmentProperty
 373         /// </summary>
 374         [EditorBrowsable(EditorBrowsableState.Never)]
 375         public static readonly BindableProperty CellVerticalAlignmentProperty = BindableProperty.Create("CellVerticalAlignment", typeof(VerticalAlignmentType), typeof(View), VerticalAlignmentType.Top, propertyChanged: (bindable, oldValue, newValue) =>
 376         {
 377             var view = (View)bindable;
 378             string valueToString = "";
 379
 380             if (newValue != null)
 381             {
 382                 switch ((VerticalAlignmentType)newValue)
 383                 {
 384                     case Tizen.NUI.VerticalAlignmentType.Top: { valueToString = "top"; break; }
 385                     case Tizen.NUI.VerticalAlignmentType.Center: { valueToString = "center"; break; }
 386                     case Tizen.NUI.VerticalAlignmentType.Bottom: { valueToString = "bottom"; break; }
 387                     default: { valueToString = "top"; break; }
 388                 }
 389                 Tizen.NUI.Object.SetProperty(view.swigCPtr, TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT, new Tizen.NUI.PropertyValue(valueToString));
 390             }
 391         },
 392         defaultValueCreator: (bindable) =>
 393         {
 394             var view = (View)bindable;
 395             string temp;
 396             Tizen.NUI.Object.GetProperty(view.swigCPtr, TableView.ChildProperty.CELL_VERTICAL_ALIGNMENT).Get(out temp);
 397             {
 398                 NUILog.Error("CellVerticalAlignment get error!");
 399             }
 400
 401             switch (temp)
 402             {
 403                 case "top": return Tizen.NUI.VerticalAlignmentType.Top;
 404                 case "center": return Tizen.NUI.VerticalAlignmentType.Center;
 405                 case "bottom": return Tizen.NUI.VerticalAlignmentType.Bottom;
 406                 default: return Tizen.NUI.VerticalAlignmentType.Top;
 407             }
 408         });
 409
 410         /// <summary>
 411         /// "Please DO NOT use! This will be deprecated! Please use 'View Weight' instead of BindableProperty"
 412         /// This needs to be hidden as inhouse API until all applications using it have been updated.  Do not make public.
 413         /// </summary>
 414         [EditorBrowsable(EditorBrowsableState.Never)]
 415         public static readonly BindableProperty WeightProperty = BindableProperty.Create("Weight", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 416         {
 417             var view = (View)bindable;
 418             if (newValue != null)
 419             {
 420                 view.Weight = (float)newValue;
 421             }
 422         },
 423
 424         defaultValueCreator: (bindable) =>
 425         {
 426             var view = (View)bindable;
 427             return view.Weight;
 428         });
 429
 430         /// <summary>
 431         /// LeftFocusableViewProperty
 432         /// </summary>
 433         [EditorBrowsable(EditorBrowsableState.Never)]
 434         public static readonly BindableProperty LeftFocusableViewProperty = BindableProperty.Create(nameof(View.LeftFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 435         {
 436             var view = (View)bindable;
 437             if (newValue != null) { view.LeftFocusableViewId = (int)(newValue as View)?.GetId(); }
 438             else { view.LeftFocusableViewId = -1; }
 439         },
 440         defaultValueCreator: (bindable) =>
 441         {
 442             var view = (View)bindable;
 443             if (view.LeftFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.LeftFocusableViewId); }
 444             return null;
 445         });
 446
 447         /// <summary>
 448         /// RightFocusableViewProperty
 449         /// </summary>
 450         [EditorBrowsable(EditorBrowsableState.Never)]
 451         public static readonly BindableProperty RightFocusableViewProperty = BindableProperty.Create(nameof(View.RightFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 452         {
 453             var view = (View)bindable;
 454             if (newValue != null) { view.RightFocusableViewId = (int)(newValue as View)?.GetId(); }
 455             else { view.RightFocusableViewId = -1; }
 456         },
 457         defaultValueCreator: (bindable) =>
 458         {
 459             var view = (View)bindable;
 460             if (view.RightFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.RightFocusableViewId); }
 461             return null;
 462         });
 463
 464         /// <summary>
 465         /// UpFocusableViewProperty
 466         /// </summary>
 467         [EditorBrowsable(EditorBrowsableState.Never)]
 468         public static readonly BindableProperty UpFocusableViewProperty = BindableProperty.Create(nameof(View.UpFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 469         {
 470             var view = (View)bindable;
 471             if (newValue != null) { view.UpFocusableViewId = (int)(newValue as View)?.GetId(); }
 472             else { view.UpFocusableViewId = -1; }
 473         },
 474         defaultValueCreator: (bindable) =>
 475         {
 476             var view = (View)bindable;
 477             if (view.UpFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.UpFocusableViewId); }
 478             return null;
 479         });
 480
 481         /// <summary>
 482         /// DownFocusableViewProperty
 483         /// </summary>
 484         [EditorBrowsable(EditorBrowsableState.Never)]
 485         public static readonly BindableProperty DownFocusableViewProperty = BindableProperty.Create(nameof(View.DownFocusableView), typeof(View), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 486         {
 487             var view = (View)bindable;
 488             if (newValue != null) { view.DownFocusableViewId = (int)(newValue as View)?.GetId(); }
 489             else { view.DownFocusableViewId = -1; }
 490         },
 491         defaultValueCreator: (bindable) =>
 492         {
 493             var view = (View)bindable;
 494             if (view.DownFocusableViewId >= 0) { return view.ConvertIdToView((uint)view.DownFocusableViewId); }
 495             return null;
 496         });
 497
 498         /// <summary>
 499         /// FocusableProperty
 500         /// </summary>
 501         [EditorBrowsable(EditorBrowsableState.Never)]
 502         public static readonly BindableProperty FocusableProperty = BindableProperty.Create("Focusable", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 503         {
 504             var view = (View)bindable;
 505             if (newValue != null) { view.SetKeyboardFocusable((bool)newValue); }
 506         },
 507         defaultValueCreator: (bindable) =>
 508         {
 509             var view = (View)bindable;
 510             return view.IsKeyboardFocusable();
 511         });
 512
 513         /// <summary>
 514         /// Size2DProperty
 515         /// </summary>
 516         [EditorBrowsable(EditorBrowsableState.Never)]
 517         public static readonly BindableProperty Size2DProperty = BindableProperty.Create("Size2D", typeof(Size2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 518         {
 519             var view = (View)bindable;
 520             if (newValue != null)
 521             {
 522                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE, new Tizen.NUI.PropertyValue(new Size((Size2D)newValue)));
 523             }
 524         },
 525         defaultValueCreator: (bindable) =>
 526         {
 527             var view = (View)bindable;
 528             Size temp = new Size(0.0f, 0.0f, 0.0f);
 529             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE).Get(temp);
 530             Size2D size = new Size2D((int)temp.Width, (int)temp.Height);
 531             return size;
 532         });
 533
 534         /// <summary>
 535         /// OpacityProperty
 536         /// </summary>
 537         [EditorBrowsable(EditorBrowsableState.Never)]
 538         public static readonly BindableProperty OpacityProperty = BindableProperty.Create("Opacity", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 539         {
 540             var view = (View)bindable;
 541             if (newValue != null)
 542             {
 543                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.OPACITY, new Tizen.NUI.PropertyValue((float)newValue));
 544             }
 545         },
 546         defaultValueCreator: (bindable) =>
 547         {
 548             var view = (View)bindable;
 549             float temp = 0.0f;
 550             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.OPACITY).Get(out temp);
 551             return temp;
 552         });
 553
 554         /// <summary>
 555         /// Position2DProperty
 556         /// </summary>
 557         [EditorBrowsable(EditorBrowsableState.Never)]
 558         public static readonly BindableProperty Position2DProperty = BindableProperty.Create("Position2D", typeof(Position2D), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 559         {
 560             var view = (View)bindable;
 561             if (newValue != null)
 562             {
 563                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION, new Tizen.NUI.PropertyValue(new Position((Position2D)newValue)));
 564             }
 565         },
 566         defaultValueCreator: (bindable) =>
 567         {
 568             var view = (View)bindable;
 569             Position temp = new Position(0.0f, 0.0f, 0.0f);
 570             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION).Get(temp);
 571             return new Position2D(temp);
 572         });
 573
 574         /// <summary>
 575         /// PositionUsesPivotPointProperty
 576         /// </summary>
 577         [EditorBrowsable(EditorBrowsableState.Never)]
 578         public static readonly BindableProperty PositionUsesPivotPointProperty = BindableProperty.Create("PositionUsesPivotPoint", typeof(bool), typeof(View), true, propertyChanged: (bindable, oldValue, newValue) =>
 579         {
 580             var view = (View)bindable;
 581             if (newValue != null)
 582             {
 583                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_USES_ANCHOR_POINT, new Tizen.NUI.PropertyValue((bool)newValue));
 584             }
 585         },
 586         defaultValueCreator: (bindable) =>
 587         {
 588             var view = (View)bindable;
 589             bool temp = false;
 590             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_USES_ANCHOR_POINT).Get(out temp);
 591             return temp;
 592         });
 593
 594         /// <summary>
 595         /// SiblingOrderProperty
 596         /// </summary>
 597         [EditorBrowsable(EditorBrowsableState.Never)]
 598         public static readonly BindableProperty SiblingOrderProperty = BindableProperty.Create("SiblingOrder", typeof(int), typeof(View), default(int), propertyChanged: (bindable, oldValue, newValue) =>
 599         {
 600             var view = (View)bindable;
 601             int value;
 602             if (newValue != null)
 603             {
 604                 value = (int)newValue;
 605                 if (value < 0)
 606                 {
 607                     NUILog.Error("SiblingOrder should be bigger than 0 or equal to 0.");
 608                     return;
 609                 }
 610                 var siblings = view.GetParent()?.Children;
 611                 if (siblings != null)
 612                 {
 613                     int currentOrder = siblings.IndexOf(view);
 614                     if (value != currentOrder)
 615                     {
 616                         if (value == 0) { view.LowerToBottom(); }
 617                         else if (value < siblings.Count - 1)
 618                         {
 619                             if (value > currentOrder) { view.RaiseAbove(siblings[value]); }
 620                             else { view.LowerBelow(siblings[value]); }
 621                         }
 622                         else { view.RaiseToTop(); }
 623                     }
 624                 }
 625             }
 626         },
 627         defaultValueCreator: (bindable) =>
 628         {
 629             var view = (View)bindable;
 630             var parentChildren = view.GetParent()?.Children;
 631             int currentOrder = 0;
 632             if (parentChildren != null)
 633             {
 634                 currentOrder = parentChildren.IndexOf(view);
 635
 636                 if (currentOrder < 0) { return 0; }
 637                 else if (currentOrder < parentChildren.Count) { return currentOrder; }
 638             }
 639
 640             return 0;
 641         });
 642
 643         /// <summary>
 644         /// ParentOriginProperty
 645         /// </summary>
 646         [EditorBrowsable(EditorBrowsableState.Never)]
 647         public static readonly BindableProperty ParentOriginProperty = BindableProperty.Create("ParentOrigin", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 648         {
 649             var view = (View)bindable;
 650             if (newValue != null)
 651             {
 652                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.PARENT_ORIGIN, new Tizen.NUI.PropertyValue((Position)newValue));
 653             }
 654         },
 655         defaultValueCreator: (bindable) =>
 656         {
 657             var view = (View)bindable;
 658             Position temp = new Position(0.0f, 0.0f, 0.0f);
 659             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.PARENT_ORIGIN).Get(temp);
 660             return temp;
 661         }
 662         );
 663
 664         /// <summary>
 665         /// PivotPointProperty
 666         /// </summary>
 667         [EditorBrowsable(EditorBrowsableState.Never)]
 668         public static readonly BindableProperty PivotPointProperty = BindableProperty.Create("PivotPoint", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 669         {
 670             var view = (View)bindable;
 671             if (newValue != null)
 672             {
 673                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.ANCHOR_POINT, new Tizen.NUI.PropertyValue((Position)newValue));
 674             }
 675         },
 676         defaultValueCreator: (bindable) =>
 677         {
 678             var view = (View)bindable;
 679             Position temp = new Position(0.0f, 0.0f, 0.0f);
 680             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.ANCHOR_POINT).Get(temp);
 681             return temp;
 682         });
 683
 684         /// <summary>
 685         /// SizeWidthProperty
 686         /// </summary>
 687         [EditorBrowsable(EditorBrowsableState.Never)]
 688         public static readonly BindableProperty SizeWidthProperty = BindableProperty.Create("SizeWidth", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 689         {
 690             var view = (View)bindable;
 691             if (newValue != null)
 692             {
 693                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_WIDTH, new Tizen.NUI.PropertyValue((float)newValue));
 694             }
 695         },
 696         defaultValueCreator: (bindable) =>
 697         {
 698             var view = (View)bindable;
 699             float temp = 0.0f;
 700             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_WIDTH).Get(out temp);
 701             return temp;
 702         });
 703
 704         /// <summary>
 705         /// SizeHeightProperty
 706         /// </summary>
 707         [EditorBrowsable(EditorBrowsableState.Never)]
 708         public static readonly BindableProperty SizeHeightProperty = BindableProperty.Create("SizeHeight", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 709         {
 710             var view = (View)bindable;
 711             if (newValue != null)
 712             {
 713                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_HEIGHT, new Tizen.NUI.PropertyValue((float)newValue));
 714             }
 715         },
 716         defaultValueCreator: (bindable) =>
 717         {
 718             var view = (View)bindable;
 719             float temp = 0.0f;
 720             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_HEIGHT).Get(out temp);
 721             return temp;
 722         });
 723
 724         /// <summary>
 725         /// PositionProperty
 726         /// </summary>
 727         [EditorBrowsable(EditorBrowsableState.Never)]
 728         public static readonly BindableProperty PositionProperty = BindableProperty.Create("Position", typeof(Position), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 729         {
 730             var view = (View)bindable;
 731             if (newValue != null)
 732             {
 733                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION, new Tizen.NUI.PropertyValue((Position)newValue));
 734             }
 735         },
 736         defaultValueCreator: (bindable) =>
 737         {
 738             var view = (View)bindable;
 739             Position temp = new Position(0.0f, 0.0f, 0.0f);
 740             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION).Get(temp);
 741             return temp;
 742         });
 743
 744         /// <summary>
 745         /// PositionXProperty
 746         /// </summary>
 747         [EditorBrowsable(EditorBrowsableState.Never)]
 748         public static readonly BindableProperty PositionXProperty = BindableProperty.Create("PositionX", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 749         {
 750             var view = (View)bindable;
 751             if (newValue != null)
 752             {
 753                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_X, new Tizen.NUI.PropertyValue((float)newValue));
 754             }
 755         },
 756         defaultValueCreator: (bindable) =>
 757         {
 758             var view = (View)bindable;
 759             float temp = 0.0f;
 760             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_X).Get(out temp);
 761             return temp;
 762         });
 763
 764         /// <summary>
 765         /// PositionYProperty
 766         /// </summary>
 767         [EditorBrowsable(EditorBrowsableState.Never)]
 768         public static readonly BindableProperty PositionYProperty = BindableProperty.Create("PositionY", 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.POSITION_Y, new Tizen.NUI.PropertyValue((float)newValue));
 774             }
 775         },
 776         defaultValueCreator: (bindable) =>
 777         {
 778             var view = (View)bindable;
 779             float temp = 0.0f;
 780             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_Y).Get(out temp);
 781             return temp;
 782         });
 783
 784         /// <summary>
 785         /// PositionZProperty
 786         /// </summary>
 787         [EditorBrowsable(EditorBrowsableState.Never)]
 788         public static readonly BindableProperty PositionZProperty = BindableProperty.Create("PositionZ", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 789         {
 790             var view = (View)bindable;
 791             if (newValue != null)
 792             {
 793                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.POSITION_Z, new Tizen.NUI.PropertyValue((float)newValue));
 794             }
 795         },
 796         defaultValueCreator: (bindable) =>
 797         {
 798             var view = (View)bindable;
 799             float temp = 0.0f;
 800             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.POSITION_Z).Get(out temp);
 801             return temp;
 802         });
 803
 804         /// <summary>
 805         /// OrientationProperty
 806         /// </summary>
 807         [EditorBrowsable(EditorBrowsableState.Never)]
 808         public static readonly BindableProperty OrientationProperty = BindableProperty.Create("Orientation", typeof(Rotation), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 809         {
 810             var view = (View)bindable;
 811             if (newValue != null)
 812             {
 813                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.ORIENTATION, new Tizen.NUI.PropertyValue((Rotation)newValue));
 814             }
 815         },
 816         defaultValueCreator: (bindable) =>
 817         {
 818             var view = (View)bindable;
 819             Rotation temp = new Rotation();
 820             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.ORIENTATION).Get(temp);
 821             return temp;
 822         });
 823
 824         /// <summary>
 825         /// ScaleProperty
 826         /// </summary>
 827         [EditorBrowsable(EditorBrowsableState.Never)]
 828         public static readonly BindableProperty ScaleProperty = BindableProperty.Create("Scale", typeof(Vector3), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
 829         {
 830             var view = (View)bindable;
 831             if (newValue != null)
 832             {
 833                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE, new Tizen.NUI.PropertyValue((Vector3)newValue));
 834             }
 835         },
 836         defaultValueCreator: (bindable) =>
 837         {
 838             var view = (View)bindable;
 839             Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
 840             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE).Get(temp);
 841             return temp;
 842         });
 843
 844         /// <summary>
 845         /// ScaleXProperty
 846         /// </summary>
 847         [EditorBrowsable(EditorBrowsableState.Never)]
 848         public static readonly BindableProperty ScaleXProperty = BindableProperty.Create("ScaleX", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 849         {
 850             var view = (View)bindable;
 851             if (newValue != null)
 852             {
 853                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_X, new Tizen.NUI.PropertyValue((float)newValue));
 854             }
 855         },
 856         defaultValueCreator: (bindable) =>
 857         {
 858             var view = (View)bindable;
 859             float temp = 0.0f;
 860             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_X).Get(out temp);
 861             return temp;
 862         });
 863
 864         /// <summary>
 865         /// ScaleYProperty
 866         /// </summary>
 867         [EditorBrowsable(EditorBrowsableState.Never)]
 868         public static readonly BindableProperty ScaleYProperty = BindableProperty.Create("ScaleY", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 869         {
 870             var view = (View)bindable;
 871             if (newValue != null)
 872             {
 873                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_Y, new Tizen.NUI.PropertyValue((float)newValue));
 874             }
 875         },
 876         defaultValueCreator: (bindable) =>
 877         {
 878             var view = (View)bindable;
 879             float temp = 0.0f;
 880             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_Y).Get(out temp);
 881             return temp;
 882         });
 883
 884         /// <summary>
 885         /// ScaleZProperty
 886         /// </summary>
 887         [EditorBrowsable(EditorBrowsableState.Never)]
 888         public static readonly BindableProperty ScaleZProperty = BindableProperty.Create("ScaleZ", typeof(float), typeof(View), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 889         {
 890             var view = (View)bindable;
 891             if (newValue != null)
 892             {
 893                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SCALE_Z, new Tizen.NUI.PropertyValue((float)newValue));
 894             }
 895         },
 896         defaultValueCreator: (bindable) =>
 897         {
 898             var view = (View)bindable;
 899             float temp = 0.0f;
 900             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SCALE_Z).Get(out temp);
 901             return temp;
 902         });
 903
 904         /// <summary>
 905         /// NameProperty
 906         /// </summary>
 907         [EditorBrowsable(EditorBrowsableState.Never)]
 908         public static readonly BindableProperty NameProperty = BindableProperty.Create("Name", typeof(string), typeof(View), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
 909         {
 910             var view = (View)bindable;
 911             if (newValue != null)
 912             {
 913                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.NAME, new Tizen.NUI.PropertyValue((string)newValue));
 914             }
 915         },
 916         defaultValueCreator: (bindable) =>
 917         {
 918             var view = (View)bindable;
 919             string temp;
 920             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.NAME).Get(out temp);
 921             return temp;
 922         });
 923
 924         /// <summary>
 925         /// SensitiveProperty
 926         /// </summary>
 927         [EditorBrowsable(EditorBrowsableState.Never)]
 928         public static readonly BindableProperty SensitiveProperty = BindableProperty.Create("Sensitive", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 929         {
 930             var view = (View)bindable;
 931             if (newValue != null)
 932             {
 933                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SENSITIVE, new Tizen.NUI.PropertyValue((bool)newValue));
 934             }
 935         },
 936         defaultValueCreator: (bindable) =>
 937         {
 938             var view = (View)bindable;
 939             bool temp = false;
 940             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SENSITIVE).Get(out temp);
 941             return temp;
 942         });
 943
 944         /// <summary>
 945         /// LeaveRequiredProperty
 946         /// </summary>
 947         [EditorBrowsable(EditorBrowsableState.Never)]
 948         public static readonly BindableProperty LeaveRequiredProperty = BindableProperty.Create("LeaveRequired", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 949         {
 950             var view = (View)bindable;
 951             if (newValue != null)
 952             {
 953                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.LEAVE_REQUIRED, new Tizen.NUI.PropertyValue((bool)newValue));
 954             }
 955         },
 956         defaultValueCreator: (bindable) =>
 957         {
 958             var view = (View)bindable;
 959             bool temp = false;
 960             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.LEAVE_REQUIRED).Get(out temp);
 961             return temp;
 962         });
 963
 964         /// <summary>
 965         /// InheritOrientationProperty
 966         /// </summary>
 967         [EditorBrowsable(EditorBrowsableState.Never)]
 968         public static readonly BindableProperty InheritOrientationProperty = BindableProperty.Create("InheritOrientation", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 969         {
 970             var view = (View)bindable;
 971             if (newValue != null)
 972             {
 973                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_ORIENTATION, new Tizen.NUI.PropertyValue((bool)newValue));
 974             }
 975         },
 976         defaultValueCreator: (bindable) =>
 977         {
 978             var view = (View)bindable;
 979             bool temp = false;
 980             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_ORIENTATION).Get(out temp);
 981             return temp;
 982         });
 983
 984         /// <summary>
 985         /// InheritScaleProperty
 986         /// </summary>
 987         [EditorBrowsable(EditorBrowsableState.Never)]
 988         public static readonly BindableProperty InheritScaleProperty = BindableProperty.Create("InheritScale", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
 989         {
 990             var view = (View)bindable;
 991             if (newValue != null)
 992             {
 993                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_SCALE, new Tizen.NUI.PropertyValue((bool)newValue));
 994             }
 995         },
 996         defaultValueCreator: (bindable) =>
 997         {
 998             var view = (View)bindable;
 999             bool temp = false;
1000             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_SCALE).Get(out temp);
1001             return temp;
1002         });
1003
1004         /// <summary>
1005         /// DrawModeProperty
1006         /// </summary>
1007         [EditorBrowsable(EditorBrowsableState.Never)]
1008         public static readonly BindableProperty DrawModeProperty = BindableProperty.Create("DrawMode", typeof(DrawModeType), typeof(View), DrawModeType.Normal, propertyChanged: (bindable, oldValue, newValue) =>
1009         {
1010             var view = (View)bindable;
1011             if (newValue != null)
1012             {
1013                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.DRAW_MODE, new Tizen.NUI.PropertyValue((int)newValue));
1014             }
1015         },
1016         defaultValueCreator: (bindable) =>
1017         {
1018             var view = (View)bindable;
1019             string temp;
1020             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.DRAW_MODE).Get(out temp) == false)
1021             {
1022                 NUILog.Error("DrawMode get error!");
1023             }
1024             switch (temp)
1025             {
1026                 case "NORMAL": return DrawModeType.Normal;
1027                 case "OVERLAY_2D": return DrawModeType.Overlay2D;
1028 #pragma warning disable CS0618 // Disable deprecated warning as we do need to use the deprecated API here.
1029                 case "STENCIL": return DrawModeType.Stencil;
1030 #pragma warning restore CS0618
1031                 default: return DrawModeType.Normal;
1032             }
1033         });
1034
1035         /// <summary>
1036         /// SizeModeFactorProperty
1037         /// </summary>
1038         [EditorBrowsable(EditorBrowsableState.Never)]
1039         public static readonly BindableProperty SizeModeFactorProperty = BindableProperty.Create("SizeModeFactor", typeof(Vector3), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1040         {
1041             var view = (View)bindable;
1042             if (newValue != null)
1043             {
1044                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_MODE_FACTOR, new Tizen.NUI.PropertyValue((Vector3)newValue));
1045             }
1046         },
1047         defaultValueCreator: (bindable) =>
1048         {
1049             var view = (View)bindable;
1050             Vector3 temp = new Vector3(0.0f, 0.0f, 0.0f);
1051             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_MODE_FACTOR).Get(temp);
1052             return temp;
1053         });
1054
1055         /// <summary>
1056         /// WidthResizePolicyProperty
1057         /// </summary>
1058         [EditorBrowsable(EditorBrowsableState.Never)]
1059         public static readonly BindableProperty WidthResizePolicyProperty = BindableProperty.Create("WidthResizePolicy", typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed, propertyChanged: (bindable, oldValue, newValue) =>
1060         {
1061             var view = (View)bindable;
1062             if (newValue != null)
1063             {
1064                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.WIDTH_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)newValue));
1065             }
1066         },
1067         defaultValueCreator: (bindable) =>
1068         {
1069             var view = (View)bindable;
1070             string temp;
1071             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.WIDTH_RESIZE_POLICY).Get(out temp) == false)
1072             {
1073                 NUILog.Error("WidthResizePolicy get error!");
1074             }
1075             switch (temp)
1076             {
1077                 case "FIXED": return ResizePolicyType.Fixed;
1078                 case "USE_NATURAL_SIZE": return ResizePolicyType.UseNaturalSize;
1079                 case "FILL_TO_PARENT": return ResizePolicyType.FillToParent;
1080                 case "SIZE_RELATIVE_TO_PARENT": return ResizePolicyType.SizeRelativeToParent;
1081                 case "SIZE_FIXED_OFFSET_FROM_PARENT": return ResizePolicyType.SizeFixedOffsetFromParent;
1082                 case "FIT_TO_CHILDREN": return ResizePolicyType.FitToChildren;
1083                 case "DIMENSION_DEPENDENCY": return ResizePolicyType.DimensionDependency;
1084                 case "USE_ASSIGNED_SIZE": return ResizePolicyType.UseAssignedSize;
1085                 default: return ResizePolicyType.Fixed;
1086             }
1087         });
1088
1089         /// <summary>
1090         /// HeightResizePolicyProperty
1091         /// </summary>
1092         [EditorBrowsable(EditorBrowsableState.Never)]
1093         public static readonly BindableProperty HeightResizePolicyProperty = BindableProperty.Create("HeightResizePolicy", typeof(ResizePolicyType), typeof(View), ResizePolicyType.Fixed, propertyChanged: (bindable, oldValue, newValue) =>
1094         {
1095             var view = (View)bindable;
1096             if (newValue != null)
1097             {
1098                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.HEIGHT_RESIZE_POLICY, new Tizen.NUI.PropertyValue((int)newValue));
1099             }
1100         },
1101         defaultValueCreator: (bindable) =>
1102         {
1103             var view = (View)bindable;
1104             string temp;
1105             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.HEIGHT_RESIZE_POLICY).Get(out temp) == false)
1106             {
1107                 NUILog.Error("HeightResizePolicy get error!");
1108             }
1109             switch (temp)
1110             {
1111                 case "FIXED": return ResizePolicyType.Fixed;
1112                 case "USE_NATURAL_SIZE": return ResizePolicyType.UseNaturalSize;
1113                 case "FILL_TO_PARENT": return ResizePolicyType.FillToParent;
1114                 case "SIZE_RELATIVE_TO_PARENT": return ResizePolicyType.SizeRelativeToParent;
1115                 case "SIZE_FIXED_OFFSET_FROM_PARENT": return ResizePolicyType.SizeFixedOffsetFromParent;
1116                 case "FIT_TO_CHILDREN": return ResizePolicyType.FitToChildren;
1117                 case "DIMENSION_DEPENDENCY": return ResizePolicyType.DimensionDependency;
1118                 case "USE_ASSIGNED_SIZE": return ResizePolicyType.UseAssignedSize;
1119                 default: return ResizePolicyType.Fixed;
1120             }
1121         });
1122
1123         /// <summary>
1124         /// SizeScalePolicyProperty
1125         /// </summary>
1126         [EditorBrowsable(EditorBrowsableState.Never)]
1127         public static readonly BindableProperty SizeScalePolicyProperty = BindableProperty.Create("SizeScalePolicy", typeof(SizeScalePolicyType), typeof(View), SizeScalePolicyType.UseSizeSet, propertyChanged: (bindable, oldValue, newValue) =>
1128         {
1129             var view = (View)bindable;
1130             string valueToString = "";
1131             if (newValue != null)
1132             {
1133                 switch ((SizeScalePolicyType)newValue)
1134                 {
1135                     case SizeScalePolicyType.UseSizeSet: { valueToString = "USE_SIZE_SET"; break; }
1136                     case SizeScalePolicyType.FitWithAspectRatio: { valueToString = "FIT_WITH_ASPECT_RATIO"; break; }
1137                     case SizeScalePolicyType.FillWithAspectRatio: { valueToString = "FILL_WITH_ASPECT_RATIO"; break; }
1138                     default: { valueToString = "USE_SIZE_SET"; break; }
1139                 }
1140                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE_SCALE_POLICY, new Tizen.NUI.PropertyValue(valueToString));
1141             }
1142         },
1143         defaultValueCreator: (bindable) =>
1144         {
1145             var view = (View)bindable;
1146             string temp;
1147             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE_SCALE_POLICY).Get(out temp) == false)
1148             {
1149                 NUILog.Error("SizeScalePolicy get error!");
1150             }
1151             switch (temp)
1152             {
1153                 case "USE_SIZE_SET": return SizeScalePolicyType.UseSizeSet;
1154                 case "FIT_WITH_ASPECT_RATIO": return SizeScalePolicyType.FitWithAspectRatio;
1155                 case "FILL_WITH_ASPECT_RATIO": return SizeScalePolicyType.FillWithAspectRatio;
1156                 default: return SizeScalePolicyType.UseSizeSet;
1157             }
1158         });
1159
1160         /// <summary>
1161         /// WidthForHeightProperty
1162         /// </summary>
1163         [EditorBrowsable(EditorBrowsableState.Never)]
1164         public static readonly BindableProperty WidthForHeightProperty = BindableProperty.Create("WidthForHeight", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1165         {
1166             var view = (View)bindable;
1167             if (newValue != null)
1168             {
1169                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.WIDTH_FOR_HEIGHT, new Tizen.NUI.PropertyValue((bool)newValue));
1170             }
1171         },
1172         defaultValueCreator: (bindable) =>
1173         {
1174             var view = (View)bindable;
1175             bool temp = false;
1176             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.WIDTH_FOR_HEIGHT).Get(out temp);
1177             return temp;
1178         });
1179
1180         /// <summary>
1181         /// HeightForWidthProperty
1182         /// </summary>
1183         [EditorBrowsable(EditorBrowsableState.Never)]
1184         public static readonly BindableProperty HeightForWidthProperty = BindableProperty.Create("HeightForWidth", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1185         {
1186             var view = (View)bindable;
1187             if (newValue != null)
1188             {
1189                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.HEIGHT_FOR_WIDTH, new Tizen.NUI.PropertyValue((bool)newValue));
1190             }
1191         },
1192         defaultValueCreator: (bindable) =>
1193         {
1194             var view = (View)bindable;
1195             bool temp = false;
1196             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.HEIGHT_FOR_WIDTH).Get(out temp);
1197             return temp;
1198         });
1199
1200         /// <summary>
1201         /// PaddingProperty
1202         /// </summary>
1203         [EditorBrowsable(EditorBrowsableState.Never)]
1204         public static readonly BindableProperty PaddingProperty = BindableProperty.Create("Padding", typeof(Extents), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1205         {
1206             var view = (View)bindable;
1207             if (newValue != null)
1208             {
1209                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.PADDING, new Tizen.NUI.PropertyValue((Extents)newValue));
1210             }
1211         },
1212         defaultValueCreator: (bindable) =>
1213         {
1214             var view = (View)bindable;
1215             Extents temp = new Extents(0, 0, 0, 0);
1216             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.PADDING).Get(temp);
1217             return temp;
1218         });
1219
1220         /// <summary>
1221         /// SizeProperty
1222         /// </summary>
1223         [EditorBrowsable(EditorBrowsableState.Never)]
1224         public static readonly BindableProperty SizeProperty = BindableProperty.Create("Size", typeof(Size), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1225         {
1226             var view = (View)bindable;
1227             if (newValue != null)
1228             {
1229                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.SIZE, new Tizen.NUI.PropertyValue((Size)newValue));
1230             }
1231         },
1232         defaultValueCreator: (bindable) =>
1233         {
1234             var view = (View)bindable;
1235             Size temp = new Size(0, 0, 0);
1236             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.SIZE).Get(temp);
1237             return temp;
1238         });
1239
1240         /// <summary>
1241         /// MinimumSizeProperty
1242         /// </summary>
1243         [EditorBrowsable(EditorBrowsableState.Never)]
1244         public static readonly BindableProperty MinimumSizeProperty = BindableProperty.Create("MinimumSize", typeof(Size), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1245         {
1246             var view = (View)bindable;
1247             Size temp = (Size)newValue;
1248             if (temp != null)
1249             {
1250                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MINIMUM_SIZE, new Tizen.NUI.PropertyValue(new Vector2(temp.Width, temp.Height)));
1251             }
1252         },
1253         defaultValueCreator: (bindable) =>
1254         {
1255             var view = (View)bindable;
1256             Size2D temp = new Size2D(0, 0);
1257             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MINIMUM_SIZE).Get(temp);
1258             return temp;
1259         });
1260
1261         /// <summary>
1262         /// MaximumSizeProperty
1263         /// </summary>
1264         [EditorBrowsable(EditorBrowsableState.Never)]
1265         public static readonly BindableProperty MaximumSizeProperty = BindableProperty.Create("MaximumSize", typeof(Size), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1266         {
1267             var view = (View)bindable;
1268             Size temp = (Size)newValue;
1269             if (temp != null)
1270             {
1271                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MAXIMUM_SIZE, new Tizen.NUI.PropertyValue(new Vector2(temp.Width, temp.Height)));
1272             }
1273         },
1274         defaultValueCreator: (bindable) =>
1275         {
1276             var view = (View)bindable;
1277             Size2D temp = new Size2D(0, 0);
1278             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MAXIMUM_SIZE).Get(temp);
1279             return temp;
1280         });
1281
1282         /// <summary>
1283         /// InheritPositionProperty
1284         /// </summary>
1285         [EditorBrowsable(EditorBrowsableState.Never)]
1286         public static readonly BindableProperty InheritPositionProperty = BindableProperty.Create("InheritPosition", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1287         {
1288             var view = (View)bindable;
1289             if (newValue != null)
1290             {
1291                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_POSITION, new Tizen.NUI.PropertyValue((bool)newValue));
1292             }
1293         },
1294         defaultValueCreator: (bindable) =>
1295         {
1296             var view = (View)bindable;
1297             bool temp = false;
1298             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_POSITION).Get(out temp);
1299             return temp;
1300         });
1301
1302         /// <summary>
1303         /// ClippingModeProperty
1304         /// </summary>
1305         [EditorBrowsable(EditorBrowsableState.Never)]
1306         public static readonly BindableProperty ClippingModeProperty = BindableProperty.Create("ClippingMode", typeof(ClippingModeType), typeof(View), ClippingModeType.Disabled, propertyChanged: (bindable, oldValue, newValue) =>
1307         {
1308             var view = (View)bindable;
1309             if (newValue != null)
1310             {
1311                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.CLIPPING_MODE, new Tizen.NUI.PropertyValue((int)newValue));
1312             }
1313         },
1314         defaultValueCreator: (bindable) =>
1315         {
1316             var view = (View)bindable;
1317             int temp = 0;
1318             if (Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.CLIPPING_MODE).Get(out temp) == false)
1319             {
1320                 NUILog.Error("ClippingMode get error!");
1321             }
1322             return (ClippingModeType)temp;
1323         });
1324
1325         /// <summary>
1326         /// InheritLayoutDirectionProperty
1327         /// </summary>
1328         [EditorBrowsable(EditorBrowsableState.Never)]
1329         public static readonly BindableProperty InheritLayoutDirectionProperty = BindableProperty.Create("InheritLayoutDirection", typeof(bool), typeof(View), false, propertyChanged: (bindable, oldValue, newValue) =>
1330         {
1331             var view = (View)bindable;
1332             if (newValue != null)
1333             {
1334                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.INHERIT_LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((bool)newValue));
1335             }
1336         },
1337         defaultValueCreator: (bindable) =>
1338         {
1339             var view = (View)bindable;
1340             bool temp = false;
1341             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.INHERIT_LAYOUT_DIRECTION).Get(out temp);
1342             return temp;
1343         });
1344
1345         /// <summary>
1346         /// LayoutDirectionProperty
1347         /// </summary>
1348         [EditorBrowsable(EditorBrowsableState.Never)]
1349         public static readonly BindableProperty LayoutDirectionProperty = BindableProperty.Create("LayoutDirection", typeof(ViewLayoutDirectionType), typeof(View), ViewLayoutDirectionType.LTR, propertyChanged: (bindable, oldValue, newValue) =>
1350         {
1351             var view = (View)bindable;
1352             if (newValue != null)
1353             {
1354                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.LAYOUT_DIRECTION, new Tizen.NUI.PropertyValue((int)newValue));
1355             }
1356         },
1357         defaultValueCreator: (bindable) =>
1358         {
1359             var view = (View)bindable;
1360             int temp;
1361             if (false == Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.LAYOUT_DIRECTION).Get(out temp))
1362             {
1363                 NUILog.Error("LAYOUT_DIRECTION get error!");
1364             }
1365             return (ViewLayoutDirectionType)temp;
1366         });
1367
1368         /// <summary>
1369         /// MarginProperty
1370         /// </summary>
1371         [EditorBrowsable(EditorBrowsableState.Never)]
1372         public static readonly BindableProperty MarginProperty = BindableProperty.Create("Margin", typeof(Extents), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1373         {
1374             var view = (View)bindable;
1375             if (newValue != null)
1376             {
1377                 Tizen.NUI.Object.SetProperty(view.swigCPtr, View.Property.MARGIN, new Tizen.NUI.PropertyValue((Extents)newValue));
1378             }
1379         },
1380         defaultValueCreator: (bindable) =>
1381         {
1382             var view = (View)bindable;
1383             Extents temp = new Extents(0, 0, 0, 0);
1384             Tizen.NUI.Object.GetProperty(view.swigCPtr, View.Property.MARGIN).Get(temp);
1385             return temp;
1386         });
1387
1388         /// <summary>
1389         /// UpdateSizeHintProperty
1390         /// </summary>
1391         [EditorBrowsable(EditorBrowsableState.Never)]
1392         public static readonly BindableProperty UpdateSizeHintProperty = BindableProperty.Create("UpdateSizeHint", typeof(Vector2), typeof(View), null, propertyChanged: (bindable, oldValue, newValue) =>
1393         {
1394             var view = (View)bindable;
1395             if (newValue != null)
1396             {
1397                 Tizen.NUI.Object.SetProperty(view.swigCPtr, Interop.ViewProperty.View_Property_UPDATE_SIZE_HINT_get(), new Tizen.NUI.PropertyValue((Vector2)newValue));
1398             }
1399         },
1400         defaultValueCreator: (bindable) =>
1401         {
1402             var view = (View)bindable;
1403
1404             Vector2 temp = new Vector2(0.0f, 0.0f);
1405             Tizen.NUI.Object.GetProperty(view.swigCPtr, Interop.ViewProperty.View_Property_UPDATE_SIZE_HINT_get()).Get(temp);
1406             return temp;
1407         });
1408
1409         /// <summary>
1410         /// XamlStyleProperty
1411         /// </summary>
1412         [EditorBrowsable(EditorBrowsableState.Never)]
1413         public static readonly BindableProperty XamlStyleProperty = BindableProperty.Create("XamlStyle", typeof(Style), typeof(View), default(Style), propertyChanged: (bindable, oldvalue, newvalue) => ((View)bindable)._mergedStyle.Style = (Style)newvalue);
1414     }
1415 }