Nascondere i puntini di sospensione all'interno di un AppBar

Question

Quando si crea un AppBar o un CommandBar in un'applicazione UWP, c'è sempre i puntini di sospensione nascosto vicino al lato del controllo, in questo modo:

non lo faccio lo voglio nella mia app ma non ho trovato alcun metodo/proprietà entro AppBar che mi aiuterebbe a sbarazzarmene. Dovrebbe essere possibile, perché molte delle app di Windows 10 predefinite non ce l'hanno. Per esempio, non c'è puntini di sospensione sulla barra del menu principale sotto:

E 'possibile nascondere i puntini di sospensione utilizzando AppBar, o devo usare un o qualche altro controllo SplitView per implementare questo?

Answer 1

Innanzitutto, prova a non utilizzare AppBar nelle tue nuove app UWP.

Il controllo CommandBar per app universali di Windows è stato migliorato per fornire un superset di funzionalità AppBar e una maggiore flessibilità nella come è possibile utilizzare nella vostra app. Si dovrebbe usare CommandBar per tutti i nuovi applicazioni universali di Windows su Windows 10.

Si può leggere di più su di esso here.

Entrambe CommandBar e AppBar possono essere completamente in stile e modelli. Questo ti dà la possibilità di rimuovere qualsiasi elemento dell'interfaccia utente che non vuoi visualizzare.

Questo è come si fa -

apre la pagina in Blend, fate clic destro su CommandBar> Modifica modello> Modifica copia. Quindi assicurati di selezionare Definisci nell'applicazione poiché attualmente c'è un errore in Blend che non genererà gli stili se scegli Questo documento.

Una volta che avete tutti gli stili, trovare il controllo MoreButton e impostare il Visibility-Collapsed (o si può rimuovere, ma cosa succede se ti rendi conto che bisogno in seguito?).

Quindi si dovrebbe avere un CommandBar senza i puntini di sospensione.

Aggiornamento per il 2017 La visibilità del pulsante di puntini di sospensione si trova ora nel OverflowButtonVisibility proprietà di un CommandBar. Come sopra, impostalo su Collapsed per nasconderlo.

Answer 2

Se si desidera nascondere questo pulsante a livello globale è sufficiente aggiungere

<Style x:Key="EllipsisButton" TargetType="Button"> 
    <Setter Property="Visibility" Value="Collapsed"/> 
</Style> 

al file di risorse globali

Answer 3

So che questa domanda è non è attiva più, ma per l'amor di completamento che propongo la mia risposta.

Invece di modificare la visibilità utilizzando Stili, ho scritto un'estensione AttachedProperty che è in grado di nascondere/mostrare il MoreButton tramite associazione dati. In questo modo puoi mostrarlo/nasconderlo a tuo piacimento.

L'uso è semplice come vincolante la vostra proprietà per l'estensione:

<CommandBar extensions:CommandBarExtensions.HideMoreButton="{Binding MyBoolean}"> 
    ... 
</CommandBar> 

Il codice di estensione è la seguente:

public static class CommandBarExtensions 
{ 
    public static readonly DependencyProperty HideMoreButtonProperty = 
     DependencyProperty.RegisterAttached("HideMoreButton", typeof(bool), typeof(CommandBarExtensions), 
      new PropertyMetadata(false, OnHideMoreButtonChanged)); 

    public static bool GetHideMoreButton(UIElement element) 
    { 
     if (element == null) throw new ArgumentNullException(nameof(element)); 
     return (bool)element.GetValue(HideMoreButtonProperty); 
    } 

    public static void SetHideMoreButton(UIElement element, bool value) 
    { 
     if (element == null) throw new ArgumentNullException(nameof(element)); 
     element.SetValue(HideMoreButtonProperty, value); 
    } 

    private static void OnHideMoreButtonChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
    { 
     var commandBar = d as CommandBar; 
     if (e == null || commandBar == null || e.NewValue == null) return; 
     var morebutton = commandBar.FindDescendantByName("MoreButton"); 
     if (morebutton != null) 
     { 
      var value = GetHideMoreButton(commandBar); 
      morebutton.Visibility = value ? Visibility.Collapsed : Visibility.Visible; 
     } 
     else 
     { 
      commandBar.Loaded += CommandBarLoaded; 
     } 
    } 

    private static void CommandBarLoaded(object o, object args) 
    { 
     var commandBar = o as CommandBar; 
     var morebutton = commandBar?.FindDescendantByName("MoreButton"); 
     if (morebutton == null) return; 
     var value = GetHideMoreButton(commandBar); 
     morebutton.Visibility = value ? Visibility.Collapsed : Visibility.Visible; 
     commandBar.Loaded -= CommandBarLoaded; 
    } 
} 

