User Settings Applied

Re: Save collection contents

5:38 9 Jul '09

Hi Jens,

jensli wrote:
Thanks for a nice library!

Assume you have in your class a list of strings, like:

private readonly List<string> ids = new List<string>();

You can create a setting property:

// ----------------------------------------------------------------------
[PropertySetting()]
public string IdSettings
{
  get
  {
    System.Text.StringBuilder sb = new System.Text.StringBuilder();
    foreach ( string item in ids )
    {
      if ( sb.Length > 0 )
      {
        sb.Append( ";" );
      }
      sb.Append( item.ToString() );
    }
    return sb.ToString();
  }
  set
  {
    ids.Clear();
    if ( !string.IsNullOrEmpty( value ) )
    {
      string[] items = value.Split( ';' );
      foreach ( string item in items )
      {
        ids.Add( item );
      }
    }
  }
} // IdSettings

The following sample allows the reuse of such a string collection setting:

// ------------------------------------------------------------------------
public class StringListSetting : Setting
{

  // ----------------------------------------------------------------------
  public StringListSetting( string name, IList<string> list )
  {
    if ( name == null )
    {
      throw new ArgumentNullException( "name" );
    }
    if ( list == null )
    {
      throw new ArgumentNullException( "list" );
    }
    this.name = name;
    this.list = list;
  } // StringListSetting

  // ----------------------------------------------------------------------
  public string Name
  {
    get { return this.name; }
  } // Name

  // ----------------------------------------------------------------------
  public IList<string> List
  {
    get { return list; }
  } // List

  // ----------------------------------------------------------------------
  public override bool HasChanged
  {
    get { return !string.Equals( OriginalStringListSettings, GetListValues() ); }
  } // HasChanged

  // ----------------------------------------------------------------------
  public override void Load()
  {
    SetListValues( OriginalStringListSettings );
  } // Load

  // ----------------------------------------------------------------------
  public override void Save()
  {
    SaveValue(
      Name,
      typeof( string ),
      SettingsSerializeAs.String,
      GetListValues(),
      null );
  } // Save

  // ----------------------------------------------------------------------
  private string OriginalStringListSettings
  {
    get
    {
      return LoadValue(
        Name,
        typeof( string ),
        SettingsSerializeAs.String,
        null ) as string;
    }
  } // OriginalStringListSettings

  // ----------------------------------------------------------------------
  private string GetListValues()
  {
    StringBuilder sb = new StringBuilder();
    foreach ( string item in list )
    {
      if ( sb.Length > 0 )
      {
        sb.Append( ";" );
      }
      sb.Append( item.ToString() );
    }
    return sb.ToString();
  } // GetListValues

  // ----------------------------------------------------------------------
  private void SetListValues( string values )
  {
    list.Clear();

    if ( string.IsNullOrEmpty( values ) )
    {
      return;
    }

    string[] items = values.Split( ';' );
    foreach ( string item in items )
    {
      list.Add( item );
    }
  } // SetListValues

  // ----------------------------------------------------------------------
  // members
  private readonly string name;
  private readonly IList<string> list;

} // class StringListSetting

The class StingListSetting can be used like:

...
// setup and load user settings
ApplicationSettings settings = new ApplicationSettings( this );
settings.Settings.Add( new StringListSetting( "IdList", ids ) );
settings.Load();
...

Cheers,
Jani [My Articles]

jensli

22:20 13 Jul '09

Cheers, it worked fine! This is very convenient, I ask a simple question and someone writes the code for me!

Below is a slight adaptation of your solution, adding support for saving any type through two convertion functions.

Also user supplied separator char in case the strings contains ';'.

Its slightly irritating that you have to give it convertion functions even if it is string you want to store, I didnt come up with a solution for that.

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Configuration;

namespace Itenso.Configuration
{
	// ------------------------------------------------------------------------
	public class StringListSetting<T> : Setting
	{
		// ----------------------------------------------------------------------
		public StringListSetting(string name, ICollection<T> list, Func<T, string> toString, Func<string, T> fromString)
			: this(name, list, ';', toString, fromString) 
		{
		}// StringListSetting

