src/Tizen.NUI.Components/Controls/Button.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 using System;
  18 using System.ComponentModel;
  19 using Tizen.NUI.BaseComponents;
  20 using Tizen.NUI.Binding;
  21
  22 namespace Tizen.NUI.Components
  23 {
  24     /// <summary>
  25     /// Button is one kind of common component, a button clearly describes what action will occur when the user selects it.
  26     /// Button may contain text or an icon.
  27     /// </summary>
  28     /// <since_tizen> 6 </since_tizen>
  29     public class Button : Control
  30     {
  31         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  32         [EditorBrowsable(EditorBrowsableState.Never)]
  33         public static readonly BindableProperty IconRelativeOrientationProperty = BindableProperty.Create(nameof(IconRelativeOrientation), typeof(IconOrientation?), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
  34         {
  35             var instance = (Button)bindable;
  36             if (newValue != null)
  37             {
  38                 instance.privateIconRelativeOrientation = (IconOrientation?)newValue;
  39             }
  40         },
  41         defaultValueCreator: (bindable) =>
  42         {
  43             var instance = (Button)bindable;
  44             return instance.privateIconRelativeOrientation;
  45         });
  46         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  47         [EditorBrowsable(EditorBrowsableState.Never)]
  48         public static readonly BindableProperty IsEnabledProperty = BindableProperty.Create(nameof(IsEnabled), typeof(bool), typeof(Button), true, propertyChanged: (bindable, oldValue, newValue) =>
  49         {
  50             var instance = (Button)bindable;
  51             if (newValue != null)
  52             {
  53                 instance.privateIsEnabled = (bool)newValue;
  54             }
  55         },
  56         defaultValueCreator: (bindable) =>
  57         {
  58             var instance = (Button)bindable;
  59             return instance.privateIsEnabled;
  60         });
  61         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  62         [EditorBrowsable(EditorBrowsableState.Never)]
  63         public static readonly BindableProperty IsSelectedProperty = BindableProperty.Create(nameof(IsSelected), typeof(bool), typeof(Button), true, propertyChanged: (bindable, oldValue, newValue) =>
  64         {
  65             var instance = (Button)bindable;
  66             if (newValue != null)
  67             {
  68                 instance.privateIsSelected = (bool)newValue;
  69             }
  70         },
  71         defaultValueCreator: (bindable) =>
  72         {
  73             var instance = (Button)bindable;
  74             return instance.privateIsSelected;
  75         });
  76         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  77         [EditorBrowsable(EditorBrowsableState.Never)]
  78         public static readonly BindableProperty IsSelectableProperty = BindableProperty.Create(nameof(IsSelectable), typeof(bool), typeof(Button), true, propertyChanged: (bindable, oldValue, newValue) =>
  79         {
  80             var instance = (Button)bindable;
  81             if (newValue != null)
  82             {
  83                 instance.privateIsSelectable = (bool)newValue;
  84             }
  85         },
  86         defaultValueCreator: (bindable) =>
  87         {
  88             var instance = (Button)bindable;
  89             return instance.privateIsSelectable;
  90         });
  91         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
  92         [EditorBrowsable(EditorBrowsableState.Never)]
  93         public static readonly BindableProperty IconPaddingProperty = BindableProperty.Create(nameof(IconPadding), typeof(Extents), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
  94         {
  95             var instance = (Button)bindable;
  96             if (null != newValue && null != instance.Style?.IconPadding)
  97             {
  98                 instance.Style.IconPadding.CopyFrom((Extents)newValue);
  99                 instance.UpdateUIContent();
 100             }
 101         },
 102         defaultValueCreator: (bindable) =>
 103         {
 104             var instance = (Button)bindable;
 105             return instance.Style?.IconPadding;
 106         });
 107         /// This will be public opened in tizen_6.0 after ACR done. Before ACR, need to be hidden as inhouse API.
 108         [EditorBrowsable(EditorBrowsableState.Never)]
 109         public static readonly BindableProperty TextPaddingProperty = BindableProperty.Create(nameof(TextPadding), typeof(Extents), typeof(Button), null, propertyChanged: (bindable, oldValue, newValue) =>
 110         {
 111             var instance = (Button)bindable;
 112             if (null != newValue && null != instance.Style?.TextPadding)
 113             {
 114                 instance.Style.TextPadding.CopyFrom((Extents)newValue);
 115                 instance.UpdateUIContent();
 116             }
 117         },
 118         defaultValueCreator: (bindable) =>
 119         {
 120             var instance = (Button)bindable;
 121             return instance.Style?.TextPadding;
 122         });
 123
 124         private ImageView overlayImage;
 125
 126         private TextLabel buttonText;
 127         private ImageView buttonIcon;
 128
 129         private EventHandler<StateChangedEventArgs> stateChangeHander;
 130
 131         private bool isSelected = false;
 132         private bool isEnabled = true;
 133         private bool isPressed = false;
 134
 135         static Button() { }
 136
 137         /// <summary>
 138         /// Creates a new instance of a Button.
 139         /// </summary>
 140         /// <since_tizen> 6 </since_tizen>
 141         public Button() : base()
 142         {
 143             Initialize();
 144         }
 145
 146         /// <summary>
 147         /// Creates a new instance of a Button with style.
 148         /// </summary>
 149         /// <param name="style">Create Button by special style defined in UX.</param>
 150         /// <since_tizen> 8 </since_tizen>
 151         public Button(string style) : base(style)
 152         {
 153             Initialize();
 154         }
 155
 156         /// <summary>
 157         /// Creates a new instance of a Button with style.
 158         /// </summary>
 159         /// <param name="buttonStyle">Create Button by style customized by user.</param>
 160         /// <since_tizen> 8 </since_tizen>
 161         public Button(ButtonStyle buttonStyle) : base(buttonStyle)
 162         {
 163             Initialize();
 164         }
 165
 166         /// <summary>
 167         /// An event for the button clicked signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 168         /// </summary>
 169         /// <since_tizen> 6 </since_tizen>
 170         public event EventHandler<ClickEventArgs> ClickEvent;
 171         /// <summary>
 172         /// An event for the button state changed signal which can be used to subscribe or unsubscribe the event handler provided by the user.<br />
 173         /// </summary>
 174         /// <since_tizen> 6 </since_tizen>
 175         public event EventHandler<StateChangedEventArgs> StateChangedEvent
 176         {
 177             add
 178             {
 179                 stateChangeHander += value;
 180             }
 181             remove
 182             {
 183                 stateChangeHander -= value;
 184             }
 185         }
 186         /// <summary>
 187         /// Icon orientation.
 188         /// </summary>
 189         /// <since_tizen> 6 </since_tizen>
 190         public enum IconOrientation
 191         {
 192             /// <summary>
 193             /// Top.
 194             /// </summary>
 195             /// <since_tizen> 6 </since_tizen>
 196             Top,
 197             /// <summary>
 198             /// Bottom.
 199             /// </summary>
 200             /// <since_tizen> 6 </since_tizen>
 201             Bottom,
 202             /// <summary>
 203             /// Left.
 204             /// </summary>
 205             /// <since_tizen> 6 </since_tizen>
 206             Left,
 207             /// <summary>
 208             /// Right.
 209             /// </summary>
 210             /// <since_tizen> 6 </since_tizen>
 211             Right,
 212         }
 213
 214         /// <summary>
 215         /// Style of the button.
 216         /// </summary>
 217         /// <since_tizen> 8 </since_tizen>
 218         public new ButtonStyle Style => ViewStyle as ButtonStyle;
 219
 220         /// <summary>
 221         /// The text of Button.
 222         /// </summary>
 223         /// <since_tizen> 6 </since_tizen>
 224         public string Text
 225         {
 226             get
 227             {
 228                 return Style?.Text?.Text?.GetValue(ControlState);
 229             }
 230             set
 231             {
 232                 if (null != Style?.Text)
 233                 {
 234                     Style.Text.Text = value;
 235                 }
 236             }
 237         }
 238
 239         /// <summary>
 240         /// Flag to decide Button can be selected or not.
 241         /// </summary>
 242         /// <since_tizen> 6 </since_tizen>
 243         public bool IsSelectable
 244         {
 245             get
 246             {
 247                 return (bool)GetValue(IsSelectableProperty);
 248             }
 249             set
 250             {
 251                 SetValue(IsSelectableProperty, value);
 252             }
 253         }
 254
 255         private bool privateIsSelectable
 256         {
 257             get
 258             {
 259                 return Style?.IsSelectable ?? false;
 260             }
 261             set
 262             {
 263                 Style.IsSelectable = value;
 264             }
 265         }
 266
 267         /// <summary>
 268         /// Translate text string in Button.
 269         /// </summary>
 270         /// <since_tizen> 6 </since_tizen>
 271         public string TranslatableText
 272         {
 273             get
 274             {
 275                 return Style?.Text?.TranslatableText?.All;
 276             }
 277             set
 278             {
 279                 if (null != Style?.Text)
 280                 {
 281                     Style.Text.TranslatableText = value;
 282                 }
 283             }
 284         }
 285
 286         /// <summary>
 287         /// Text point size in Button.
 288         /// </summary>
 289         /// <since_tizen> 6 </since_tizen>
 290         public float PointSize
 291         {
 292             get
 293             {
 294                 return Style?.Text?.PointSize?.All ?? 0;
 295             }
 296             set
 297             {
 298                 if (null != Style?.Text)
 299                 {
 300                     Style.Text.PointSize = value;
 301                 }
 302             }
 303         }
 304
 305         /// <summary>
 306         /// Text font family in Button.
 307         /// </summary>
 308         /// <since_tizen> 6 </since_tizen>
 309         public string FontFamily
 310         {
 311             get
 312             {
 313                 return Style?.Text?.FontFamily.All;
 314             }
 315             set
 316             {
 317                 if (null != Style?.Text)
 318                 {
 319                     Style.Text.FontFamily = value;
 320                 }
 321             }
 322         }
 323         /// <summary>
 324         /// Text color in Button.
 325         /// </summary>
 326         /// <since_tizen> 6 </since_tizen>
 327         public Color TextColor
 328         {
 329             get
 330             {
 331                 return Style?.Text?.TextColor?.All;
 332             }
 333             set
 334             {
 335                 if (null != Style?.Text)
 336                 {
 337                     Style.Text.TextColor = value;
 338                 }
 339             }
 340         }
 341         /// <summary>
 342         /// Text horizontal alignment in Button.
 343         /// </summary>
 344         /// <since_tizen> 6 </since_tizen>
 345         public HorizontalAlignment TextAlignment
 346         {
 347             get
 348             {
 349                 return Style?.Text?.HorizontalAlignment ?? HorizontalAlignment.Center;
 350             }
 351             set
 352             {
 353                 if (null != Style?.Text)
 354                 {
 355                     Style.Text.HorizontalAlignment = value;
 356                 }
 357             }
 358         }
 359         /// <summary>
 360         /// Icon image's resource url in Button.
 361         /// </summary>
 362         /// <since_tizen> 6 </since_tizen>
 363         public string IconURL
 364         {
 365             get
 366             {
 367                 return Style?.Icon?.ResourceUrl?.All;
 368             }
 369             set
 370             {
 371                 if (null != Style?.Icon)
 372                 {
 373                     Style.Icon.ResourceUrl = value;
 374                 }
 375             }
 376         }
 377
 378         private StringSelector textSelector = new StringSelector();
 379         /// <summary>
 380         /// Text string selector in Button.
 381         /// </summary>
 382         /// <since_tizen> 6 </since_tizen>
 383         public StringSelector TextSelector
 384         {
 385             get
 386             {
 387                 return textSelector;
 388             }
 389             set
 390             {
 391                 textSelector.Clone(value);
 392             }
 393         }
 394
 395         private StringSelector translatableTextSelector = new StringSelector();
 396         /// <summary>
 397         /// Translateable text string selector in Button.
 398         /// </summary>
 399         /// <since_tizen> 6 </since_tizen>
 400         public StringSelector TranslatableTextSelector
 401         {
 402             get
 403             {
 404                 return translatableTextSelector;
 405             }
 406             set
 407             {
 408                 translatableTextSelector.Clone(value);
 409             }
 410         }
 411
 412         private ColorSelector textColorSelector = new ColorSelector();
 413         /// <summary>
 414         /// Text color selector in Button.
 415         /// </summary>
 416         /// <since_tizen> 6 </since_tizen>
 417         public ColorSelector TextColorSelector
 418         {
 419             get
 420             {
 421                 return textColorSelector;
 422             }
 423             set
 424             {
 425                 textColorSelector.Clone(value);
 426             }
 427         }
 428
 429         private FloatSelector pointSizeSelector = new FloatSelector();
 430         /// <summary>
 431         /// Text font size selector in Button.
 432         /// </summary>
 433         /// <since_tizen> 6 </since_tizen>
 434         public FloatSelector PointSizeSelector
 435         {
 436             get
 437             {
 438                 return pointSizeSelector;
 439             }
 440             set
 441             {
 442                 pointSizeSelector.Clone(value);
 443             }
 444         }
 445
 446         private StringSelector iconURLSelector = new StringSelector();
 447         /// <summary>
 448         /// Icon image's resource url selector in Button.
 449         /// </summary>
 450         /// <since_tizen> 6 </since_tizen>
 451         public StringSelector IconURLSelector
 452         {
 453             get
 454             {
 455                 return iconURLSelector;
 456             }
 457             set
 458             {
 459                 iconURLSelector.Clone(value);
 460             }
 461         }
 462
 463         /// <summary>
 464         /// Flag to decide selected state in Button.
 465         /// </summary>
 466         /// <since_tizen> 6 </since_tizen>
 467         public bool IsSelected
 468         {
 469             get
 470             {
 471                 return (bool)GetValue(IsSelectedProperty);
 472             }
 473             set
 474             {
 475                 SetValue(IsSelectedProperty, value);
 476             }
 477         }
 478         private bool privateIsSelected
 479         {
 480             get
 481             {
 482                 return isSelected;
 483             }
 484             set
 485             {
 486                 isSelected = value;
 487                 UpdateState();
 488             }
 489         }
 490         /// <summary>
 491         /// Flag to decide enable or disable in Button.
 492         /// </summary>
 493         /// <since_tizen> 6 </since_tizen>
 494         public bool IsEnabled
 495         {
 496             get
 497             {
 498                 return (bool)GetValue(IsEnabledProperty);
 499             }
 500             set
 501             {
 502                 SetValue(IsEnabledProperty, value);
 503             }
 504         }
 505         private bool privateIsEnabled
 506         {
 507             get
 508             {
 509                 return isEnabled;
 510             }
 511             set
 512             {
 513                 isEnabled = value;
 514                 UpdateState();
 515             }
 516         }
 517
 518         /// <summary>
 519         /// Icon relative orientation in Button, work only when show icon and text.
 520         /// </summary>
 521         /// <since_tizen> 6 </since_tizen>
 522         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 523         [EditorBrowsable(EditorBrowsableState.Never)]
 524         public IconOrientation? IconRelativeOrientation
 525         {
 526             get
 527             {
 528                 return (IconOrientation?)GetValue(IconRelativeOrientationProperty);
 529             }
 530             set
 531             {
 532                 SetValue(IconRelativeOrientationProperty, value);
 533             }
 534         }
 535         private IconOrientation? privateIconRelativeOrientation
 536         {
 537             get
 538             {
 539                 return Style?.IconRelativeOrientation;
 540             }
 541             set
 542             {
 543                 if(Style != null && Style.IconRelativeOrientation != value)
 544                 {
 545                     Style.IconRelativeOrientation = value;
 546                     UpdateUIContent();
 547                 }
 548             }
 549         }
 550
 551         /// <summary>
 552         /// Icon padding in Button, work only when show icon and text.
 553         /// </summary>
 554         /// <since_tizen> 6 </since_tizen>
 555         public Extents IconPadding
 556         {
 557             get => (Extents)GetValue(IconPaddingProperty);
 558             set => SetValue(IconPaddingProperty, value);
 559         }
 560
 561         /// <summary>
 562         /// Text padding in Button, work only when show icon and text.
 563         /// </summary>
 564         /// <since_tizen> 6 </since_tizen>
 565         public Extents TextPadding
 566         {
 567             get => (Extents) GetValue(TextPaddingProperty);
 568             set => SetValue(TextPaddingProperty, value);
 569         }
 570
 571         /// <summary>
 572         /// Dispose Button and all children on it.
 573         /// </summary>
 574         /// <param name="type">Dispose type.</param>
 575         /// <since_tizen> 6 </since_tizen>
 576         protected override void Dispose(DisposeTypes type)
 577         {
 578             if (disposed)
 579             {
 580                 return;
 581             }
 582
 583             if (type == DisposeTypes.Explicit)
 584             {
 585                 if (buttonIcon != null)
 586                 {
 587                     Utility.Dispose(buttonIcon);
 588                 }
 589                 if (buttonText != null)
 590                 {
 591                     Utility.Dispose(buttonText);
 592                 }
 593                 if (overlayImage != null)
 594                 {
 595                     Utility.Dispose(overlayImage);
 596                 }
 597             }
 598
 599             base.Dispose(type);
 600         }
 601         /// <summary>
 602         /// Called after a key event is received by the view that has had its focus set.
 603         /// </summary>
 604         /// <param name="key">The key event.</param>
 605         /// <returns>True if the key event should be consumed.</returns>
 606         /// <since_tizen> 6 </since_tizen>
 607         public override bool OnKey(Key key)
 608         {
 609             if (null == key) return false;
 610             if (key.State == Key.StateType.Down)
 611             {
 612                 if (key.KeyPressedName == "Return")
 613                 {
 614                     isPressed = true;
 615                     UpdateState();
 616                     if(isEnabled)
 617                     {
 618                         ClickEventArgs eventArgs = new ClickEventArgs();
 619                         OnClick(eventArgs);
 620                     }
 621                 }
 622             }
 623             else if (key.State == Key.StateType.Up)
 624             {
 625                 if (key.KeyPressedName == "Return")
 626                 {
 627                     isPressed = false;
 628                     if (Style.IsSelectable != null && Style.IsSelectable == true)
 629                     {
 630                         isSelected = !isSelected;
 631                     }
 632                     UpdateState();
 633                 }
 634             }
 635             return base.OnKey(key);
 636         }
 637
 638         /// <summary>
 639         /// Called when the control gain key input focus. Should be overridden by derived classes if they need to customize what happens when the focus is gained.
 640         /// </summary>
 641         /// <since_tizen> 6 </since_tizen>
 642         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 643         [EditorBrowsable(EditorBrowsableState.Never)]
 644         public override void OnFocusGained()
 645         {
 646             base.OnFocusGained();
 647             UpdateState();
 648         }
 649
 650         /// <summary>
 651         /// Called when the control loses key input focus. Should be overridden by derived classes if they need to customize what happens when the focus is lost.
 652         /// </summary>
 653         /// <since_tizen> 6 </since_tizen>
 654         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 655         [EditorBrowsable(EditorBrowsableState.Never)]
 656         public override void OnFocusLost()
 657         {
 658             base.OnFocusLost();
 659             UpdateState();
 660         }
 661
 662         /// <summary>
 663         /// Tap gesture event callback.
 664         /// </summary>
 665         /// <param name="source">Source which recieved touch event.</param>
 666         /// <param name="e">Tap gesture event argument.</param>
 667         /// <since_tizen> 6 </since_tizen>
 668         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 669         [EditorBrowsable(EditorBrowsableState.Never)]
 670         protected override void OnTapGestureDetected(object source, TapGestureDetector.DetectedEventArgs e)
 671         {
 672             if (isEnabled)
 673             {
 674                 ClickEventArgs eventArgs = new ClickEventArgs();
 675                 OnClick(eventArgs);
 676                 base.OnTapGestureDetected(source, e);
 677             }
 678         }
 679         /// <summary>
 680         /// Called after a touch event is received by the owning view.<br />
 681         /// CustomViewBehaviour.REQUIRES_TOUCH_EVENTS must be enabled during construction. See CustomView(ViewWrapperImpl.CustomViewBehaviour behaviour).<br />
 682         /// </summary>
 683         /// <param name="touch">The touch event.</param>
 684         /// <returns>True if the event should be consumed.</returns>
 685         /// <since_tizen> 6 </since_tizen>
 686         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 687         [EditorBrowsable(EditorBrowsableState.Never)]
 688         public override bool OnTouch(Touch touch)
 689         {
 690             if (null == touch) return false;
 691             PointStateType state = touch.GetState(0);
 692
 693             switch(state)
 694             {
 695                 case PointStateType.Down:
 696                     isPressed = true;
 697                     UpdateState();
 698                     return true;
 699                 case PointStateType.Interrupted:
 700                     isPressed = false;
 701                     UpdateState();
 702                     return true;
 703                 case PointStateType.Up:
 704                     isPressed = false;
 705                     if (Style.IsSelectable != null && Style.IsSelectable == true)
 706                     {
 707                         isSelected = !isSelected;
 708                     }
 709                     UpdateState();
 710                     return true;
 711                 default:
 712                     break;
 713             }
 714             return base.OnTouch(touch);
 715         }
 716
 717         /// <summary>
 718         /// Apply style to button.
 719         /// </summary>
 720         /// <param name="viewStyle">The style to apply.</param>
 721         /// <since_tizen> 8 </since_tizen>
 722         public override void ApplyStyle(ViewStyle viewStyle)
 723         {
 724             base.ApplyStyle(viewStyle);
 725
 726             ButtonStyle buttonStyle = viewStyle as ButtonStyle;
 727
 728             if (null != buttonStyle)
 729             {
 730                 if (null == overlayImage)
 731                 {
 732                     overlayImage = new ImageView()
 733                     {
 734                         WidthResizePolicy = ResizePolicyType.FillToParent,
 735                         HeightResizePolicy = ResizePolicyType.FillToParent
 736                     };
 737                     this.Add(overlayImage);
 738                 }
 739
 740                 if (null == buttonText)
 741                 {
 742                     buttonText = new TextLabel();
 743                     this.Add(buttonText);
 744                 }
 745
 746                 if (null == buttonIcon)
 747                 {
 748                     buttonIcon = new ImageView();
 749                     this.Add(buttonIcon);
 750                 }
 751
 752                 overlayImage.ApplyStyle(buttonStyle.Overlay);
 753                 buttonText.ApplyStyle(buttonStyle.Text);
 754                 buttonIcon.ApplyStyle(buttonStyle.Icon);
 755             }
 756         }
 757
 758         /// <summary>
 759         /// Get Button style.
 760         /// </summary>
 761         /// <returns>The default button style.</returns>
 762         /// <since_tizen> 8 </since_tizen>
 763         protected override ViewStyle GetViewStyle()
 764         {
 765             return new ButtonStyle();
 766         }
 767
 768         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 769         [EditorBrowsable(EditorBrowsableState.Never)]
 770         protected override void OnUpdate()
 771         {
 772             base.OnUpdate();
 773             UpdateUIContent();
 774         }
 775
 776         /// <summary>
 777         /// Update Button State.
 778         /// </summary>
 779         /// <since_tizen> 6 </since_tizen>
 780         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 781         [EditorBrowsable(EditorBrowsableState.Never)]
 782         protected void UpdateState()
 783         {
 784             ControlStates sourceState = ControlState;
 785             ControlStates targetState;
 786
 787             if(isEnabled)
 788             {
 789                 targetState = isPressed ? ControlStates.Pressed : (IsFocused ? (IsSelected ? ControlStates.SelectedFocused : ControlStates.Focused) : (IsSelected ? ControlStates.Selected : ControlStates.Normal));
 790             }
 791             else
 792             {
 793                 targetState = IsSelected ? ControlStates.DisabledSelected : (IsFocused ? ControlStates.DisabledFocused : ControlStates.Disabled);
 794             }
 795
 796             if(sourceState != targetState)
 797             {
 798                 ControlState = targetState;
 799
 800                 OnUpdate();
 801
 802                 StateChangedEventArgs e = new StateChangedEventArgs
 803                 {
 804                     PreviousState = sourceState,
 805                     CurrentState = targetState
 806                 };
 807                 stateChangeHander?.Invoke(this, e);
 808             }
 809         }
 810
 811         /// <summary>
 812         /// It is hijack by using protected, style copy problem when class inherited from Button.
 813         /// </summary>
 814         /// <since_tizen> 6 </since_tizen>
 815         private void Initialize()
 816         {
 817             if (null == Style.IconRelativeOrientation) Style.IconRelativeOrientation = IconOrientation.Left;
 818             UpdateState();
 819             LayoutDirectionChanged += OnLayoutDirectionChanged;
 820         }
 821
 822         /// <summary>
 823         /// Measure text, it can be override.
 824         /// </summary>
 825         /// <since_tizen> 6 </since_tizen>
 826         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 827         [EditorBrowsable(EditorBrowsableState.Never)]
 828         protected virtual void MeasureText()
 829         {
 830             if (Style.IconRelativeOrientation == null || buttonIcon == null || buttonText == null)
 831             {
 832                 return;
 833             }
 834             buttonText.WidthResizePolicy = ResizePolicyType.Fixed;
 835             buttonText.HeightResizePolicy = ResizePolicyType.Fixed;
 836             int textPaddingStart = Style.TextPadding.Start;
 837             int textPaddingEnd = Style.TextPadding.End;
 838             int textPaddingTop = Style.TextPadding.Top;
 839             int textPaddingBottom = Style.TextPadding.Bottom;
 840
 841             int iconPaddingStart = Style.IconPadding.Start;
 842             int iconPaddingEnd = Style.IconPadding.End;
 843             int iconPaddingTop = Style.IconPadding.Top;
 844             int iconPaddingBottom = Style.IconPadding.Bottom;
 845
 846             if (IconRelativeOrientation == IconOrientation.Top || IconRelativeOrientation == IconOrientation.Bottom)
 847             {
 848                 buttonText.SizeWidth = SizeWidth - textPaddingStart - textPaddingEnd;
 849                 buttonText.SizeHeight = SizeHeight - textPaddingTop - textPaddingBottom - iconPaddingTop - iconPaddingBottom - buttonIcon.SizeHeight;
 850             }
 851             else
 852             {
 853                 buttonText.SizeWidth = SizeWidth - textPaddingStart - textPaddingEnd - iconPaddingStart - iconPaddingEnd - buttonIcon.SizeWidth;
 854                 buttonText.SizeHeight = SizeHeight - textPaddingTop - textPaddingBottom;
 855             }
 856         }
 857         /// <summary>
 858         /// Layout child, it can be override.
 859         /// </summary>
 860         /// <since_tizen> 6 </since_tizen>
 861         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 862         [EditorBrowsable(EditorBrowsableState.Never)]
 863         protected virtual void LayoutChild()
 864         {
 865             if (Style.IconRelativeOrientation == null || buttonIcon == null || buttonText == null)
 866             {
 867                 return;
 868             }
 869
 870             int textPaddingStart = Style.TextPadding.Start;
 871             int textPaddingEnd = Style.TextPadding.End;
 872             int textPaddingTop = Style.TextPadding.Top;
 873             int textPaddingBottom = Style.TextPadding.Bottom;
 874
 875             int iconPaddingStart = Style.IconPadding.Start;
 876             int iconPaddingEnd = Style.IconPadding.End;
 877             int iconPaddingTop = Style.IconPadding.Top;
 878             int iconPaddingBottom = Style.IconPadding.Bottom;
 879
 880             switch (IconRelativeOrientation)
 881             {
 882                 case IconOrientation.Top:
 883                     buttonIcon.PositionUsesPivotPoint = true;
 884                     buttonIcon.ParentOrigin = NUI.ParentOrigin.TopCenter;
 885                     buttonIcon.PivotPoint = NUI.PivotPoint.TopCenter;
 886                     buttonIcon.Position2D = new Position2D(0, iconPaddingTop);
 887
 888                     buttonText.PositionUsesPivotPoint = true;
 889                     buttonText.ParentOrigin = NUI.ParentOrigin.BottomCenter;
 890                     buttonText.PivotPoint = NUI.PivotPoint.BottomCenter;
 891                     buttonText.Position2D = new Position2D(0, -textPaddingBottom);
 892                     break;
 893                 case IconOrientation.Bottom:
 894                     buttonIcon.PositionUsesPivotPoint = true;
 895                     buttonIcon.ParentOrigin = NUI.ParentOrigin.BottomCenter;
 896                     buttonIcon.PivotPoint = NUI.PivotPoint.BottomCenter;
 897                     buttonIcon.Position2D = new Position2D(0, -iconPaddingBottom);
 898
 899                     buttonText.PositionUsesPivotPoint = true;
 900                     buttonText.ParentOrigin = NUI.ParentOrigin.TopCenter;
 901                     buttonText.PivotPoint = NUI.PivotPoint.TopCenter;
 902                     buttonText.Position2D = new Position2D(0, textPaddingTop);
 903                     break;
 904                 case IconOrientation.Left:
 905                     if (LayoutDirection == ViewLayoutDirectionType.LTR)
 906                     {
 907                         buttonIcon.PositionUsesPivotPoint = true;
 908                         buttonIcon.ParentOrigin = NUI.ParentOrigin.CenterLeft;
 909                         buttonIcon.PivotPoint = NUI.PivotPoint.CenterLeft;
 910                         buttonIcon.Position2D = new Position2D(iconPaddingStart, 0);
 911
 912                         buttonText.PositionUsesPivotPoint = true;
 913                         buttonText.ParentOrigin = NUI.ParentOrigin.CenterRight;
 914                         buttonText.PivotPoint = NUI.PivotPoint.CenterRight;
 915                         buttonText.Position2D = new Position2D(-textPaddingEnd, 0);
 916                     }
 917                     else
 918                     {
 919                         buttonIcon.PositionUsesPivotPoint = true;
 920                         buttonIcon.ParentOrigin = NUI.ParentOrigin.CenterRight;
 921                         buttonIcon.PivotPoint = NUI.PivotPoint.CenterRight;
 922                         buttonIcon.Position2D = new Position2D(-iconPaddingStart, 0);
 923
 924                         buttonText.PositionUsesPivotPoint = true;
 925                         buttonText.ParentOrigin = NUI.ParentOrigin.CenterLeft;
 926                         buttonText.PivotPoint = NUI.PivotPoint.CenterLeft;
 927                         buttonText.Position2D = new Position2D(textPaddingEnd, 0);
 928                     }
 929
 930                     break;
 931                 case IconOrientation.Right:
 932                     if (LayoutDirection == ViewLayoutDirectionType.RTL)
 933                     {
 934                         buttonIcon.PositionUsesPivotPoint = true;
 935                         buttonIcon.ParentOrigin = NUI.ParentOrigin.CenterLeft;
 936                         buttonIcon.PivotPoint = NUI.PivotPoint.CenterLeft;
 937                         buttonIcon.Position2D = new Position2D(iconPaddingEnd, 0);
 938
 939                         buttonText.PositionUsesPivotPoint = true;
 940                         buttonText.ParentOrigin = NUI.ParentOrigin.CenterRight;
 941                         buttonText.PivotPoint = NUI.PivotPoint.CenterRight;
 942                         buttonText.Position2D = new Position2D(-textPaddingStart, 0);
 943                     }
 944                     else
 945                     {
 946                         buttonIcon.PositionUsesPivotPoint = true;
 947                         buttonIcon.ParentOrigin = NUI.ParentOrigin.CenterRight;
 948                         buttonIcon.PivotPoint = NUI.PivotPoint.CenterRight;
 949                         buttonIcon.Position2D = new Position2D(-iconPaddingEnd, 0);
 950
 951                         buttonText.PositionUsesPivotPoint = true;
 952                         buttonText.ParentOrigin = NUI.ParentOrigin.CenterLeft;
 953                         buttonText.PivotPoint = NUI.PivotPoint.CenterLeft;
 954                         buttonText.Position2D = new Position2D(textPaddingStart, 0);
 955                     }
 956                     break;
 957                 default:
 958                     break;
 959             }
 960             if (string.IsNullOrEmpty(buttonText.Text))
 961             {
 962                 buttonIcon.ParentOrigin = NUI.ParentOrigin.Center;
 963                 buttonIcon.PivotPoint = NUI.PivotPoint.Center;
 964             }
 965         }
 966         /// <summary>
 967         /// Theme change callback when theme is changed, this callback will be trigger.
 968         /// </summary>
 969         /// <param name="sender">The sender</param>
 970         /// <param name="e">The event data</param>
 971         /// <since_tizen> 8 </since_tizen>
 972         protected override void OnThemeChangedEvent(object sender, StyleManager.ThemeChangeEventArgs e)
 973         {
 974             ButtonStyle buttonStyle = StyleManager.Instance.GetViewStyle(style) as ButtonStyle;
 975             if (buttonStyle != null)
 976             {
 977                 Style.CopyFrom(buttonStyle);
 978                 UpdateUIContent();
 979             }
 980         }
 981
 982         private void UpdateUIContent()
 983         {
 984             MeasureText();
 985             LayoutChild();
 986
 987             Sensitive = isEnabled;
 988         }
 989
 990         private void OnLayoutDirectionChanged(object sender, LayoutDirectionChangedEventArgs e)
 991         {
 992             MeasureText();
 993             LayoutChild();
 994         }
 995
 996         private void OnClick(ClickEventArgs eventArgs)
 997         {
 998             ClickEvent?.Invoke(this, eventArgs);
 999         }
1000
1001         private void OnIconRelayout(object sender, EventArgs e)
1002         {
1003             MeasureText();
1004             LayoutChild();
1005         }
1006
1007         /// <summary>
1008         /// ClickEventArgs is a class to record button click event arguments which will sent to user.
1009         /// </summary>
1010         /// <since_tizen> 6 </since_tizen>
1011         public class ClickEventArgs : EventArgs
1012         {
1013         }
1014         /// <summary>
1015         /// StateChangeEventArgs is a class to record button state change event arguments which will sent to user.
1016         /// </summary>
1017         /// <since_tizen> 6 </since_tizen>
1018         public class StateChangedEventArgs : EventArgs
1019         {
1020             /// <summary> previous state of Button </summary>
1021             /// <since_tizen> 6 </since_tizen>
1022             public ControlStates PreviousState;
1023             /// <summary> current state of Button </summary>
1024             /// <since_tizen> 6 </since_tizen>
1025             public ControlStates CurrentState;
1026         }
1027
1028     }
1029 }