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         private bool styleApplied = false;
  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 (!styleApplied) 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 #if PROFILE_MOBILE
 281             Feedback = true;
 282 #endif
 283         }
 284
 285         /// <inheritdoc/>
 286         [EditorBrowsable(EditorBrowsableState.Never)]
 287         public override void OnRelayout(Vector2 size, RelayoutContainer container)
 288         {
 289             if (size == null) return;
 290
 291             if (size.Equals(this.size))
 292             {
 293                 return;
 294             }
 295
 296             this.size = new Vector2(size);
 297
 298             UpdateSizeAndSpacing();
 299         }
 300
 301         /// <inheritdoc/>
 302         [EditorBrowsable(EditorBrowsableState.Never)]
 303         protected override void OnControlStateChanged(ControlStateChangedEventArgs controlStateChangedInfo)
 304         {
 305             base.OnControlStateChanged(controlStateChangedInfo);
 306
 307             var stateEnabled = !controlStateChangedInfo.CurrentState.Contains(ControlState.Disabled);
 308
 309             if (IsEnabled != stateEnabled)
 310             {
 311                 IsEnabled = stateEnabled;
 312             }
 313
 314             var statePressed = controlStateChangedInfo.CurrentState.Contains(ControlState.Pressed);
 315
 316             if (isPressed != statePressed)
 317             {
 318                 isPressed = statePressed;
 319             }
 320         }
 321
 322         /// <summary>
 323         /// Put sub items (e.g. buttonText, buttonIcon) to the right place.
 324         /// </summary>
 325         [EditorBrowsable(EditorBrowsableState.Never)]
 326         protected virtual void LayoutItems()
 327         {
 328             if (buttonIcon == null || buttonText == null)
 329             {
 330                 return;
 331             }
 332
 333             buttonIcon.Unparent();
 334             buttonText.Unparent();
 335             overlayImage?.Unparent();
 336
 337 #pragma warning disable CA2000
 338             Size2D cellPadding = String.IsNullOrEmpty(buttonText.Text) ? new Size2D(0, 0) : itemSpacing;
 339 #pragma warning restore CA2000
 340
 341             // If LayoutItems() is called by OnInitialize(), then layout would be null.
 342             // Because layout is set by ApplyStyle() which is called after OnInitialize().
 343             var layout = Layout as LinearLayout;
 344             if (layout != null)
 345             {
 346                 layout.HorizontalAlignment = itemHorizontalAlignment;
 347                 layout.VerticalAlignment = itemVerticalAlignment;
 348                 layout.CellPadding = cellPadding;
 349             }
 350
 351             if (IconRelativeOrientation == IconOrientation.Left)
 352             {
 353                 if (layout != null)
 354                 {
 355                     layout.LinearOrientation = LinearLayout.Orientation.Horizontal;
 356                 }
 357
 358                 Add(buttonIcon);
 359                 Add(buttonText);
 360             }
 361             else if (IconRelativeOrientation == IconOrientation.Right)
 362             {
 363                 if (layout != null)
 364                 {
 365                     layout.LinearOrientation = LinearLayout.Orientation.Horizontal;
 366                 }
 367
 368                 Add(buttonText);
 369                 Add(buttonIcon);
 370             }
 371             else if (IconRelativeOrientation == IconOrientation.Top)
 372             {
 373                 if (layout != null)
 374                 {
 375                     layout.LinearOrientation = LinearLayout.Orientation.Vertical;
 376                 }
 377
 378                 Add(buttonIcon);
 379                 Add(buttonText);
 380             }
 381             else if (IconRelativeOrientation == IconOrientation.Bottom)
 382             {
 383                 if (layout != null)
 384                 {
 385                     layout.LinearOrientation = LinearLayout.Orientation.Vertical;
 386                 }
 387
 388                 Add(buttonText);
 389                 Add(buttonIcon);
 390             }
 391
 392             if (overlayImage != null)
 393             {
 394                 overlayImage.ExcludeLayouting = true;
 395                 Add(overlayImage);
 396             }
 397         }
 398
 399         private void UpdateSizeAndSpacing()
 400         {
 401             if (size == null || buttonIcon == null || buttonText == null)
 402             {
 403                 return;
 404             }
 405
 406             LinearLayout layout = Layout as LinearLayout;
 407
 408             if (layout == null)
 409             {
 410                 return;
 411             }
 412
 413             float lengthWithoutText = 0;
 414             Size2D cellPadding = null;
 415             Extents iconMargin = buttonIcon.Margin ?? new Extents(0);
 416             Extents textMargin = buttonText.Margin ?? new Extents(0);
 417
 418             if (buttonIcon.Size.Width != 0 && buttonIcon.Size.Height != 0)
 419             {
 420                 lengthWithoutText = buttonIcon.Size.Width;
 421
 422                 if (!String.IsNullOrEmpty(buttonText.Text))
 423                 {
 424                     cellPadding = itemSpacing;
 425
 426                     if (iconRelativeOrientation == IconOrientation.Left || iconRelativeOrientation == IconOrientation.Right)
 427                     {
 428                         lengthWithoutText += (itemSpacing?.Width ?? 0) + iconMargin.Start + iconMargin.End + textMargin.Start + textMargin.End;
 429                     }
 430                     else
 431                     {
 432                         lengthWithoutText += (itemSpacing?.Height ?? 0) + iconMargin.Top + iconMargin.Bottom + textMargin.Top + textMargin.Bottom;
 433                     }
 434                 }
 435             }
 436
 437             layout.CellPadding = cellPadding ?? new Size2D(0, 0);
 438
 439             // If the button has fixed width and the text is not empty, the text should not exceed button boundary.
 440             if (WidthSpecification != LayoutParamPolicies.WrapContent && !String.IsNullOrEmpty(buttonText.Text))
 441             {
 442                 buttonText.MaximumSize = new Size2D((int)Math.Max(size.Width - lengthWithoutText, Math.Max(buttonText.MinimumSize.Width, 1)), (int)size.Height);
 443             }
 444         }
 445
 446         private void OnClickedInternal(ClickedEventArgs eventArgs, Touch touch)
 447         {
 448             // If GrabTouchAfterLeave is true, Up will result in Finished rather than Interrupted even if it is out of the button area.
 449             // So, it is necessary to check whether it is Up in the button area.
 450             if (GrabTouchAfterLeave == true)
 451             {
 452                 Vector2 localPosition = touch.GetLocalPosition(0);
 453                 if ((localPosition != null && Size != null &&
 454                     0 <= localPosition.X && localPosition.X <= Size.Width &&
 455                     0 <= localPosition.Y && localPosition.Y <= Size.Height) == false)
 456                 {
 457                     return;
 458                 }
 459             }
 460             OnClickedInternal(eventArgs);
 461         }
 462
 463         private void OnClickedInternal(ClickedEventArgs eventArgs)
 464         {
 465             Command?.Execute(CommandParameter);
 466             OnClicked(eventArgs);
 467             Extension?.OnClicked(this, eventArgs);
 468
 469             ClickEventArgs nestedEventArgs = new ClickEventArgs();
 470             ClickEvent?.Invoke(this, nestedEventArgs);
 471             Clicked?.Invoke(this, eventArgs);
 472         }
 473     }
 474 }