		// ----------------------------------------------------------------------
		/// <summary>
		/// Specify function for converting the class of the objects to and from string
		/// </summary>
		public StringListSetting(string name, ICollection<T> list, char splitChar, Func<T, string> toString, Func<string, T> fromString)
		{
			if (name == null)
			{
				throw new ArgumentNullException("name");
			}
			if (list == null)
			{
				throw new ArgumentNullException("list");
			}
			this.name = name;
			this.list = list;
			this.convertFromString = fromString;
			this.convertToString = toString;
			this.splitChar = splitChar;
		} // StringListSetting

		// ----------------------------------------------------------------------
		public string Name
		{
			get { return this.name; }
		} // Name

		// ----------------------------------------------------------------------
		public ICollection<T> List
		{
			get { return list; }
		} // List

		// ----------------------------------------------------------------------
		public override bool HasChanged
		{
			get { return !string.Equals(OriginalStringListSettings, GetListValues()); }
		} // HasChanged

		// ----------------------------------------------------------------------
		public override void Load()
		{
			SetListValues(OriginalStringListSettings);
		} // Load

		// ----------------------------------------------------------------------
		public override void Save()
		{
			SaveValue(
			  Name,
			  typeof(string),
			  SettingsSerializeAs.String,
			  GetListValues(),
			  null);
		} // Save

		// ----------------------------------------------------------------------
		private string OriginalStringListSettings
		{
			get
			{
				return LoadValue(
				  Name,
				  typeof(string),
				  SettingsSerializeAs.String,
				  null) as string;
			}
		} // OriginalStringListSettings

		// ----------------------------------------------------------------------
		private string GetListValues()
		{
			StringBuilder sb = new StringBuilder();
			foreach (T item in list)
			{
				if (sb.Length > 0)
				{
					sb.Append(splitChar);
				}
				sb.Append(convertToString(item));
			}
			return sb.ToString();
		} // GetListValues

		// ----------------------------------------------------------------------
		private void SetListValues(string values)
		{
			list.Clear();

			if (string.IsNullOrEmpty(values))
			{
				return;
			}

			string[] items = values.Split(splitChar);
			foreach (string item in items)
			{
				list.Add(convertFromString(item));
			}
		} // SetListValues

		// ----------------------------------------------------------------------
		// members
		private readonly string name;
		private readonly ICollection<T> list;
		private readonly char splitChar = ';';
		private Func<T, string> convertToString;
		private Func<string, T> convertFromString;

	} // class StringListSetting}
}

Multi-Monitor Support?

amr_tsc

11:30 13 Mar '09

The example application for WPF saves and restores its window position. However, if the app is saved to a second monitor and the monitor is then removed, the next time the app runs, it will restore to a position on the non-existent monitor, making it impossible to move the app.

The window location is automatically handled as a dependency property in class WindowSettings. How could I hook into this to check if the location is on a non-existent Screen, so I could force the app to the PrimaryScreen?

Re: Multi-Monitor Support?

Re: Multi-Monitor Support?

9:59 14 Mar '09

Hi amr_tsc

Thanks for the feedback.

I have added Multi-Monitor support to the WindowSettings class:

// -- FILE ------------------------------------------------------------------
// name       : WindowSettings.cs
// created    : Jani Giannoudis - 2008.04.25
// language   : c#
// environment: .NET 3.0
// --------------------------------------------------------------------------
using System;
using System.Windows;
using System.ComponentModel;
using System.Diagnostics;
using System.Windows.Forms;
using System.Windows.Interop;

namespace Itenso.Configuration
{

  // ------------------------------------------------------------------------
  public class WindowSettings : ApplicationSettings
  {

    // ----------------------------------------------------------------------
    public static readonly DependencyProperty SettingsProperty = 
      DependencyProperty.RegisterAttached(
        "Settings",
        typeof( string ),
        typeof( WindowSettings ),
        new FrameworkPropertyMetadata( new PropertyChangedCallback( OnWindowSettingsChanged ) ) );

    // ----------------------------------------------------------------------
    public static readonly DependencyProperty CollectedSettingProperty =
      DependencyProperty.RegisterAttached(
        "CollectedSetting",
        typeof( DependencyProperty ),
        typeof( WindowSettings ),
        new FrameworkPropertyMetadata( new PropertyChangedCallback( OnCollectedSettingChanged ) ) );

