src/Tizen.NUI.Components/Controls/Control.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
  18 using System;
  19 using System.ComponentModel;
  20 using Tizen.NUI.BaseComponents;
  21 using Tizen.NUI.Binding;
  22 using System.Windows.Input;
  23 using Tizen.System;
  24
  25 namespace Tizen.NUI.Components
  26 {
  27     /// <summary>
  28     /// The control component is base class of tv nui components. It's abstract class, so can't instantiate and can only be inherited.
  29     /// </summary>
  30     /// <since_tizen> 6 </since_tizen>
  31     /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  32     [EditorBrowsable(EditorBrowsableState.Never)]
  33     public class Control : VisualView
  34     {
  35         /// Internal used.
  36         [EditorBrowsable(EditorBrowsableState.Never)]
  37         public static readonly BindableProperty CommandProperty = BindableProperty.Create(nameof(Command), typeof(ICommand), typeof(Control), null, propertyChanged: (bo, o, n) => ((Control)bo).OnCommandChanged());
  38
  39         /// Internal used.
  40         [EditorBrowsable(EditorBrowsableState.Never)]
  41         public static readonly BindableProperty CommandParameterProperty = BindableProperty.Create(nameof(CommandParameter), typeof(object), typeof(Button), null,
  42             propertyChanged: (bindable, oldvalue, newvalue) => ((Button)bindable).CommandCanExecuteChanged(bindable, EventArgs.Empty));
  43
  44         private bool onThemeChangedEventOverrideChecker;
  45
  46         private Feedback feedback = null;
  47
  48         static Control()
  49         {
  50             ThemeManager.AddPackageTheme(DefaultThemeCreator.Instance);
  51         }
  52
  53         /// <summary>
  54         /// This is used to improve theme performance.
  55         /// </summary>
  56         [EditorBrowsable(EditorBrowsableState.Never)]
  57         static public void Preload()
  58         {
  59             DefaultThemeCreator.Preload();
  60         }
  61
  62         /// <summary>
  63         /// Construct an empty Control.
  64         /// </summary>
  65         /// <since_tizen> 6 </since_tizen>
  66         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  67         [EditorBrowsable(EditorBrowsableState.Never)]
  68         public Control() : this((ControlStyle)null)
  69         {
  70         }
  71
  72         /// <summary>
  73         /// Construct with style.
  74         /// </summary>
  75         /// <param name="style">Create control with style.</param>
  76         /// <since_tizen> 6 </since_tizen>
  77         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  78         [EditorBrowsable(EditorBrowsableState.Never)]
  79         public Control(ControlStyle style) : base(style)
  80         {
  81         }
  82
  83         /// <summary>
  84         /// Construct with style name
  85         /// </summary>
  86         /// <param name="styleName">The name of style in the current theme to be applied</param>
  87         /// <since_tizen> 6 </since_tizen>
  88         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
  89         [EditorBrowsable(EditorBrowsableState.Never)]
  90         public Control(string styleName) : base(ThemeManager.GetInitialStyleWithoutClone(styleName) ?? throw new InvalidOperationException($"There is no style {styleName}"))
  91         {
  92             this.styleName = styleName;
  93
  94             SetThemeApplied();
  95         }
  96
  97         /// <summary>
  98         /// Enable/Disable a sound feedback when tap gesture detected.
  99         /// </summary>
 100         [EditorBrowsable(EditorBrowsableState.Never)]
 101         public bool Feedback
 102         {
 103             get => feedback != null;
 104             set
 105             {
 106                 if (value == (feedback != null))
 107                 {
 108                     return;
 109                 }
 110
 111                 if (value)
 112                 {
 113                     feedback = new Feedback();
 114                     this.TouchEvent += OnTouchPlayFeedback;
 115                 }
 116                 else
 117                 {
 118                     this.TouchEvent -= OnTouchPlayFeedback;
 119                     feedback = null;
 120                 }
 121             }
 122         }
 123
 124         private bool OnTouchPlayFeedback(object source, TouchEventArgs e)
 125         {
 126             if (Feedback && e?.Touch.GetState(0) == PointStateType.Down)
 127             {
 128                 if (feedback != null && feedback.IsSupportedPattern(FeedbackType.Sound, "Tap"))
 129                 {
 130                     feedback.Play(FeedbackType.Sound, "Tap");
 131                 }
 132             }
 133             return false;
 134         }
 135
 136         /// Internal used.
 137         [EditorBrowsable(EditorBrowsableState.Never)]
 138         public ICommand Command
 139         {
 140             get { return (ICommand)GetValue(CommandProperty); }
 141             set { SetValue(CommandProperty, value); }
 142         }
 143
 144         /// Internal used.
 145         [EditorBrowsable(EditorBrowsableState.Never)]
 146         public object CommandParameter
 147         {
 148             get { return GetValue(CommandParameterProperty); }
 149             set { SetValue(CommandParameterProperty, value); }
 150         }
 151
 152         /// <summary>
 153         /// Whether focusable when touch
 154         /// </summary>
 155         /// <since_tizen> 6 </since_tizen>
 156         internal bool StateFocusableOnTouchMode { get; set; }
 157
 158         internal bool IsFocused { get; set; } = false;
 159
 160         internal void CommandCanExecuteChanged(object sender, EventArgs eventArgs)
 161         {
 162             ICommand cmd = Command;
 163             if (cmd != null)
 164                 cmd.CanExecute(CommandParameter);
 165         }
 166
 167         internal void OnCommandChanged()
 168         {
 169             if (Command != null)
 170             {
 171                 Command.CanExecuteChanged += CommandCanExecuteChanged;
 172                 CommandCanExecuteChanged(this, EventArgs.Empty);
 173             }
 174         }
 175
 176         /// <summary>
 177         /// Dispose Control and all children on it.
 178         /// </summary>
 179         /// <param name="type">Dispose type.</param>
 180         /// <since_tizen> 6 </since_tizen>
 181         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 182         [EditorBrowsable(EditorBrowsableState.Never)]
 183         protected override void Dispose(DisposeTypes type)
 184         {
 185             if (disposed)
 186             {
 187                 return;
 188             }
 189
 190             feedback = null;
 191             this.TouchEvent -= OnTouchPlayFeedback;
 192
 193             if (type == DisposeTypes.Explicit)
 194             {
 195             }
 196
 197             base.Dispose(type);
 198         }
 199
 200         /// <inheritdoc/>
 201         public override void OnInitialize()
 202         {
 203             base.OnInitialize();
 204
 205             LeaveRequired = true;
 206             StateFocusableOnTouchMode = false;
 207             EnableControlState = true;
 208         }
 209
 210         /// <summary>
 211         /// Called after a key event is received by the view that has had its focus set.
 212         /// </summary>
 213         /// <param name="key">The key event.</param>
 214         /// <returns>True if the key event should be consumed.</returns>
 215         /// <since_tizen> 6 </since_tizen>
 216         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 217         [EditorBrowsable(EditorBrowsableState.Never)]
 218         public override bool OnKey(Key key)
 219         {
 220             return false;
 221         }
 222
 223         /// <summary>
 224         /// Called after the size negotiation has been finished for this control.<br />
 225         /// The control is expected to assign this given size to itself or its children.<br />
 226         /// Should be overridden by derived classes if they need to layout views differently after certain operations like add or remove views, resize, or after changing specific properties.<br />
 227         /// As this function is called from inside the size negotiation algorithm, you cannot call RequestRelayout (the call would just be ignored).<br />
 228         /// </summary>
 229         /// <param name="size">The allocated size.</param>
 230         /// <param name="container">The control should add views to this container that it is not able to allocate a size for.</param>
 231         /// <since_tizen> 6 </since_tizen>
 232         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 233         [EditorBrowsable(EditorBrowsableState.Never)]
 234         public override void OnRelayout(Vector2 size, RelayoutContainer container)
 235         {
 236             base.OnRelayout(size, container);
 237             OnUpdate();
 238         }
 239
 240         /// <summary>
 241         /// 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.
 242         /// </summary>
 243         /// <since_tizen> 6 </since_tizen>
 244         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 245         [EditorBrowsable(EditorBrowsableState.Never)]
 246         public override void OnFocusGained()
 247         {
 248             IsFocused = true;
 249         }
 250
 251         /// <summary>
 252         /// 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.
 253         /// </summary>
 254         /// <since_tizen> 6 </since_tizen>
 255         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 256         [EditorBrowsable(EditorBrowsableState.Never)]
 257         public override void OnFocusLost()
 258         {
 259             IsFocused = false;
 260         }
 261
 262         /// <summary>
 263         /// Update by style.
 264         /// </summary>
 265         /// <since_tizen> 6 </since_tizen>
 266         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 267         [EditorBrowsable(EditorBrowsableState.Never)]
 268         protected virtual void OnUpdate()
 269         {
 270         }
 271
 272         /// <summary>
 273         /// Theme change callback when theme is changed, this callback will be trigger.
 274         /// Note that it is deprecated API.Please use OnThemeChanged instead.
 275         /// </summary>
 276         /// <param name="sender">The sender</param>
 277         /// <param name="e">The event data</param>
 278         /// <since_tizen> 6 </since_tizen>
 279         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 280         [EditorBrowsable(EditorBrowsableState.Never)]
 281         protected virtual void OnThemeChangedEvent(object sender, StyleManager.ThemeChangeEventArgs e)
 282         {
 283             onThemeChangedEventOverrideChecker = false;
 284         }
 285
 286         /// This will be public opened in tizen_5.5 after ACR done. Before ACR, need to be hidden as inhouse API.
 287         [EditorBrowsable(EditorBrowsableState.Never)]
 288         protected override ViewStyle CreateViewStyle()
 289         {
 290             return new ControlStyle();
 291         }
 292
 293         /// <inheritdoc/>
 294         [EditorBrowsable(EditorBrowsableState.Never)]
 295         protected override void OnThemeChanged(object sender, ThemeChangedEventArgs e)
 296         {
 297             // TODO Remove checker after update Tizen.FH.NUI.
 298             onThemeChangedEventOverrideChecker = true;
 299
 300             OnThemeChangedEvent(sender, new StyleManager.ThemeChangeEventArgs { CurrentTheme = e.ThemeId });
 301
 302             if (onThemeChangedEventOverrideChecker) return;
 303
 304             // If the OnThemeChangedEvent is not implemented, ApplyStyle()
 305             base.OnThemeChanged(sender, e);
 306         }
 307     }
 308 }