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 (IconRelativeOrientation == IconOrientation.Left)
 342             {
 343                 Layout = new LinearLayout()
 344                 {
 345                     LinearOrientation = LinearLayout.Orientation.Horizontal,
 346                     HorizontalAlignment = itemHorizontalAlignment,
 347                     VerticalAlignment = itemVerticalAlignment,
 348                     CellPadding = cellPadding
 349                 };
 350
 351                 Add(buttonIcon);
 352                 Add(buttonText);
 353             }
 354             else if (IconRelativeOrientation == IconOrientation.Right)
 355             {
 356                 Layout = new LinearLayout()
 357                 {
 358                     LinearOrientation = LinearLayout.Orientation.Horizontal,
 359                     HorizontalAlignment = itemHorizontalAlignment,
 360                     VerticalAlignment = itemVerticalAlignment,
 361                     CellPadding = cellPadding
 362                 };
 363
 364                 Add(buttonText);
 365                 Add(buttonIcon);
 366             }
 367             else if (IconRelativeOrientation == IconOrientation.Top)
 368             {
 369                 Layout = new LinearLayout()
 370                 {
 371                     LinearOrientation = LinearLayout.Orientation.Vertical,
 372                     HorizontalAlignment = itemHorizontalAlignment,
 373                     VerticalAlignment = itemVerticalAlignment,
 374                     CellPadding = cellPadding
 375                 };
 376
 377                 Add(buttonIcon);
 378                 Add(buttonText);
 379             }
 380             else if (IconRelativeOrientation == IconOrientation.Bottom)
 381             {
 382                 Layout = new LinearLayout()
 383                 {
 384                     LinearOrientation = LinearLayout.Orientation.Vertical,
 385                     HorizontalAlignment = itemHorizontalAlignment,
 386                     VerticalAlignment = itemVerticalAlignment,
 387                     CellPadding = cellPadding
 388                 };
 389
 390                 Add(buttonText);
 391                 Add(buttonIcon);
 392             }
 393
 394             if (overlayImage != null)
 395             {
 396                 overlayImage.ExcludeLayouting = true;
 397                 Add(overlayImage);
 398             }
 399         }
 400
 401         private void UpdateSizeAndSpacing()
 402         {
 403             if (size == null || buttonIcon == null || buttonText == null)
 404             {
 405                 return;
 406             }
 407
 408             LinearLayout layout = Layout as LinearLayout;
 409
 410             if (layout == null)
 411             {
 412                 return;
 413             }
 414
 415             float lengthWithoutText = 0;
 416             Size2D cellPadding = null;
 417             Extents iconMargin = buttonIcon.Margin ?? new Extents(0);
 418             Extents textMargin = buttonText.Margin ?? new Extents(0);
 419
 420             if (buttonIcon.Size.Width != 0 && buttonIcon.Size.Height != 0)
 421             {
 422                 lengthWithoutText = buttonIcon.Size.Width;
 423
 424                 if (!String.IsNullOrEmpty(buttonText.Text))
 425                 {
 426                     cellPadding = itemSpacing;
 427
 428                     if (iconRelativeOrientation == IconOrientation.Left || iconRelativeOrientation == IconOrientation.Right)
 429                     {
 430                         lengthWithoutText += (itemSpacing?.Width ?? 0) + iconMargin.Start + iconMargin.End + textMargin.Start + textMargin.End;
 431                     }
 432                     else
 433                     {
 434                         lengthWithoutText += (itemSpacing?.Height ?? 0) + iconMargin.Top + iconMargin.Bottom + textMargin.Top + textMargin.Bottom;
 435                     }
 436                 }
 437             }
 438
 439             layout.CellPadding = cellPadding ?? new Size2D(0, 0);
 440
 441             // If the button has fixed width and the text is not empty, the text should not exceed button boundary.
 442             if (WidthSpecification != LayoutParamPolicies.WrapContent && !String.IsNullOrEmpty(buttonText.Text))
 443             {
 444                 buttonText.MaximumSize = new Size2D((int)Math.Max(size.Width - lengthWithoutText, Math.Max(buttonText.MinimumSize.Width, 1)), (int)size.Height);
 445             }
 446         }
 447
 448         private void OnClickedInternal(ClickedEventArgs eventArgs, Touch touch)
 449         {
 450             // If GrabTouchAfterLeave is true, Up will result in Finished rather than Interrupted even if it is out of the button area.
 451             // So, it is necessary to check whether it is Up in the button area.
 452             if (GrabTouchAfterLeave == true)
 453             {
 454                 Vector2 localPosition = touch.GetLocalPosition(0);
 455                 if ((localPosition != null && Size != null &&
 456                     0 <= localPosition.X && localPosition.X <= Size.Width &&
 457                     0 <= localPosition.Y && localPosition.Y <= Size.Height) == false)
 458                 {
 459                     return;
 460                 }
 461             }
 462             OnClickedInternal(eventArgs);
 463         }
 464
 465         private void OnClickedInternal(ClickedEventArgs eventArgs)
 466         {
 467             Command?.Execute(CommandParameter);
 468             OnClicked(eventArgs);
 469             Extension?.OnClicked(this, eventArgs);
 470
 471             ClickEventArgs nestedEventArgs = new ClickEventArgs();
 472             ClickEvent?.Invoke(this, nestedEventArgs);
 473             Clicked?.Invoke(this, eventArgs);
 474         }
 475     }
 476 }