    // ----------------------------------------------------------------------
    public static readonly DependencyProperty ExcludeElementProperty = DependencyProperty.RegisterAttached(
      "ExcludeElement",
      typeof( bool ),
      typeof( WindowSettings ) );

    // ----------------------------------------------------------------------
    public WindowSettings( Window window ) :
      this( window, window.GetType().Name )
    {
    } // WindowSettings

    // ----------------------------------------------------------------------
    public WindowSettings( Window window, string settingsKey ) :
      base( settingsKey )
    {
      if ( window == null )
      {
        throw new ArgumentNullException( "window" );
      }

      this.window = window;
      UseLocation = true;
      UseSize = true;
      UseWindowState = true;
      SaveOnClose = true;

      // subscribe to parent window's events
      this.window.Initialized += new EventHandler( WindowInitialized );
      this.window.Loaded += new RoutedEventHandler( WindowLoaded );
      this.window.Closing += new CancelEventHandler( WindowClosing );
    } // WindowSettings

    // ----------------------------------------------------------------------
    public Window Window
    {
      get { return this.window; }
    } // Window

    // ----------------------------------------------------------------------
    public bool? SaveCondition
    {
      get { return this.saveCondition; }
      set { this.saveCondition = value; }
    } // SaveCondition

    // ----------------------------------------------------------------------
    public double LocationY
    {
      get { return this.window.Top; }
      set
      {
        double posTop = Screen.Bounds.Y + value;
        if ( posTop < Screen.Bounds.Bottom )
        {
          this.window.Top = posTop;
        }
      }
    } // LocationY

    // ----------------------------------------------------------------------
    public double LocationX
    {
      get { return this.window.Left; }
      set
      {
        double posLeft = Screen.Bounds.X + value;
        if ( posLeft < Screen.Bounds.Right )
        {
          this.window.Left = posLeft;
        }
      }
    } // LocationX

    // ----------------------------------------------------------------------
    public bool UseLocation { get; set; }

    // ----------------------------------------------------------------------
    public bool UseSize { get; set; }

    // ----------------------------------------------------------------------
    public bool UseWindowState { get; set; }

    // ----------------------------------------------------------------------
    public bool AllowMinimized { get; set; }

    // ----------------------------------------------------------------------
    public bool SaveOnClose
    {
      get { return this.saveOnClose; }
      set { this.saveOnClose = value; }
    } // SaveOnClose

    // ----------------------------------------------------------------------
    private Screen Screen
    {
      get
      {
        if ( this.screen == null )
        {
          IntPtr hwnd = new WindowInteropHelper( this.window ).Handle;
          this.screen = Screen.FromHandle( hwnd );
        }
        return this.screen;
      }
    } // Screen

    // ----------------------------------------------------------------------
    public static string GetSettings( DependencyObject dependencyObject )
    {
      return dependencyObject.GetValue( SettingsProperty ) as string;
    } // SetSettings

    // ----------------------------------------------------------------------
    public static void SetSettings( DependencyObject dependencyObject, string settingsKey )
    {
      dependencyObject.SetValue( SettingsProperty, settingsKey );
    } // SetSettings

    // ----------------------------------------------------------------------
    public static DependencyProperty GetCollectedSetting( DependencyObject dependencyObject )
    {
      return dependencyObject.GetValue( SettingsProperty ) as DependencyProperty;
    } // GetCollectedSetting

    // ----------------------------------------------------------------------
    public static void SetCollectedSetting( DependencyObject dependencyObject, DependencyProperty dependencyProperty )
    {
      dependencyObject.SetValue( SettingsProperty, dependencyProperty );
    } // SetCollectedSetting

    // ----------------------------------------------------------------------
    public static bool GetExcludeElement( DependencyObject obj )
    {
      return (bool)obj.GetValue( ExcludeElementProperty );
    } // GetExcludeElement

    // ----------------------------------------------------------------------
    public static void SetExcludeElement( DependencyObject obj, bool exclude )
    {
      obj.SetValue( ExcludeElementProperty, exclude );
    } // SetExcludeElement

    // ----------------------------------------------------------------------
    public override void Save()
    {
      if ( this.saveCondition.HasValue && this.saveCondition != this.window.DialogResult )
      {
        return;
      }
      base.Save();
    } // Save

