src/Tizen.NUI.Xaml/src/public/UIComponents/Button.cs

   1 /*
   2  * Copyright(c) 2017 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;
  21 using Tizen.NUI.XamlBinding;
  22 using static Tizen.NUI.UIComponents.Button;
  23
  24 namespace Tizen.NUI.Xaml.UIComponents
  25 {
  26     /// <summary>
  27     /// The Button class is a base class for different kinds of buttons.<br />
  28     /// This class provides the disabled property and the clicked signal.<br />
  29     /// The clicked event handler is emitted when the button is touched, and the touch point doesn't leave the boundary of the button.<br />
  30     /// When the disabled property is set to true, no signal is emitted.<br />
  31     /// The 'Visual' describes not just traditional images like PNG and BMP, but also refers to whatever is used to show the button. It could be a color, gradient, or some other kind of renderer.<br />
  32     /// The button's appearance can be modified by setting properties for the various visuals or images.<br />
  33     /// It is not mandatory to set all the visuals. A button could be defined only by setting its background visual, or by setting its background and selected visuals.<br />
  34     /// The button visual is shown over the background visual.<br />
  35     /// When pressed, the unselected visuals are replaced by the selected visuals.<br />
  36     /// The text label is always placed on the top of all images.<br />
  37     /// When the button is disabled, the background button and the selected visuals are replaced by their disabled visuals.<br />
  38     /// </summary>
  39     /// <since_tizen> 6 </since_tizen>
  40     /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  41     [EditorBrowsable(EditorBrowsableState.Never)]
  42     public class Button : Tizen.NUI.Xaml.Forms.BaseComponents.View
  43     {
  44         private Tizen.NUI.UIComponents.Button _button;
  45         internal Tizen.NUI.UIComponents.Button button
  46         {
  47             get
  48             {
  49                 if (null == _button)
  50                 {
  51                     _button = handleInstance as Tizen.NUI.UIComponents.Button;
  52                 }
  53
  54                 return _button;
  55             }
  56         }
  57
  58         /// <summary>
  59         /// Creates an uninitialized button.
  60         /// </summary>
  61         /// <since_tizen> 6 </since_tizen>
  62         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  63         [EditorBrowsable(EditorBrowsableState.Never)]
  64         public Button() : this(new Tizen.NUI.UIComponents.Button())
  65         {
  66         }
  67
  68         internal Button(Tizen.NUI.UIComponents.Button nuiInstance) : base(nuiInstance)
  69         {
  70             SetNUIInstance(nuiInstance);
  71         }
  72
  73         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  74         [EditorBrowsable(EditorBrowsableState.Never)]
  75         public static readonly BindableProperty UnselectedVisualProperty = BindableProperty.Create("UnselectedVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
  76         {
  77             var button = ((Button)bindable).button;
  78             button.UnselectedVisual = (PropertyMap)newValue;
  79         },
  80         defaultValueCreator: (bindable) =>
  81         {
  82             var button = ((Button)bindable).button;
  83             return button.UnselectedVisual;
  84         });
  85         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  86         [EditorBrowsable(EditorBrowsableState.Never)]
  87         public static readonly BindableProperty SelectedVisualProperty = BindableProperty.Create("SelectedVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
  88         {
  89             var button = ((Button)bindable).button;
  90             button.SelectedVisual = (PropertyMap)newValue;
  91         },
  92         defaultValueCreator: (bindable) =>
  93         {
  94             var button = ((Button)bindable).button;
  95             return button.SelectedVisual;
  96         });
  97         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  98         [EditorBrowsable(EditorBrowsableState.Never)]
  99         public static readonly BindableProperty DisabledSelectedVisualProperty = BindableProperty.Create("DisabledSelectedVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 100         {
 101             var button = ((Button)bindable).button;
 102             button.DisabledSelectedVisual = (PropertyMap)newValue;
 103         },
 104         defaultValueCreator: (bindable) =>
 105         {
 106             var button = ((Button)bindable).button;
 107             return button.DisabledSelectedVisual;
 108         });
 109         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 110         [EditorBrowsable(EditorBrowsableState.Never)]
 111         public static readonly BindableProperty DisabledUnselectedVisualProperty = BindableProperty.Create("DisabledUnselectedVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 112         {
 113             var button = ((Button)bindable).button;
 114             button.DisabledUnselectedVisual = (PropertyMap)newValue;
 115         },
 116         defaultValueCreator: (bindable) =>
 117         {
 118             var button = ((Button)bindable).button;
 119             return button.DisabledUnselectedVisual;
 120         });
 121         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 122         [EditorBrowsable(EditorBrowsableState.Never)]
 123         public static readonly BindableProperty UnselectedBackgroundVisualProperty = BindableProperty.Create("UnselectedBackgroundVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 124         {
 125             var button = ((Button)bindable).button;
 126             button.UnselectedBackgroundVisual = (PropertyMap)newValue;
 127         },
 128         defaultValueCreator: (bindable) =>
 129         {
 130             var button = ((Button)bindable).button;
 131             return button.UnselectedBackgroundVisual;
 132         });
 133         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 134         [EditorBrowsable(EditorBrowsableState.Never)]
 135         public static readonly BindableProperty SelectedBackgroundVisualProperty = BindableProperty.Create("SelectedBackgroundVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 136         {
 137             var button = ((Button)bindable).button;
 138             button.SelectedBackgroundVisual = (PropertyMap)newValue;
 139         },
 140         defaultValueCreator: (bindable) =>
 141         {
 142             var button = ((Button)bindable).button;
 143             return button.SelectedBackgroundVisual;
 144         });
 145         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 146         [EditorBrowsable(EditorBrowsableState.Never)]
 147         public static readonly BindableProperty DisabledUnselectedBackgroundVisualProperty = BindableProperty.Create("DisabledUnselectedBackgroundVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 148         {
 149             var button = ((Button)bindable).button;
 150             button.DisabledUnselectedBackgroundVisual = (PropertyMap)newValue;
 151         },
 152         defaultValueCreator: (bindable) =>
 153         {
 154             var button = ((Button)bindable).button;
 155             return button.DisabledUnselectedBackgroundVisual;
 156         });
 157         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 158         [EditorBrowsable(EditorBrowsableState.Never)]
 159         public static readonly BindableProperty DisabledSelectedBackgroundVisualProperty = BindableProperty.Create("DisabledSelectedBackgroundVisual", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 160         {
 161             var button = ((Button)bindable).button;
 162             button.DisabledSelectedBackgroundVisual = (PropertyMap)newValue;
 163         },
 164         defaultValueCreator: (bindable) =>
 165         {
 166             var button = ((Button)bindable).button;
 167             return button.DisabledSelectedBackgroundVisual;
 168         });
 169         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 170         [EditorBrowsable(EditorBrowsableState.Never)]
 171         public static readonly BindableProperty LabelRelativeAlignmentProperty = BindableProperty.Create("LabelRelativeAlignment", typeof(Align), typeof(Button), Align.End, propertyChanged: (bindable, oldValue, newValue) =>
 172         {
 173             var button = ((Button)bindable).button;
 174             button.LabelRelativeAlignment = (Align)newValue;
 175         },
 176         defaultValueCreator: (bindable) =>
 177         {
 178             var button = ((Button)bindable).button;
 179             return button.LabelRelativeAlignment;
 180         });
 181         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 182         [EditorBrowsable(EditorBrowsableState.Never)]
 183         public static readonly BindableProperty LabelPaddingProperty = BindableProperty.Create("LabelPadding", typeof(Vector4), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 184         {
 185             var button = ((Button)bindable).button;
 186             button.LabelPadding = (Vector4)newValue;
 187         },
 188         defaultValueCreator: (bindable) =>
 189         {
 190             var button = ((Button)bindable).button;
 191             return button.LabelPadding;
 192         });
 193         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 194         [EditorBrowsable(EditorBrowsableState.Never)]
 195         public static readonly BindableProperty ForegroundVisualPaddingProperty = BindableProperty.Create("ForegroundVisualPadding", typeof(Vector4), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 196         {
 197             var button = ((Button)bindable).button;
 198             button.ForegroundVisualPadding = (Vector4)newValue;
 199         },
 200         defaultValueCreator: (bindable) =>
 201         {
 202             var button = ((Button)bindable).button;
 203             return button.ForegroundVisualPadding;
 204         });
 205         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 206         [EditorBrowsable(EditorBrowsableState.Never)]
 207         public static readonly BindableProperty AutoRepeatingProperty = BindableProperty.Create("AutoRepeating", typeof(bool), typeof(Button), false, propertyChanged: (bindable, oldValue, newValue) =>
 208         {
 209             var button = ((Button)bindable).button;
 210             button.AutoRepeating = (bool)newValue;
 211         },
 212         defaultValueCreator: (bindable) =>
 213         {
 214             var button = ((Button)bindable).button;
 215             return button.AutoRepeating;
 216         });
 217         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 218         [EditorBrowsable(EditorBrowsableState.Never)]
 219         public static readonly BindableProperty InitialAutoRepeatingDelayProperty = BindableProperty.Create("InitialAutoRepeatingDelay", typeof(float), typeof(Button), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 220         {
 221             var button = ((Button)bindable).button;
 222             button.InitialAutoRepeatingDelay = (float)newValue;
 223         },
 224         defaultValueCreator: (bindable) =>
 225         {
 226             var button = ((Button)bindable).button;
 227             return button.InitialAutoRepeatingDelay;
 228         });
 229         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 230         [EditorBrowsable(EditorBrowsableState.Never)]
 231         public static readonly BindableProperty NextAutoRepeatingDelayProperty = BindableProperty.Create("NextAutoRepeatingDelay", typeof(float), typeof(Button), default(float), propertyChanged: (bindable, oldValue, newValue) =>
 232         {
 233             var button = ((Button)bindable).button;
 234             button.NextAutoRepeatingDelay = (float)newValue;
 235         },
 236         defaultValueCreator: (bindable) =>
 237         {
 238             var button = ((Button)bindable).button;
 239             return button.NextAutoRepeatingDelay;
 240         });
 241         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 242         [EditorBrowsable(EditorBrowsableState.Never)]
 243         public static readonly BindableProperty TogglableProperty = BindableProperty.Create("Togglable", typeof(bool), typeof(Button), false, propertyChanged: (bindable, oldValue, newValue) =>
 244         {
 245             var button = ((Button)bindable).button;
 246             button.Togglable = (bool)newValue;
 247         },
 248         defaultValueCreator: (bindable) =>
 249         {
 250             var button = ((Button)bindable).button;
 251             return button.Togglable;
 252         });
 253         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 254         [EditorBrowsable(EditorBrowsableState.Never)]
 255         public static readonly BindableProperty SelectedProperty = BindableProperty.Create("Selected", typeof(bool), typeof(Button), false, propertyChanged: (bindable, oldValue, newValue) =>
 256         {
 257             var button = ((Button)bindable).button;
 258             button.Selected = (bool)newValue;
 259         },
 260         defaultValueCreator: (bindable) =>
 261         {
 262             var button = ((Button)bindable).button;
 263             return button.Selected;
 264         });
 265         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 266         [EditorBrowsable(EditorBrowsableState.Never)]
 267         public static readonly BindableProperty UnselectedColorProperty = BindableProperty.Create("UnselectedColor", typeof(Color), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 268         {
 269             var button = ((Button)bindable).button;
 270             button.UnselectedColor = (Color)newValue;
 271         },
 272         defaultValueCreator: (bindable) =>
 273         {
 274             var button = ((Button)bindable).button;
 275             return button.UnselectedColor;
 276         });
 277         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 278         [EditorBrowsable(EditorBrowsableState.Never)]
 279         public static readonly BindableProperty SelectedColorProperty = BindableProperty.Create("SelectedColor", typeof(Color), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 280         {
 281             var button = ((Button)bindable).button;
 282             button.SelectedColor = (Color)newValue;
 283         },
 284         defaultValueCreator: (bindable) =>
 285         {
 286             var button = ((Button)bindable).button;
 287             return button.SelectedColor;
 288         });
 289         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 290         [EditorBrowsable(EditorBrowsableState.Never)]
 291         public static readonly BindableProperty LabelProperty = BindableProperty.Create("Label", typeof(PropertyMap), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 292         {
 293             var button = ((Button)bindable).button;
 294             button.Label = (PropertyMap)newValue;
 295         },
 296         defaultValueCreator: (bindable) =>
 297         {
 298             var button = ((Button)bindable).button;
 299             return button.Label;
 300         });
 301         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 302         [EditorBrowsable(EditorBrowsableState.Never)]
 303         public static readonly BindableProperty LabelTextProperty = BindableProperty.Create("LabelText", typeof(string), typeof(Button), string.Empty, propertyChanged: (bindable, oldValue, newValue) =>
 304         {
 305             var button = ((Button)bindable).button;
 306             button.LabelText = (string)newValue;
 307         },
 308         defaultValueCreator: (bindable) =>
 309         {
 310             var button = ((Button)bindable).button;
 311             return button.LabelText;
 312         });
 313
 314         /// <summary>
 315         /// The Clicked event will be triggered when the button is touched and the touch point doesn't leave the boundary of the button.
 316         /// </summary>
 317         /// <since_tizen> 6 </since_tizen>
 318         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 319         [EditorBrowsable(EditorBrowsableState.Never)]
 320         public event EventHandlerWithReturnType<object, EventArgs, bool> Clicked
 321         {
 322             add
 323             {
 324                 button.Clicked += value;
 325             }
 326
 327             remove
 328             {
 329                 button.Clicked -= value;
 330             }
 331         }
 332
 333         /// <summary>
 334         /// The Pressed event will be triggered when the button is touched.
 335         /// </summary>
 336         /// <since_tizen> 6 </since_tizen>
 337         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 338         [EditorBrowsable(EditorBrowsableState.Never)]
 339         public event EventHandlerWithReturnType<object, EventArgs, bool> Pressed
 340         {
 341             add
 342             {
 343                 button.Pressed += value;
 344             }
 345
 346             remove
 347             {
 348                 button.Pressed -= value;
 349             }
 350         }
 351
 352         /// <summary>
 353         /// The Released event will be triggered when the button is touched and the touch point leaves the boundary of the button.
 354         /// </summary>
 355         /// <since_tizen> 6 </since_tizen>
 356         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 357         [EditorBrowsable(EditorBrowsableState.Never)]
 358         public event EventHandlerWithReturnType<object, EventArgs, bool> Released
 359         {
 360             add
 361             {
 362                 button.Released += value;
 363             }
 364
 365             remove
 366             {
 367                 button.Released -= value;
 368             }
 369         }
 370
 371         /// <summary>
 372         /// The StateChanged event will be triggered when the button's state is changed.
 373         /// </summary>
 374         /// <since_tizen> 6 </since_tizen>
 375         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 376         [EditorBrowsable(EditorBrowsableState.Never)]
 377         public event EventHandlerWithReturnType<object, EventArgs, bool> StateChanged
 378         {
 379             add
 380             {
 381                 button.StateChanged += value;
 382             }
 383
 384             remove
 385             {
 386                 button.StateChanged -= value;
 387             }
 388         }
 389
 390         /// <summary>
 391         /// Gets or sets the unselected button foreground or icon visual.
 392         /// </summary>
 393         /// <since_tizen> 6 </since_tizen>
 394         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 395         [EditorBrowsable(EditorBrowsableState.Never)]
 396         public PropertyMap UnselectedVisual
 397         {
 398             get
 399             {
 400                 return (PropertyMap)GetValue(UnselectedVisualProperty);
 401             }
 402             set
 403             {
 404                 SetValue(UnselectedVisualProperty, value);
 405             }
 406         }
 407
 408         /// <summary>
 409         /// Gets or sets the selected button foreground or icon visual.
 410         /// </summary>
 411         /// <since_tizen> 6 </since_tizen>
 412         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 413         [EditorBrowsable(EditorBrowsableState.Never)]
 414         public PropertyMap SelectedVisual
 415         {
 416             get
 417             {
 418                 return (PropertyMap)GetValue(SelectedVisualProperty);
 419             }
 420             set
 421             {
 422                 SetValue(SelectedVisualProperty, value);
 423             }
 424         }
 425
 426         /// <summary>
 427         /// Gets or sets the disabled selected state foreground or icon button visual.
 428         /// </summary>
 429         /// <since_tizen> 6 </since_tizen>
 430         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 431         [EditorBrowsable(EditorBrowsableState.Never)]
 432         public PropertyMap DisabledSelectedVisual
 433         {
 434             get
 435             {
 436                 return (PropertyMap)GetValue(DisabledSelectedVisualProperty);
 437             }
 438             set
 439             {
 440                 SetValue(DisabledSelectedVisualProperty, value);
 441             }
 442         }
 443
 444         /// <summary>
 445         /// Gets or sets the disabled unselected state foreground or icon visual.
 446         /// </summary>
 447         /// <since_tizen> 6 </since_tizen>
 448         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 449         [EditorBrowsable(EditorBrowsableState.Never)]
 450         public PropertyMap DisabledUnselectedVisual
 451         {
 452             get
 453             {
 454                 return (PropertyMap)GetValue(DisabledUnselectedVisualProperty);
 455             }
 456             set
 457             {
 458                 SetValue(DisabledUnselectedVisualProperty, value);
 459             }
 460         }
 461
 462         /// <summary>
 463         /// Gets or sets the disabled unselected state background button visual.
 464         /// </summary>
 465         /// <since_tizen> 6 </since_tizen>
 466         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 467         [EditorBrowsable(EditorBrowsableState.Never)]
 468         public PropertyMap UnselectedBackgroundVisual
 469         {
 470             get
 471             {
 472                 return (PropertyMap)GetValue(UnselectedBackgroundVisualProperty);
 473             }
 474             set
 475             {
 476                 SetValue(UnselectedBackgroundVisualProperty, value);
 477             }
 478         }
 479
 480         /// <summary>
 481         /// Gets or sets the selected background button visual.
 482         /// </summary>
 483         /// <since_tizen> 6 </since_tizen>
 484         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 485         [EditorBrowsable(EditorBrowsableState.Never)]
 486         public PropertyMap SelectedBackgroundVisual
 487         {
 488             get
 489             {
 490                 return (PropertyMap)GetValue(SelectedBackgroundVisualProperty);
 491             }
 492             set
 493             {
 494                 SetValue(SelectedBackgroundVisualProperty, value);
 495             }
 496         }
 497
 498         /// <summary>
 499         /// Gets or sets the disabled while unselected background button visual.
 500         /// </summary>
 501         /// <since_tizen> 6 </since_tizen>
 502         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 503         [EditorBrowsable(EditorBrowsableState.Never)]
 504         public PropertyMap DisabledUnselectedBackgroundVisual
 505         {
 506             get
 507             {
 508                 return (PropertyMap)GetValue(DisabledUnselectedBackgroundVisualProperty);
 509             }
 510             set
 511             {
 512                 SetValue(DisabledUnselectedBackgroundVisualProperty, value);
 513             }
 514         }
 515
 516         /// <summary>
 517         /// Gets or sets the disabled while selected background button visual.
 518         /// </summary>
 519         /// <since_tizen> 6 </since_tizen>
 520         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 521         [EditorBrowsable(EditorBrowsableState.Never)]
 522         public PropertyMap DisabledSelectedBackgroundVisual
 523         {
 524             get
 525             {
 526                 return (PropertyMap)GetValue(DisabledSelectedBackgroundVisualProperty);
 527             }
 528             set
 529             {
 530                 SetValue(DisabledSelectedBackgroundVisualProperty, value);
 531             }
 532         }
 533
 534         /// <summary>
 535         /// Gets or sets the position of the the label in relation to the foreground or icon, if both present.
 536         /// </summary>
 537         /// <since_tizen> 6 </since_tizen>
 538         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 539         [EditorBrowsable(EditorBrowsableState.Never)]
 540         public Align LabelRelativeAlignment
 541         {
 542             get
 543             {
 544                 return (Align)GetValue(LabelRelativeAlignmentProperty);
 545             }
 546             set
 547             {
 548                 SetValue(LabelRelativeAlignmentProperty, value);
 549             }
 550         }
 551
 552         /// <summary>
 553         /// Gets or sets the padding around the text.
 554         /// </summary>
 555         /// <since_tizen> 6 </since_tizen>
 556         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 557         [EditorBrowsable(EditorBrowsableState.Never)]
 558         public Vector4 LabelPadding
 559         {
 560             get
 561             {
 562                 return (Vector4)GetValue(LabelPaddingProperty);
 563             }
 564             set
 565             {
 566                 SetValue(LabelPaddingProperty, value);
 567             }
 568         }
 569
 570         /// <summary>
 571         /// Gets or sets the padding around the foreground visual.
 572         /// </summary>
 573         /// <since_tizen> 6 </since_tizen>
 574         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 575         [EditorBrowsable(EditorBrowsableState.Never)]
 576         public Vector4 ForegroundVisualPadding
 577         {
 578             get
 579             {
 580                 return (Vector4)GetValue(ForegroundVisualPaddingProperty);
 581             }
 582             set
 583             {
 584                 SetValue(ForegroundVisualPaddingProperty, value);
 585             }
 586         }
 587
 588         /// <summary>
 589         /// If the autorepeating property is set to true, then the togglable property is set to false.
 590         /// </summary>
 591         /// <since_tizen> 6 </since_tizen>
 592         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 593         [EditorBrowsable(EditorBrowsableState.Never)]
 594         public bool AutoRepeating
 595         {
 596             get
 597             {
 598                 return (bool)GetValue(AutoRepeatingProperty);
 599             }
 600             set
 601             {
 602                 SetValue(AutoRepeatingProperty, value);
 603             }
 604         }
 605
 606         /// <summary>
 607         /// By default, this value is set to 0.15 seconds.
 608         /// </summary>
 609         /// <since_tizen> 6 </since_tizen>
 610         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 611         [EditorBrowsable(EditorBrowsableState.Never)]
 612         public float InitialAutoRepeatingDelay
 613         {
 614             get
 615             {
 616                 return (float)GetValue(InitialAutoRepeatingDelayProperty);
 617             }
 618             set
 619             {
 620                 SetValue(InitialAutoRepeatingDelayProperty, value);
 621             }
 622         }
 623
 624         /// <summary>
 625         /// By default, this value is set to 0.05 seconds.
 626         /// </summary>
 627         /// <since_tizen> 6 </since_tizen>
 628         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 629         [EditorBrowsable(EditorBrowsableState.Never)]
 630         public float NextAutoRepeatingDelay
 631         {
 632             get
 633             {
 634                 return (float)GetValue(NextAutoRepeatingDelayProperty);
 635             }
 636             set
 637             {
 638                 SetValue(NextAutoRepeatingDelayProperty, value);
 639             }
 640         }
 641
 642         /// <summary>
 643         /// If the togglable property is set to true, then the autorepeating property is set to false.
 644         /// </summary>
 645         /// <since_tizen> 6 </since_tizen>
 646         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 647         [EditorBrowsable(EditorBrowsableState.Never)]
 648         public bool Togglable
 649         {
 650             get
 651             {
 652                 return (bool)GetValue(TogglableProperty);
 653             }
 654             set
 655             {
 656                 SetValue(TogglableProperty, value);
 657             }
 658         }
 659
 660         /// <summary>
 661         /// Gets or sets the togglable button as either selected or unselected, togglable property must be set to true.
 662         /// </summary>
 663         /// <since_tizen> 6 </since_tizen>
 664         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 665         [EditorBrowsable(EditorBrowsableState.Never)]
 666         public bool Selected
 667         {
 668             get
 669             {
 670                 return (bool)GetValue(SelectedProperty);
 671             }
 672             set
 673             {
 674                 SetValue(SelectedProperty, value);
 675             }
 676         }
 677
 678         /// <summary>
 679         /// Gets or sets the unselected color.
 680         /// </summary>
 681         /// <since_tizen> 6 </since_tizen>
 682         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 683         [EditorBrowsable(EditorBrowsableState.Never)]
 684         public Color UnselectedColor
 685         {
 686             get
 687             {
 688                 return (Color)GetValue(UnselectedColorProperty);
 689             }
 690             set
 691             {
 692                 SetValue(UnselectedColorProperty, value);
 693             }
 694         }
 695
 696         /// <summary>
 697         /// Gets or sets the selected color.
 698         /// </summary>
 699         /// <since_tizen> 6 </since_tizen>
 700         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 701         [EditorBrowsable(EditorBrowsableState.Never)]
 702         public Color SelectedColor
 703         {
 704             get
 705             {
 706                 return (Color)GetValue(SelectedColorProperty);
 707             }
 708             set
 709             {
 710                 SetValue(SelectedColorProperty, value);
 711             }
 712         }
 713
 714         /// <summary>
 715         /// Gets or sets the label.
 716         /// </summary>
 717         /// <since_tizen> 6 </since_tizen>
 718         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 719         [EditorBrowsable(EditorBrowsableState.Never)]
 720         public PropertyMap Label
 721         {
 722             get
 723             {
 724                 return (PropertyMap)GetValue(LabelProperty);
 725             }
 726             set
 727             {
 728                 SetValue(LabelProperty, value);
 729             }
 730         }
 731
 732         /// <summary>
 733         /// Gets or sets the text of the label.
 734         /// </summary>
 735         /// <since_tizen> 6 </since_tizen>
 736         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 737         [EditorBrowsable(EditorBrowsableState.Never)]
 738         public string LabelText
 739         {
 740             get
 741             {
 742                 return (string)GetValue(LabelTextProperty);
 743             }
 744             set
 745             {
 746                 SetValue(LabelTextProperty, value);
 747             }
 748         }
 749     }
 750 }