Su iniziale vincolante utilizza l'evento Loaded per applicare il nascondere una volta è stato caricato. Il FindDescendantByName è un altro metodo di estensione che itera l'albero visivo. Potresti volerlo creare o prenderne uno se la tua soluzione non lo contiene ancora.

Answer 4

Poiché non posso aggiungere un commento alla risposta specifica, lo posterò qui.

Nella seguente pagina sono riportati molti esempi che troveranno l'oggetto figlio complimentare con la risposta di @RepiusK.

How can I find WPF controls by name or type?

Quello che ha funzionato per me in particolare in UWP era:

/// <summary> 
/// Finds a Child of a given item in the visual tree. 
/// </summary> 
/// <param name="parent">A direct parent of the queried item.</param> 
/// <typeparam name="T">The type of the queried item.</typeparam> 
/// <param name="childName">x:Name or Name of child. </param> 
/// <returns>The first parent item that matches the submitted type parameter. 
/// If not matching item can be found, 
/// a null parent is being returned.</returns> 
public static T FindChild<T>(DependencyObject parent, string childName) where T : DependencyObject 
{ 
    // Confirm parent and childName are valid. 
    if (parent == null) 
     return null; 

    T foundChild = null; 

    int childrenCount = VisualTreeHelper.GetChildrenCount(parent); 
    for (int i = 0; i < childrenCount; i++) 
    { 
     var child = VisualTreeHelper.GetChild(parent, i); 

     // If the child is not of the request child type child 
     T childType = child as T; 
     if (childType == null) 
     { 
      // recursively drill down the tree 
      foundChild = FindChild<T>(child, childName); 

      // If the child is found, break so we do not overwrite the found child. 
      if (foundChild != null) 
       break; 
     } 
     else if (!string.IsNullOrEmpty(childName)) 
     { 
      var frameworkElement = child as FrameworkElement; 

      // If the child's name is set for search 
      if (frameworkElement != null && frameworkElement.Name == childName) 
      { 
       // if the child's name is of the request name 
       foundChild = (T)child; 
       break; 
      } 
     } 
     else 
     { 
      // child element found. 
      foundChild = (T)child; 
      break; 
     } 
    } 

    return foundChild; 
} 

Chiamando il codice come questo:

var morebutton = FindChild<Button>(commandBar, "MoreButton"); 

Answer 5

Basandosi sulle @ di RadiusK risposta (che ha alcuni problemi), Ho trovato un'alternativa concisa che è stata testata e funziona:

using Windows.UI.Xaml; 
using Windows.UI.Xaml.Controls; 
using Windows.UI.Xaml.Media; 

namespace Linq 
{ 
    public static class CommandBarExtensions 
    { 
     public static readonly DependencyProperty HideMoreButtonProperty = DependencyProperty.RegisterAttached("HideMoreButton", typeof(bool), typeof(CommandBarExtensions), new PropertyMetadata(false, OnHideMoreButtonChanged)); 
     public static bool GetHideMoreButton(CommandBar d) 
     { 
      return (bool)d.GetValue(HideMoreButtonProperty); 
     } 
     public static void SetHideMoreButton(CommandBar d, bool value) 
     { 
      d.SetValue(HideMoreButtonProperty, value); 
     } 
     static void OnHideMoreButtonChanged(DependencyObject d, DependencyPropertyChangedEventArgs e) 
     { 
      var CommandBar = d as CommandBar; 
      if (CommandBar != null) 
      { 
       var MoreButton = CommandBar.GetChild<Button>("MoreButton") as UIElement; 
       if (MoreButton != null) 
       { 
        MoreButton.Visibility = !(e.NewValue as bool) ? Visibility.Visible : Visibility.Collapsed; 
       } 
       else CommandBar.Loaded += OnCommandBarLoaded; 
      } 
     } 

     static void OnCommandBarLoaded(object sender, RoutedEventArgs e) 
     { 
      var CommandBar = sender as CommandBar; 

      var MoreButton = CommandBar?.GetChild<Button>("MoreButton") as UIElement; 
      if (MoreButton != null) 
      { 
       MoreButton.Visibility = !(GetHideMoreButton(CommandBar) as bool) ? Visibility.Visible : Visibility.Collapsed; 
       CommandBar.Loaded -= OnCommandBarLoaded; 
      } 
     } 

     public static T GetChild<T>(this DependencyObject Parent, string Name) where T : DependencyObject 
     { 
      if (Parent != null) 
      { 
       for (int i = 0, Count = VisualTreeHelper.GetChildrenCount(Parent); i < Count; i++) 
       { 
        var Child = VisualTreeHelper.GetChild(Parent, i); 

        var Result = Child is T && !string.IsNullOrEmpty(Name) && (Child as FrameworkElement)?.Name == Name ? Child as T : Child.GetChild<T>(Name); 
        if (Result != null) 
         return Result; 
       } 
      } 
      return null; 
     } 
    } 
}