    // ----------------------------------------------------------------------
    protected override void OnCollectingSetting( SettingCollectorCancelEventArgs e )
    {
      FrameworkElement frameworkElement = e.Element as FrameworkElement;
      if ( frameworkElement == null )
      {
        e.Cancel = true;
        return;
      }

      // exclusion
      object exclude = frameworkElement.ReadLocalValue( ExcludeElementProperty );
      if ( exclude != null && exclude.GetType() == typeof( bool ) && (bool)exclude )
      {
        e.Cancel = true;
        return;
      }

      base.OnCollectingSetting( e );
    } // OnCollectSettings

    // ----------------------------------------------------------------------
    private void WindowInitialized( object sender, EventArgs e )
    {
      if ( UseLocation )
      {
        AddPropertySetting( "Window.Top", this, "LocationY" );
        AddPropertySetting( "Window.Left", this, "LocationX" );
      }
      if ( UseSize )
      {
        AddDependencyPropertySetting( "Window.Width", this.window, FrameworkElement.WidthProperty );
        AddDependencyPropertySetting( "Window.Height", this.window, FrameworkElement.HeightProperty );
      }
      if ( UseWindowState )
      {
        AddDependencyPropertySetting( "Window.WindowState", this.window, Window.WindowStateProperty );
      }
      Load();
    } // WindowInitialized

    // ----------------------------------------------------------------------
    private void WindowLoaded( object sender, RoutedEventArgs e )
    {
      Load();
    } // WindowLoaded

    // ----------------------------------------------------------------------
    private void WindowClosing( object sender, CancelEventArgs e )
    {
      if ( this.saveOnClose == false )
      {
        return;
      }
      Save();
    } // WindowClosing

    // ----------------------------------------------------------------------
    private void AddPropertySetting( string name, object component, string propertyName )
    {
      PropertySetting propertySetting = new PropertySetting( name, component, propertyName );
      propertySetting.ValueSaving += new SettingValueCancelEventHandler( ValueSaving );
      Settings.Add( propertySetting );
    } // AddPropertySetting

    // ----------------------------------------------------------------------
    private void AddDependencyPropertySetting( string name, DependencyObject dependencyObject, DependencyProperty dependencyProperty )
    {
      DependencyPropertySetting propertySetting = new DependencyPropertySetting( name, dependencyObject, dependencyProperty );
      propertySetting.ValueSaving += new SettingValueCancelEventHandler( ValueSaving );
      Settings.Add( propertySetting );
    } // AddDependencyPropertySetting

    // ----------------------------------------------------------------------
    private void ValueSaving( object sender, SettingValueCancelEventArgs e )
    {
      if ( AllowMinimized == false && this.window.WindowState == WindowState.Minimized )
      {
        e.Cancel = true;
      }
    } // ValueSaving

    // ----------------------------------------------------------------------
    private static void OnWindowSettingsChanged( DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e )
    {
      Window window = dependencyObject as Window;
      if ( window == null )
      {
        Debug.WriteLine( "WindowSettings: invalid window" );
        return;
      }

      if ( window.GetValue( DependencyPropertySetting.ApplicationSettingsProperty ) != null )
      {
        return; // window contains already an application setting
      }

      string settingsKey = e.NewValue as string;
      if ( string.IsNullOrEmpty( settingsKey ) )
      {
        Debug.WriteLine( "WindowSettings: missing window settings key" );
        return;
      }

      // create and attach the application settings to the window
      WindowSettings windowSettings = new WindowSettings( window, settingsKey );
      window.SetValue( DependencyPropertySetting.ApplicationSettingsProperty, windowSettings );
    } // OnWindowSettingsChanged

    // ----------------------------------------------------------------------
    private static void OnCollectedSettingChanged( DependencyObject dependencyObject, DependencyPropertyChangedEventArgs e )
    {
      FrameworkElement frameworkElement = dependencyObject as FrameworkElement;
      if ( frameworkElement == null )
      {
        Debug.WriteLine( "WindowSettings: invalid framework element" );
        return;
      }

      DependencyProperty dependencyProperty = e.NewValue as DependencyProperty;
      if ( dependencyProperty == null )
      {
        Debug.WriteLine( "WindowSettings: missing dependency property" );
        return;
      }

      // search the window settings
      WindowSettings windowSettings =
          frameworkElement.ReadLocalValue( DependencyPropertySetting.ApplicationSettingsProperty ) as WindowSettings;
      if ( windowSettings == null )
      {
        Debug.WriteLine( "WindowSettings: missing window settings in element " + frameworkElement );
        return;
      }

      DependencyPropertySettingCollector collector = 
        new DependencyPropertySettingCollector( frameworkElement, dependencyProperty );
      windowSettings.SettingCollectors.Add( collector );
    } // OnCollectedSettingChanged

