WPF: как реализовать кнопку, которая делает две другие кнопки видимыми с замиранием

Question

Я хочу использовать специальную кнопку, и я даже не знаю, как начать с этого.

Я хочу, чтобы мое имущество Button составляло: Play. При нажатии на нее, я хочу 2 другие Buttons всплывал в левой и в правой частях: Single Play и Parallel Play

Answer 1

После долгих обсуждений, и вот результат, чтобы решить эту проблему:

XAML:

<Window x:Class="WpfApplication3.MainWindow" 
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation" 
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" 
    xmlns:my="clr-namespace:WpfApplication3" 
    Title="MainWindow" Height="350" Width="525"> 
<Grid> 
    <StackPanel Orientation="Horizontal"> 
     <Button Name="btnSinglePlay" Visibility="Collapsed" my:VisibilityAnimation.IsActive="True">SinglePlay</Button> 
     <Button Name="btnPlay" Click="btnPlay_Click">Play</Button> 
     <Button Name="btnParallelPlay" Visibility="Collapsed" my:VisibilityAnimation.IsActive="True">ParallelPlay</Button> 
    </StackPanel> 
</Grid> 

C# для установки кнопки 2 стороны видно.

private void btnPlay_Click(object sender, RoutedEventArgs e) 
     { 
      btnSinglePlay.Visibility = Visibility.Visible; 
      btnParallelPlay.Visibility = Visibility.Visible; 
     } 

И код C#, позволяющий исчезать/исчезать. Он исходит от WPF Fade Animation, поэтому реквизит в Анваку, а не мне.

using System; 
using System.Collections; 
using System.Collections.Generic; 
using System.Linq; 
using System.Text; 
using System.Threading.Tasks; 
using System.Windows; 
using System.Windows.Media.Animation; 

namespace WpfApplication3 
{ 
    public class VisibilityAnimation : DependencyObject 
    { 
     private const int DURATION_MS = 200; 

     private static readonly Hashtable _hookedElements = new Hashtable(); 

     public static readonly DependencyProperty IsActiveProperty = 
      DependencyProperty.RegisterAttached("IsActive", 
      typeof(bool), 
      typeof(VisibilityAnimation), 
      new FrameworkPropertyMetadata(false, new PropertyChangedCallback(OnIsActivePropertyChanged))); 

     public static bool GetIsActive(UIElement element) 
     { 
      if (element == null) 
      { 
       throw new ArgumentNullException("element"); 
      } 

      return (bool)element.GetValue(IsActiveProperty); 
     } 

     public static void SetIsActive(UIElement element, bool value) 
     { 
      if (element == null) 
      { 
       throw new ArgumentNullException("element"); 
      } 
      element.SetValue(IsActiveProperty, value); 
     } 

     static VisibilityAnimation() 
     { 
      UIElement.VisibilityProperty.AddOwner(typeof(FrameworkElement), 
                new FrameworkPropertyMetadata(Visibility.Visible, new PropertyChangedCallback(VisibilityChanged), CoerceVisibility)); 
     } 

     private static void VisibilityChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
     { 
      // So what? Ignore. 
     } 

     private static void OnIsActivePropertyChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
     { 
      var fe = d as FrameworkElement; 
      if (fe == null) 
      { 
       return; 
      } 
      if (GetIsActive(fe)) 
      { 
       HookVisibilityChanges(fe); 
      } 
      else 
      { 
       UnHookVisibilityChanges(fe); 
      } 
     } 

     private static void UnHookVisibilityChanges(FrameworkElement fe) 
     { 
      if (_hookedElements.Contains(fe)) 
      { 
       _hookedElements.Remove(fe); 
      } 
     } 

     private static void HookVisibilityChanges(FrameworkElement fe) 
     { 
      _hookedElements.Add(fe, false); 
     } 

     private static object CoerceVisibility(DependencyObject d, object baseValue) 
     { 
      var fe = d as FrameworkElement; 
      if (fe == null) 
      { 
       return baseValue; 
      } 

      if (CheckAndUpdateAnimationStartedFlag(fe)) 
      { 
       return baseValue; 
      } 
      // If we get here, it means we have to start fade in or fade out 
      // animation. In any case return value of this method will be 
      // Visibility.Visible. 

      var visibility = (Visibility)baseValue; 

      var da = new DoubleAnimation 
      { 
       Duration = new Duration(TimeSpan.FromMilliseconds(DURATION_MS)) 
      }; 

      da.Completed += (o, e) => 
      { 
       // This will trigger value coercion again 
       // but CheckAndUpdateAnimationStartedFlag() function will reture true 
       // this time, and animation will not be triggered. 
       fe.Visibility = visibility; 
       // NB: Small problem here. This may and probably will brake 
       // binding to visibility property. 
      }; 

      if (visibility == Visibility.Collapsed || visibility == Visibility.Hidden) 
      { 
       da.From = 1.0; 
       da.To = 0.0; 
      } 
      else 
      { 
       da.From = 0.0; 
       da.To = 1.0; 
      } 

      fe.BeginAnimation(UIElement.OpacityProperty, da); 
      return Visibility.Visible; 
     } 

     private static bool CheckAndUpdateAnimationStartedFlag(FrameworkElement fe) 
     { 
      var hookedElement = _hookedElements.Contains(fe); 
      if (!hookedElement) 
      { 
       return true; // don't need to animate unhooked elements. 
      } 

      var animationStarted = (bool)_hookedElements[fe]; 
      _hookedElements[fe] = !animationStarted; 

      return animationStarted; 
     } 
    } 
} 

Answer 2

Все, что вам нужно сделать, это создать 3 кнопки, а затем поставить конвертер видимость на ваших 2-х сторон кнопок. Создайте свойство, которое будет удерживаться, если они должны быть видимыми или нет, и привяжите конвертер видимости к этому свойству. Кнопка Play должна изменить это свойство при нажатии.

Надеюсь, это даст вам представление о том, как начать с этого.