src/Tizen.NUI.Components/Controls/Button.Internal.cs

   1 /*
   2  * Copyright(c) 2022 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;
  19 using System.ComponentModel;
  20 using System.Diagnostics;
  21 using Tizen.NUI.BaseComponents;
  22 using Tizen.NUI.Components.Extension;
  23 using Tizen.NUI.Accessibility; // To use AccessibilityManager
  24
  25 namespace Tizen.NUI.Components
  26 {
  27     public partial class Button
  28     {
  29         private ImageView overlayImage;
  30         private TextLabel buttonText;
  31         private ImageView buttonIcon;
  32         private Vector2 size;
  33
  34         private EventHandler<StateChangedEventArgs> stateChangeHandler;
  35
  36         private bool isPressed = false;
  37         internal int styleApplying = 0;
  38
  39         /// <summary>
  40         /// Gets accessibility name.
  41         /// </summary>
  42         [EditorBrowsable(EditorBrowsableState.Never)]
  43         protected override string AccessibilityGetName()
  44         {
  45             return Text;
  46         }
  47
  48         /// <summary>
  49         /// The ButtonExtension instance that is injected by ButtonStyle.
  50         /// </summary>
  51         [EditorBrowsable(EditorBrowsableState.Never)]
  52         protected ButtonExtension Extension { get; set; }
  53
  54         /// <summary>
  55         /// Creates Button's text part.
  56         /// </summary>
  57         /// <return>The created Button's text part.</return>
  58         [EditorBrowsable(EditorBrowsableState.Never)]
  59         protected virtual TextLabel CreateText()
  60         {
  61             return new TextLabel(new TextLabelStyle())
  62             {
  63                 HorizontalAlignment = HorizontalAlignment.Center,
  64                 VerticalAlignment = VerticalAlignment.Center,
  65                 AccessibilityHidden = true,
  66             };
  67         }
  68
  69         /// <summary>
  70         /// Creates Button's icon part.
  71         /// </summary>
  72         /// <return>The created Button's icon part.</return>
  73         [EditorBrowsable(EditorBrowsableState.Never)]
  74         protected virtual ImageView CreateIcon()
  75         {
  76             return new ImageView()
  77             {
  78                 AccessibilityHidden = true,
  79             };
  80         }
  81
  82         /// <summary>
  83         /// Creates Button's overlay image part.
  84         /// </summary>
  85         /// <return>The created Button's overlay image part.</return>
  86         [EditorBrowsable(EditorBrowsableState.Never)]
  87         protected virtual ImageView CreateOverlayImage()
  88         {
  89             return new ImageView
  90             {
  91                 PositionUsesPivotPoint = true,
  92                 ParentOrigin = NUI.ParentOrigin.Center,
  93                 PivotPoint = NUI.PivotPoint.Center,
  94                 WidthResizePolicy = ResizePolicyType.FillToParent,
  95                 HeightResizePolicy = ResizePolicyType.FillToParent,
  96                 AccessibilityHidden = true,
  97             };
  98         }
  99
 100         /// <summary>
 101         /// Called when the Button is Clicked by a user
 102         /// </summary>
 103         /// <param name="eventArgs">The click information.</param>
 104         [EditorBrowsable(EditorBrowsableState.Never)]
 105         protected virtual void OnClicked(ClickedEventArgs eventArgs)
 106         {
 107         }
 108
 109         /// <summary>
 110         /// Get Button style.
 111         /// </summary>
 112         /// <returns>The default button style.</returns>
 113         /// <since_tizen> 8 </since_tizen>
 114         protected override ViewStyle CreateViewStyle()
 115         {
 116             return new ButtonStyle();
 117         }
 118
 119         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 120         [EditorBrowsable(EditorBrowsableState.Never)]
 121         protected override void OnUpdate()
 122         {
 123             base.OnUpdate();
 124             Extension?.OnRelayout(this);
 125         }
 126
 127         /// <inheritdoc/>
 128         [EditorBrowsable(EditorBrowsableState.Never)]
 129         protected override bool HandleControlStateOnTouch(Touch touch)
 130         {
 131             if (!IsEnabled || null == touch)
 132             {
 133                 return false;
 134             }
 135
 136             PointStateType state = touch.GetState(0);
 137
 138             switch (state)
 139             {
 140                 case PointStateType.Down:
 141                     isPressed = true;
 142                     Extension?.SetTouchInfo(touch);
 143                     UpdateState();
 144                     return true;
 145                 case PointStateType.Interrupted:
 146                     isPressed = false;
 147                     UpdateState();
 148                     return true;
 149                 case PointStateType.Up:
 150                     {
 151                         if (!isPressed)
 152                         {
 153                             return false;
 154                         }
 155
 156                         isPressed = false;
 157
 158                         if (IsSelectable)
 159                         {
 160                             Extension?.SetTouchInfo(touch);
 161                             IsSelected = !IsSelected;
 162                         }
 163                         else
 164                         {
 165                             Extension?.SetTouchInfo(touch);
 166                             UpdateState();
 167                         }
 168
 169                         ClickedEventArgs eventArgs = new ClickedEventArgs();
 170                         OnClickedInternal(eventArgs, touch);
 171
 172                         return true;
 173                     }
 174                 default:
 175                     break;
 176             }
 177             return base.HandleControlStateOnTouch(touch);
 178         }
 179
 180         /// <inheritdoc/>
 181         [EditorBrowsable(EditorBrowsableState.Never)]
 182         protected override void OnEnabled(bool enabled)
 183         {
 184             base.OnEnabled(enabled);
 185             UpdateState();
 186         }
 187
 188         /// <summary>
 189         /// Update Button State.
 190         /// </summary>
 191         /// <since_tizen> 6 </since_tizen>
 192         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 193         [EditorBrowsable(EditorBrowsableState.Never)]
 194         protected void UpdateState()
 195         {
 196             if (styleApplying > 0) return;
 197
 198             ControlState sourceState = ControlState;
 199             ControlState targetState;
 200
 201             // Normal, Disabled
 202             targetState = IsEnabled ? ControlState.Normal : ControlState.Disabled;
 203
 204             // Selected, DisabledSelected
 205             if (IsSelected) targetState += ControlState.Selected;
 206
 207             // Pressed, PressedSelected
 208             if (isPressed) targetState += ControlState.Pressed;
 209
 210             // Focused, FocusedPressed, FocusedPressedSelected, DisabledFocused, DisabledSelectedFocused
 211             if (IsFocused) targetState += ControlState.Focused;
 212
 213             if (sourceState != targetState)
 214             {
 215                 ControlState = targetState;
 216                 OnUpdate();
 217
 218                 StateChangedEventArgs e = new StateChangedEventArgs
 219                 {
 220                     PreviousState = ControlStatesExtension.FromControlStateClass(sourceState),
 221                     CurrentState = ControlStatesExtension.FromControlStateClass(targetState)
 222                 };
 223                 stateChangeHandler?.Invoke(this, e);
 224
 225                 Extension?.OnControlStateChanged(this, new ControlStateChangedEventArgs(sourceState, targetState));
 226             }
 227         }
 228
 229         /// <summary>
 230         /// Dispose Button and all children on it.
 231         /// </summary>
 232         /// <param name="type">Dispose type.</param>
 233         /// <since_tizen> 6 </since_tizen>
 234         protected override void Dispose(DisposeTypes type)
 235         {
 236             if (disposed)
 237             {
 238                 return;
 239             }
 240
 241             if (type == DisposeTypes.Explicit)
 242             {
 243                 Extension?.OnDispose(this);
 244
 245                 if (buttonIcon != null)
 246                 {
 247                     Utility.Dispose(buttonIcon);
 248                 }
 249                 if (buttonText != null)
 250                 {
 251                     Utility.Dispose(buttonText);
 252                 }
 253                 if (overlayImage != null)
 254                 {
 255                     Utility.Dispose(overlayImage);
 256                 }
 257             }
 258
 259             base.Dispose(type);
 260         }
 261
 262         /// <summary>
 263         /// Initializes AT-SPI object.
 264         /// </summary>
 265         [EditorBrowsable(EditorBrowsableState.Never)]
 266         public override void OnInitialize()
 267         {
 268             base.OnInitialize();
 269
 270             AccessibilityRole = Role.PushButton;
 271             AccessibilityHighlightable = true;
 272             EnableControlStatePropagation = true;
 273
 274             AccessibilityManager.Instance.SetAccessibilityAttribute(this, AccessibilityManager.AccessibilityAttribute.Trait, "Button");
 275
 276             buttonText = CreateText();
 277             buttonIcon = CreateIcon();
 278             LayoutItems();
 279
 280             Feedback = true;
 281         }
 282
 283         /// <inheritdoc/>
 284         [EditorBrowsable(EditorBrowsableState.Never)]
 285         public override void OnRelayout(Vector2 size, RelayoutContainer container)
 286         {
 287             if (size == null) return;
 288
 289             if (size.Equals(this.size))
 290             {
 291                 return;
 292             }
 293
 294             this.size = new Vector2(size);
 295
 296             UpdateSizeAndSpacing();
 297         }
 298
 299         /// <inheritdoc/>
 300         [EditorBrowsable(EditorBrowsableState.Never)]
 301         protected override void OnControlStateChanged(ControlStateChangedEventArgs controlStateChangedInfo)
 302         {
 303             base.OnControlStateChanged(controlStateChangedInfo);
 304
 305             var stateEnabled = !controlStateChangedInfo.CurrentState.Contains(ControlState.Disabled);
 306
 307             if (IsEnabled != stateEnabled)
 308             {
 309                 IsEnabled = stateEnabled;
 310             }
 311
 312             var statePressed = controlStateChangedInfo.CurrentState.Contains(ControlState.Pressed);
 313
 314             if (isPressed != statePressed)
 315             {
 316                 isPressed = statePressed;
 317             }
 318
 319             if (IsSelectable)
 320             {
 321                 var stateSelected = controlStateChangedInfo.CurrentState.Contains(ControlState.Selected);
 322
 323                 if (IsSelected != stateSelected)
 324                 {
 325                     IsSelected = stateSelected;
 326                 }
 327             }
 328         }
 329
 330         /// <summary>
 331         /// Put sub items (e.g. buttonText, buttonIcon) to the right place.
 332         /// </summary>
 333         [EditorBrowsable(EditorBrowsableState.Never)]
 334         protected virtual void LayoutItems()
 335         {
 336             if (buttonIcon == null || buttonText == null)
 337             {
 338                 return;
 339             }
 340
 341             buttonIcon.Unparent();
 342             buttonText.Unparent();
 343             overlayImage?.Unparent();
 344
 345 #pragma warning disable CA2000
 346             Size2D cellPadding = String.IsNullOrEmpty(buttonText.Text) ? new Size2D(0, 0) : itemSpacing;
 347 #pragma warning restore CA2000
 348
 349             if (IconRelativeOrientation == IconOrientation.Left)
 350             {
 351                 Layout = new LinearLayout()
 352                 {
 353                     LinearOrientation = LinearLayout.Orientation.Horizontal,
 354                     HorizontalAlignment = itemHorizontalAlignment,
 355                     VerticalAlignment = itemVerticalAlignment,
 356                     CellPadding = cellPadding
 357                 };
 358
 359                 Add(buttonIcon);
 360                 Add(buttonText);
 361             }
 362             else if (IconRelativeOrientation == IconOrientation.Right)
 363             {
 364                 Layout = new LinearLayout()
 365                 {
 366                     LinearOrientation = LinearLayout.Orientation.Horizontal,
 367                     HorizontalAlignment = itemHorizontalAlignment,
 368                     VerticalAlignment = itemVerticalAlignment,
 369                     CellPadding = cellPadding
 370                 };
 371
 372                 Add(buttonText);
 373                 Add(buttonIcon);
 374             }
 375             else if (IconRelativeOrientation == IconOrientation.Top)
 376             {
 377                 Layout = new LinearLayout()
 378                 {
 379                     LinearOrientation = LinearLayout.Orientation.Vertical,
 380                     HorizontalAlignment = itemHorizontalAlignment,
 381                     VerticalAlignment = itemVerticalAlignment,
 382                     CellPadding = cellPadding
 383                 };
 384
 385                 Add(buttonIcon);
 386                 Add(buttonText);
 387             }
 388             else if (IconRelativeOrientation == IconOrientation.Bottom)
 389             {
 390                 Layout = new LinearLayout()
 391                 {
 392                     LinearOrientation = LinearLayout.Orientation.Vertical,
 393                     HorizontalAlignment = itemHorizontalAlignment,
 394                     VerticalAlignment = itemVerticalAlignment,
 395                     CellPadding = cellPadding
 396                 };
 397
 398                 Add(buttonText);
 399                 Add(buttonIcon);
 400             }
 401
 402             if (overlayImage != null)
 403             {
 404                 overlayImage.ExcludeLayouting = true;
 405                 Add(overlayImage);
 406             }
 407         }
 408
 409         private void UpdateSizeAndSpacing()
 410         {
 411             if (size == null || buttonIcon == null || buttonText == null)
 412             {
 413                 return;
 414             }
 415
 416             LinearLayout layout = Layout as LinearLayout;
 417
 418             if (layout == null)
 419             {
 420                 return;
 421             }
 422
 423             float lengthWithoutText = 0;
 424             Size2D cellPadding = null;
 425             Extents iconMargin = buttonIcon.Margin ?? new Extents(0);
 426             Extents textMargin = buttonText.Margin ?? new Extents(0);
 427
 428             if (buttonIcon.Size.Width != 0 && buttonIcon.Size.Height != 0)
 429             {
 430                 lengthWithoutText = buttonIcon.Size.Width;
 431
 432                 if (!String.IsNullOrEmpty(buttonText.Text))
 433                 {
 434                     cellPadding = itemSpacing;
 435
 436                     if (iconRelativeOrientation == IconOrientation.Left || iconRelativeOrientation == IconOrientation.Right)
 437                     {
 438                         lengthWithoutText += (itemSpacing?.Width ?? 0) + iconMargin.Start + iconMargin.End + textMargin.Start + textMargin.End + Padding.Start + Padding.End;
 439                     }
 440                     else
 441                     {
 442                         lengthWithoutText += (itemSpacing?.Height ?? 0) + iconMargin.Top + iconMargin.Bottom + textMargin.Top + textMargin.Bottom + Padding.Top + Padding.Bottom;
 443                     }
 444                 }
 445             }
 446
 447             layout.CellPadding = cellPadding ?? new Size2D(0, 0);
 448
 449             // If the button has fixed width and the text is not empty, the text should not exceed button boundary.
 450             if (WidthSpecification != LayoutParamPolicies.WrapContent && !String.IsNullOrEmpty(buttonText.Text))
 451             {
 452                 buttonText.MaximumSize = new Size2D((int)Math.Max(size.Width - lengthWithoutText, Math.Max(buttonText.MinimumSize.Width, 1)), (int)size.Height);
 453             }
 454         }
 455
 456         private void OnClickedInternal(ClickedEventArgs eventArgs, Touch touch)
 457         {
 458             // If GrabTouchAfterLeave is true, Up will result in Finished rather than Interrupted even if it is out of the button area.
 459             // So, it is necessary to check whether it is Up in the button area.
 460             if (GrabTouchAfterLeave == true)
 461             {
 462                 Vector2 localPosition = touch.GetLocalPosition(0);
 463                 if ((localPosition != null && Size != null &&
 464                     0 <= localPosition.X && localPosition.X <= Size.Width &&
 465                     0 <= localPosition.Y && localPosition.Y <= Size.Height) == false)
 466                 {
 467                     return;
 468                 }
 469             }
 470             OnClickedInternal(eventArgs);
 471         }
 472
 473         private void OnClickedInternal(ClickedEventArgs eventArgs)
 474         {
 475             Command?.Execute(CommandParameter);
 476             OnClicked(eventArgs);
 477             Extension?.OnClicked(this, eventArgs);
 478
 479             ClickEventArgs nestedEventArgs = new ClickEventArgs();
 480             ClickEvent?.Invoke(this, nestedEventArgs);
 481             Clicked?.Invoke(this, eventArgs);
 482         }
 483     }
 484 }