    // ----------------------------------------------------------------------
    // members
    private readonly Window window;
    private Screen screen;
    private bool? saveCondition;
    private bool saveOnClose;

  } // class WindowSettings

} // namespace Itenso.Configuration
// -- EOF -------------------------------------------------------------------

Is it possible to test this extension in your environment using one or two monitors?
If it works, I will include this addition to the library. Please note, that you have to include references to System.Drawing and System.Windows.Forms.

Cheers,
Jani [My Articles]

amr_tsc

11:35 16 Mar '09

Hi Jani,

Thanks for taking a look at this. Unfortunately, as implemented, this code does not work for me. Previously, on a dual monitor system, it used to restore the position/size correctly, but did not handle the case where the saved location was on a screen that now no longer exists. Now, it does not restore to the secondary monitor at all. The problem seems to be in the logic of the Screen property.

Here's how I have approached the solution in the past:
1) Read in the location and size of the window from the config file.
2) Iterate through all the currently available screens in Screen.AllScreens.
3) If the left,top of the saved coordinates now no longer falls within the boundaries of one of the screens, force the window to Screen.PrimaryScreen at the same coordinates.
4) If the size of window is now larger than the bounds of the screen it's on, resize to fit.

Is there a way for your code to fire an event after reading a setting from the config file but before setting the bound class member or dependency property? I would use this event to validate and/or rewrite the setting value as necessary.

Also, is there a way to read/write a complex piece of data such as a System.Drawing.Point all at once? The idea would be to allow validation of the data once all member have been read, rather than having to validate X and Y separately, for example.

Thanks again for your time, Jani,
Andy

Re: Multi-Monitor Support?

Howto bind different properties to the same setting

0:37 17 Mar '09

Hi Andy,

Thanks for this clarification.

amr_tsc wrote:
Is there a way for your code to fire an event after reading a setting from the config file but before setting the bound class member or dependency property? I would use this event to validate and/or rewrite the setting value as necessary.

Setting.ValueSaving and Setting.ValueLoading allows to trigger the save/load process. Unfortunately the WindowSettings class generates the settings on the fly. I have added the following extensions:
- ApplicationSettings provides new events SettingsSaving and SettingLoading
- WindowSettings provides access to all settings

The update will be available during the next days.

amr_tsc wrote:
Also, is there a way to read/write a complex piece of data such as a System.Drawing.Point all at once? The idea would be to allow validation of the data once all member have been read, rather than having to validate X and Y separately, for example.

You have this options:
- generate a custom setting class for Point/WindowLocation (see example ListViewSetting)
- use a custom property to save/restore the window location:

// ----------------------------------------------------------------------
public MyWindow()
{
  this.windowSettings = new WindowSettings( this );
  this.windowSettings.UseLocation = false; // disable build-in save/load
  // ...
  this.windowSettings.Settings.Add(
    new PropertySetting( "Window.Location", this, "WindowLocation" ) );
} // MyWindow
 
// ----------------------------------------------------------------------
public string WindowLocation
{
  get { return string.Concat( Left.ToString(), ";", Top.ToString() ); }
  set
  {
    if ( string.IsNullOrEmpty( value ) )
    {
      return;
    }
    string[] tokens = value.Split( ';' );
    if ( tokens.Length == 2 )
    {
      Left = double.Parse( tokens[ 0 ] );
      Top = double.Parse( tokens[ 1 ] );
    }
  }
} // WindowLocation

You can also add the current screen index to save/restore the window location (something like ScreenIndex:Left;Top).

Cheers,
Jani

Cheers,
Jani [My Articles]

deep42

5:36 5 Aug '08

Hi, first of all, thank you for the great article and the wonderful piece of C# code. Second I have a question. I would like to bind different properties to the same setting. For example the Checked properties of a MenuItem and a ToolbarButton. So for example any change of ToolbarItem.Checked would immediately be seen on the MenuItem and vice versa. Any chance to do this? Regards Peter
Sign In·View Thread·PermaLink

