Colore di sfondo solo in fase di progettazione in WPF?

Question

In WPF XAML c'è il comodo DesignHeight e DesignWidth, ad esempio nel codice come

<UserControl ... d:DesignHeight="500" d:DesignWidth="500" ... /> 

che è grande perché posso costruire il layout con un rappresentante, ma non bloccato in, controllo dimensione .

Tuttavia, sto spesso costruendo interfacce utente scure, in cui le etichette e così via devono essere bianche, ma i miei controlli hanno ancora bisogno di un colore di sfondo trasparente. Ciò crea un inconveniente in fase di progettazione poiché il bianco sembra essere il colore di sfondo predefinito per i controlli trasparenti nella finestra di progettazione, portando a etichette illeggibili white-on-white.

C'è un modo o una strategia per impostare il colore di sfondo in fase di progettazione, con la stessa convenienza di DesignHeight/DesignWidth?

Answer 1

La mia risposta è stata trovata qui: Black Background for XAML Editor. Ci sono una serie di scelte tra cui il controllo System.ComponentModel.DesignerProperties.GetIsInDesignMode(this) in fase di esecuzione.

Answer 2

Ho scoperto che puoi farne uno per te. Custom design-time attributes in Silverlight and WPF designer è un tutorial su come farlo sia per Silverlight che per WPF.

Answer 3

C'è una proprietà non documentata d:DesignStyle di tipo Style che è possibile impostare su un controllo utente. Questo stile viene applicato solo nel designer e non viene utilizzato in fase di runtime.

si utilizza in questo modo:

<UserControl ... d:DesignStyle="{StaticResource MyDesignStyle}" /> 

O come questa:

<UserControl ...> 
    <d:DesignerProperties.DesignStyle> 
     <Style TargetType="UserControl">...</Style> 
    </d:DesignerProperties.DesignStyle> 
</UserControl> 

Nota tuttavia che qualsiasi valore impostato sul Style di proprietà (quello utilizzato in fase di esecuzione) sarà anche ignorare il DesignStyle nel designer.

Answer 4

Il d:DesignerProperties.DesignStyle tecnica mostrata in questa pagina funziona alla grande per l'applicazione di un disegno volta sola stile WPF a un singolo controllo , ma non sembra funzionare per un Style in un ResourceDictionary che si applicherebbe a all dei controlli o degli elementi tipizzati in modo appropriato nell'ambito del dizionario. Di seguito è la soluzione semplice che ho trovato per la distribuzione di uno stile di progettazione in uno ResourceDictionary.

Si consideri ad esempio uno Window contenente un TreeView, in cui si desidera che i nodi TreeViewItem vengano visualizzati come completamente espansi, ma solo in fase di progettazione. Per prima cosa, inserisci lo stile desiderato nel dizionario XAML nel modo normale.

<Window.Resources> 
    <Style TargetType="TreeViewItem"> 
     <Setter Property="IsExpanded" Value="True" /> 
    </Style> 
</Window.Resources> 

Qui, il Style è messo in ResourceDictionary della Window ma naturalmente è possibile utilizzare qualsiasi altro dizionario sussumere invece. Successivamente, nel codice C#, rimuovere lo stile da Resource­Dict­ionary quando la modalità di progettazione è non rilevata.Fare questo è nel OnInitialized di esclusione:

protected override void OnInitialized(EventArgs e) 
{ 
    if (DesignerProperties.GetIsInDesignMode(this) == false) 
     Resources.Remove(typeof(TreeViewItem)); 

    base.OnInitialized(e); 
} 

Design Mode:                                                         Modalità di esecuzione:

   

Answer 5

Questa è la soluzione completa per DesignBackground:

public class DesignTimeProperties : DependencyObject 
    { 
     private static readonly Type OwnerType = typeof(DesignTimeProperties); 

     #region DesignBackground (attached property) 

     public static Brush GetDesignBackground(DependencyObject obj) 
     { 
      return (Brush)obj.GetValue(DesignBackgroundProperty); 
     } 

     public static void SetDesignBackground(DependencyObject obj, Brush value) 
     { 
      obj.SetValue(DesignBackgroundProperty, value); 
     } 

     public static readonly DependencyProperty DesignBackgroundProperty = 
      DependencyProperty.RegisterAttached(
       "DesignBackground", 
       typeof (Brush), 
       OwnerType, 
       new FrameworkPropertyMetadata(Brushes.Transparent, 
        DesignBackgroundChangedCallback)); 

     public static void DesignBackgroundChangedCallback(DependencyObject d, DependencyPropertyChangedEventArgs e) 
     { 
      if (IsInDesignMode) 
      { 
       var control = d as Control; 
       var brush = e.NewValue as Brush; 
       if (control != null && brush != null) 
       { 
        control.Background = brush; 
       } 
      } 
     } 

     public static bool IsInDesignMode 
     { 
      get 
      { 
       return 
        ((bool) 
         DesignerProperties.IsInDesignModeProperty.GetMetadata(typeof (DependencyObject)).DefaultValue); 
      } 
     } 

     #endregion 

    } 

Usage:

<UserControl ... infra:DesignTimeProperties.DesignBackground="Black" />