Re: Howto bind different properties to the same setting

Re: Howto bind different properties to the same setting

10:46 5 Aug '08

Hi Peter,

Thanks for the positive feedback. Big Grin

For this situation, I would recommend to use the Command Pattern.
For WPF applications you can read my article WPF Command-Pattern Applied[^].

For Windows Forms applications you can implement a command as follows:

// ------------------------------------------------------------------------
public abstract class Command : INotifyPropertyChanged
{
  
  // ----------------------------------------------------------------------
  public event PropertyChangedEventHandler PropertyChanged;
  
  // ----------------------------------------------------------------------
  public abstract void Execute();
 
  // ----------------------------------------------------------------------
  public bool? IsAvailable
  {
    get { return this.isAvailable; }
    set 
    { 
      if ( this.isAvailable != value )
      {
        this.isAvailable = value; 
        OnPropertyChanged( new PropertyChangedEventArgs( "IsAvailable" ) );
      }
    }
  } // IsAvailable
  
  // ----------------------------------------------------------------------
  protected void OnPropertyChanged( PropertyChangedEventArgs e )
  {
    if ( PropertyChanged != null )
    {
      PropertyChanged( this, e );
    }
  } // OnPropertyChanged
  
  // ----------------------------------------------------------------------
  // membres
  private bool? isAvailable;
  
} // Command
  
// ------------------------------------------------------------------------
public class CheckedCommand : Command
{
  
  // ----------------------------------------------------------------------
  public bool? IsChecked
  {
    get { return this.isChecked; }
    set 
    { 
      if ( this.isChecked != value )
      {
        this.isChecked = value;
        OnPropertyChanged( new PropertyChangedEventArgs( "IsChecked" ) );
      }
    }
  } // IsChecked
  
  // ----------------------------------------------------------------------
  public override void Execute()
  {
    IsChecked = !IsChecked;
  } // Execute
  
  // ----------------------------------------------------------------------
  // members
  private bool? isChecked;
  
} // class CheckedCommand
  
// ------------------------------------------------------------------------
public abstract class CommandBinding
{
  
  // ----------------------------------------------------------------------
  protected CommandBinding( object target, Command command )
  {
    if ( target == null )
    {
      throw new ArgumentNullException( "target" );
    }
    if ( command == null )
    {
      throw new ArgumentNullException ("command" );
    }
  
    this.target = target;
    this.command = command;
    this.command.PropertyChanged += new PropertyChangedEventHandler( CommandPropertyChanged );
  } // CommandBinding
  
  // ----------------------------------------------------------------------
  public object Target
  {
    get { return this.target; }
  } // Target
  
  // ----------------------------------------------------------------------
  public Command Command
  {
    get { return this.command; }
  } // Command
  
  // ----------------------------------------------------------------------
  public void Execute()
  {
    this.command.Execute();
  } // Execute
  
  // ----------------------------------------------------------------------
  protected virtual void OnCommandPropertyChanged( PropertyChangedEventArgs e )
  {
  } // OnCommandPropertyChanged
  
  // ----------------------------------------------------------------------
  private void CommandPropertyChanged( object sender, PropertyChangedEventArgs e )
  {
    OnCommandPropertyChanged( e );
  } // CommandPropertyChanged
  
  // ----------------------------------------------------------------------
  // members
  private readonly object target;
  private readonly Command command;
  
} // class CommandBinding
  
// ------------------------------------------------------------------------
public class ToolStripMenuItemCommandBinding : CommandBinding
{
  
  // ----------------------------------------------------------------------
  public ToolStripMenuItemCommandBinding( ToolStripMenuItem menuItem, Command command )
    : base( menuItem, command )
  {
    menuItem.Click += new EventHandler( ToolStripMenuItemClick );
  } // ToolStripMenuItemCommandBinding
  
  // ----------------------------------------------------------------------
  public ToolStripMenuItem ToolStripMenuItem
  {
    get { return Target as ToolStripMenuItem; }
  } // ToolStripMenuItem
  
  // ----------------------------------------------------------------------
  protected override void OnCommandPropertyChanged( PropertyChangedEventArgs e )
  {
    switch ( e.PropertyName )
    {
      case "IsAvailable":
        ToolStripMenuItem.Enabled = Command.IsAvailable.Value;
        break;
      case "IsChecked":
        if ( Command is CheckedCommand )
        {
          ToolStripMenuItem.Checked = ( (CheckedCommand)Command ).IsChecked.Value;
        }
        break;
    }
  } // OnCommandPropertyChanged
  
  // ----------------------------------------------------------------------
  private void ToolStripMenuItemClick( object sender, EventArgs e )
  {
    Execute();
  } // ToolStripMenuItemClick
  
} // class ToolStripMenuItemCommandBinding
  
// ------------------------------------------------------------------------
public class ToolStripButtonCommandBinding : CommandBinding
{
  
  // ----------------------------------------------------------------------
  public ToolStripButtonCommandBinding( ToolStripButton toolStripButton, Command command )
    : base( toolStripButton, command )
  {
    toolStripButton.Click += new EventHandler( ToolStripButtonClick );
  } // ToolStripButtonCommandBinding
  
  // ----------------------------------------------------------------------
  public ToolStripButton ToolStripButton
  {
    get { return Target as ToolStripButton; }
  } // ToolStripButton
  
  // ----------------------------------------------------------------------
  protected override void OnCommandPropertyChanged( PropertyChangedEventArgs e )
  {
    switch ( e.PropertyName )
    {
      case "IsAvailable":
        ToolStripButton.Enabled = Command.IsAvailable.Value;
        break;
      case "IsChecked":
        if ( Command is CheckedCommand )
        {
          ToolStripButton.Checked = ( (CheckedCommand)Command ).IsChecked.Value;
        }
        break;
    }
  } // OnCommandPropertyChanged
  
  // ----------------------------------------------------------------------
  private void ToolStripButtonClick( object sender, EventArgs e )
  {
    Execute();
  } // ToolStripButtonClick
  
} // class ToolStripButtonCommandBinding

To use the command create a new Form with a ToolStripMenuItem and a ToolStripButton. In code behind you can bind the UI elements to the command:

// ------------------------------------------------------------------------
public partial class Form1 : Form
{
  
  // ----------------------------------------------------------------------
  public Form1()
  {
    InitializeComponent();
  
    new ToolStripMenuItemCommandBinding( italicToolStripMenuItem, italicCommand );
    new ToolStripButtonCommandBinding( italicToolStripButton, italicCommand );
  
    this.italicCommand.IsChecked = false;
    //this.italicCommand.IsAvailable = false; // test disabled state
  } // Form1
  
  // ----------------------------------------------------------------------
  // members
  private CheckedCommand italicCommand = new CheckedCommand();
  
} // class Form1

Now you can derive custom Command classes, build your custom CommandBinding to any UI element - and finally - bind the PropertySetting to the property italicCommand.IsChecked.

Hope this helps.
Regards,
Jani

deep42

23:28 6 Aug '08

Jani,

thank you for your detailed and sophisticated answer, which shows me, that I made a mistake in trying do bind the setting direct to a property of an UI element.

Thats just nonsense. I think, it is better to create one or more classes, lets call them configuration classes, which holds the configuration data. Then bind the settings stuff to the propeties of the configuration classes.

And because I am already using the command pattern for all the UI stuff, the commands set the configuration classes properties.

My configuration classes now implement the INotifyPropertyChanged (thanks for the idea), so I can bind my UI components directly to these configuration classes, so that any configuration changes are reflected immediatly in the UI.

Thanks again
Peter

Combobox Settings

8:04 18 Jul '08

Jani, Could you provide an example on how to apply the settings for a combo box as the collectedSettings? Thanks, Wei
Sign In·View Thread·PermaLink

8:14 20 Jul '08

Hi Wei,

Please try:

  // ------------------------------------------------------------------------
  public partial class MyForm : Form
  {
 
    // ----------------------------------------------------------------------
    public MyForm()
    {
      InitializeComponent();
      FormSettings formSettings = new FormSettings( this );
      formSettings.SettingCollectors.Add( new PropertySettingCollector
            ( this, typeof( ComboBox ), "SelectedText" ) );
    } // MyForm
 
  } // class MyForm

Regards,
Jani

6:30 21 Jul '08

For WPF, the code may look like as the following: 6 7 8 9 <combobox&> public partial class myWindow : Window { public myWindow() { InitializeComponent(); FrameworkElementSettings settings = new FrameworkElementSettings(this); settings.SettingCollectors.Add(new PropertySettingCollector(this, typeof(ComboBox), "SelectedIndex")); } } Please advise why this doesn't work.
Sign In·View Thread·PermaLink

6:06 22 Jul '08

Hi Wei,

For the WPF ComboBox try this in XAML:

  <ComboBox
    x:Name="MyComboBox"
    IsSynchronizedWithCurrentItem="True">
    <ComboBoxItem>6</ComboBoxItem>
    <ComboBoxItem>7</ComboBoxItem>
    <ComboBoxItem>8</ComboBoxItem>
    <ComboBoxItem>9</ComboBoxItem>
  </ComboBox>

... and this in code behind:

  // ------------------------------------------------------------------------
  public partial class MyWindow : Window
  {
  
    // ----------------------------------------------------------------------
    public MyWindow()
    {
      WindowSettings windowSettings = new WindowSettings( this );
      windowSettings.SettingCollectors.Add( new DependencyPropertySettingCollector
        ( this, ComboBox.TextProperty ) );
    } // MyWindow
  
  } // class MyWindow

Regards,
Jani

6:39 1 Aug '08

Hi Jani, Tried adding the following code to your file: XamlUserSettingsWindow.xaml below the last . Please check why it doesn't work. <ComboBox SelectedIndex="1" Margin="5,0,0,0" IsSynchronizedWithCurrentItem="True" x:Name="MyComboBox"> <ComboBoxItem>C# Corner</ComboBoxItem> <ComboBoxItem>Longhorn Corner</ComboBoxItem> <ComboBoxItem>.NET Heaven</ComboBoxItem> </ComboBox> Wei
Sign In·View Thread·PermaLink

20:44 1 Aug '08

Hi Wei,

In this sample you have to replace the Window attribute

config:WindowSettings.CollectedSetting="{x:Static CheckBox.IsCheckedProperty}"

with

config:WindowSettings.CollectedSetting="{x:Static ComboBox.TextProperty}"

In case you have multiple collected settings, I suggest to use the code behind approach.

Regards,
Jani

7:29 11 Aug '08

Hi Jani, It seems a WPF ComboBox doesn't have the TextProperty. Or do I miss somthing? Thanks, Wei
Sign In·View Thread·PermaLink

7:41 11 Aug '08

Hi Wei, Take a look at MSDN[^]. Regards, Jani
Sign In·View Thread·PermaLink

8:11 11 Aug '08

Hi Jani,

This TextProperty can't be used as a method. Smile

Please see the following compiler error:

public XamlUserSettingsWindow()
{
InitializeComponent();
WindowSettings windowSettings = new WindowSettings(this);
windowSettings.SettingCollectors.Add(new DependencyPropertySettingCollector(this, MyComboBox.TextProperty));
} // XamlUserSettingsWindow

Error 1 Non-invocable member 'System.Windows.Controls.ComboBox.TextProperty' cannot be used like a method.
...\Projects\UserSettingSApplied\ConfigurationWindowsDemo\XamlUserSettingsWindow.xaml.cs 25 106 ConfigurationWindowsDemo

Re: Combobox Settings [modified]

10:01 11 Aug '08

Hi Wei,

In case of collected settings, you have to register the type property:

public XamlUserSettingsWindow()
{
  InitializeComponent();
  
  WindowSettings windowSettings = new WindowSettings( this );
  windowSettings.SettingCollectors.Add( new DependencyPropertySettingCollector( this, ComboBox.TextProperty ) );
} // XamlUserSettingsWindow

Hope this helps Smile

.

Regards,
Jani

Binding control properties

10:55 11 Aug '08

It works VERY WELL. Thank you - Jani. Please ignore the message earlier since it works great after a bug was fixed. Regards, Wei modified on Monday, August 11, 2008 5:31 PM
Sign In·View Thread·PermaLink

Giorgi Dalakishvili

4:38 16 Jul '08

Hello, Nice article! It would be nice if it was possible to have the code automatically generated by binding control properties to settings from properties windows like it is done when using built in settings. Giorgi Dalakishvili #region signature my articles #endregion
Sign In·View Thread·PermaLink

Re: Binding control properties