LegHumped.com » WPF » Leghumped

WPF: Radio Toggle Button

Harry Jennerway — Sun, 24 Apr 2011 20:29:42 +0000

There are times when you might want to display a toggle switch to let the user pick between one or more views. The easiest way to implement this in WPF is with RadioButtons and custom templates. Persistence can easily be added by binding to an application settings resource, as in the example below.

The first thing you need is a custom control. This just needs to inherit from RadioButton, I added a few extra properties to make adding images easier.

namespace Lime49.UI {
    /// 
    /// A button which can be assigned an image
    /// 
    public class RadioImageButton : RadioButton {
        public static readonly DependencyProperty ImageLocationProperty = DependencyProperty.Register("ImageLocation", typeof(PlacementMode), typeof(RadioImageButton), new UIPropertyMetadata(PlacementMode.Left));
        /// 
        /// Gets or sets the position of the image in relative to the text.
        /// 
        /// The image.
        public PlacementMode ImageLocation {
            get { return (PlacementMode)base.GetValue(ImageLocationProperty); }
            set { base.SetValue(ImageLocationProperty, value); }
        }
 
        public static readonly DependencyProperty ImageProperty = DependencyProperty.Register("Image", typeof(ImageSource), typeof(RadioImageButton));
        /// 
        /// Gets or sets the image to display.
        /// 
        /// The image.
        public ImageSource Image {
            get { return base.GetValue(ImageProperty) as ImageSource; }
            set { base.SetValue(ImageProperty, value); }
        }
 
        public static readonly DependencyProperty TextProperty = DependencyProperty.Register("Text", typeof(string), typeof(RadioImageButton));
        /// 
        /// Gets or sets the text.
        /// 
        /// The text.
        public string Text {
            get { return base.GetValue(TextProperty) as string; }
            set { base.SetValue(TextProperty, value); }
        }
 
        public static readonly DependencyProperty ShowTextProperty = DependencyProperty.Register("ShowText", typeof(bool), typeof(RadioImageButton), new UIPropertyMetadata(true));
        /// 
        /// Gets or sets whether to show the text.
        /// 
        /// true if the text should be shown, otherwise false.
        public bool ShowText {
            get { return (bool)base.GetValue(ShowTextProperty); }
            set { base.SetValue(ShowTextProperty, value); }
        }
 
        public static readonly DependencyProperty AlwaysShowBorderProperty = DependencyProperty.Register("AlwaysShowBorder", typeof(bool), typeof(RadioImageButton));
        /// 
        /// Gets or sets whether to always show the border.
        /// 
        /// true if the border should be shown, otherwise false.
        public bool AlwaysShowBorder {
            get { return (bool)base.GetValue(AlwaysShowBorderProperty); }
            set { base.SetValue(AlwaysShowBorderProperty, value); }
        }
    }
}

The control template just needs to take these properties and display them. Ie (Visual Statemanager states omitted for brevity):

Then in your Window/Page you can use the following to quickly insert a RadioButton which is bound to the AppSettings collection and will persist it’s state:

private void btnChangeView_Checked(object sender, RoutedEventArgs e) {
    if (!IsLoaded)
        return;

Checkbox to Select in WPF Datagrid

Harry Jennerway — Thu, 17 Mar 2011 13:16:40 +0000

There are several datagrids available for WPF, but in my experience the best free one is the one included in .NET 4 (formerly the WPF toolkit). A fairly common task which I use in dialogs is using a checkbox to allow selection of items. This isn’t as trivial as it appears with the WPF datagrid, but it is possible.

The first thing you need is an extended DataGrid control which includes a handler for the OnPreviewMouseLeftButtonDown event which listens for mouse clicks, then if the clicked cell contains a checkbox, places the cell in edit mode and toggles the checkbox.

public class CheckboxDataGrid : DataGrid
{
    public CheckboxDataGrid()
    {
        EventManager.RegisterClassHandler(typeof(DataGridCell),
            DataGridCell.PreviewMouseLeftButtonDownEvent,
            new RoutedEventHandler(this.OnPreviewMouseLeftButtonDown));
    }
 
 
    private void OnPreviewMouseLeftButtonDown(object sender, RoutedEventArgs e)
    {
        DataGridCell cell = sender as DataGridCell;
        if (cell != null && !cell.IsEditing && !cell.IsReadOnly)
        {
 
                var parentRow = cell.Parent as DataGridRow;
                if (parentRow != null)
                {
                    SelectedIndex = parentRow.GetIndex();
                }
                CurrentCell = new DataGridCellInfo(cell);
                BeginEdit(e);
         DependencyObject obj = FindVisualChild<CheckBox>(cell);
            if (obj != null) {
                System.Windows.Controls.CheckBox cb = (System.Windows.Controls.CheckBox)obj;
                cb.Focus();
                cb.IsChecked = !cb.IsChecked;
            }
        }
    }
    public static TChild FindVisualChild<TChild>(DependencyObject obj) where TChild : DependencyObject {
        for(int i = 0; i < VisualTreeHelper.GetChildrenCount(obj); i++) {
            DependencyObject child = VisualTreeHelper.GetChild(obj, i);
            if(child != null && child is TChild) {
                return (TChild)child;
            } else {
                TChild childOfChild = FindVisualChild<TChild>(child);
                if(childOfChild != null)
                    return childOfChild;
            }
        }
        return null;
    }
}

 x:Name="dgCategories" DockPanel.Dock="Bottom" AutoGenerateColumns="False" CanUserAddRows="False" CanUserDeleteRows="False" VerticalAlignment="Stretch" SelectionMode="Single" 
    SelectionUnit="FullRow" CanUserSortColumns="True" EnableRowVirtualization="True" GridLinesVisibility="Horizontal"
    ItemsSource="{Binding Path=Categories,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" HeadersVisibility="Column" 
    ScrollViewer.VerticalScrollBarVisibility="Auto" ScrollViewer.CanContentScroll="True" SelectedValuePath="CategoryID">
    >
         Width="18">
            >
                >
                     IsChecked="{Binding IsSelected}" IsEnabled="False"/>
                >
            >
            >
                >
                     IsChecked="{Binding IsSelected,Mode=TwoWay,UpdateSourceTrigger=PropertyChanged}" Checked="chkCategories_CheckedStateChanged" Unchecked="chkCategories_CheckedStateChanged"/>
                >
            >
        >

IsSelected is a property of the objects to which the grid is bound.

While this gets you 99% of the way there, the only situation it doesn’t work in is uopdating the last checked item. Eg: If a row is checked, then a button is clicked which closes the dialog, the item won’t be updated because the cell is still in edit mode. To update the item instantly, the handler for the checkbox’s Checked and Unchecked event also toggles the selection.

private void chkCategories_CheckedStateChanged(object sender, RoutedEventArgs e)
{
    var cat = (dgCategories.CurrentItem as SelectableCategory);
    var checkBox = sender as CheckBox;
    if (cat != null && checkBox != null)
    {
        cat.IsSelected = checkBox.IsChecked == true;
    }
}

Watermarked TextBox with an AttachedProperty

Harry Jennerway — Sun, 07 Feb 2010 12:11:16 +0000

Ever wanted to create a watermark effect for a TextBox in WPF? Most of the tutorials scattered around have either used static text or created a subclass of TextBox. I wanted to use an AttachedProperty instead, and though it took a while to try every possible combination of brackets and bindings I came up with the following to create an AttachedProperty which you can apply in any ResourceDictionary or wherever you keep your Styles.

Get the code after the jump.

public class WatermarkedTextBox
{
  public static readonly DependencyProperty WatermarkProperty = DependencyProperty.RegisterAttached("Watermark", typeof(string), typeof(WatermarkedTextBox));
 
  public static void SetWatermark(TextBox element, string watermark) {
    element.SetValue(WatermarkProperty, watermark);
  }
 
  public static string GetWatermark(UIElement element) {
    return element.GetValue(WatermarkProperty) as string;
  }
}

You need to include the namespace for whichever assemly contains the AttachedProperty (l49ui in my case).

 TargetType="{x:Type TextBoxBase}" x:Key="{x:Type TextBox}">
   Property="Template">
    >
       TargetType="{x:Type TextBoxBase}">
        >
           Margin="0" x:Name="PART_ContentHost" Background="Transparent"/>
           x:Name="watermark" Opacity="0.3"
             Text="{Binding (l49ui:WatermarkedTextBox.Watermark),RelativeSource={RelativeSource TemplatedParent}}"
             TextWrapping="Wrap"
             Visibility="Collapsed" />
        >
        >
          >
            >
               Property="IsFocused" Value="False" />
               Property="TextBox.Text" Value="" />
            >
             Property="Visibility" TargetName="watermark" Value="Visible" />
          >
        >
      >
    >
  >
>

Minimize To Tray with WPF

Harry Jennerway — Sat, 19 Dec 2009 12:09:43 +0000

I’ve been working on porting LockCrypt to WPF from Java and was pretty shocked to find there was no no built-in support. It’s entirely possible, but you have to use WinForms. I based this on Delay‘s sample, feel free to use it however you wish.

namespace Lime49.WPF {
    /// 
    /// Tray minimization utility, based on Delay's code - http://blogs.msdn.com/delay/.
    /// 
    public static class TrayMinimizer {
        /// 
        /// Enables "minimize to tray" behavior for the specified Window.
        /// 
        /// Window to enable the behavior for.
        public static void EnableMinimizeToTray(Window window) {
            if(MinimizeInstances.ContainsKey(window)) {
                Console.WriteLine(string.Format("Minimization already enabled for '{0}'", window.Title));
            } else {
                var instance = new MinimizeToTrayInstance(window);
                instance.Enable();
                MinimizeInstances.Add(window, instance);
            }
        }

 
        /// 
        /// Disables "minimize to tray" behavior for the specified Window.
        /// 
        /// Window to enable the behavior for.
        public static void DisableMinimizeToTray(Window window) {
            if(!MinimizeInstances.ContainsKey(window)) {
                Console.WriteLine(string.Format("Minimization not enabled for '{0}'", window.Title));
            } else {
                var instance = MinimizeInstances[window];
                instance.Disable();
                MinimizeInstances.Remove(window);
            }
        }
 
        private static Dictionary<Window, MinimizeToTrayInstance> _minimizeInstances;
        /// 
        /// Gets or sets the windows for which tray minimization is currently enabled.
        /// 
        /// The windows for which tray minimization is currently enabled.
        private static Dictionary<Window, MinimizeToTrayInstance> MinimizeInstances {
            get {
                if(_minimizeInstances == null) {
                    _minimizeInstances = new Dictionary<Window, MinimizeToTrayInstance>();
                }
                return _minimizeInstances;
            }
            set { _minimizeInstances = value; }
        }
 
        /// 
        /// Allows minimization of a window to the tray.
        /// 
        private class MinimizeToTrayInstance {
            private Window _window;
            private NotifyIcon _notifyIcon;
 
            /// 
            /// Initializes a new instance of the MinimizeToTrayInstance class.
            /// 
            /// Window instance to attach to.
            public MinimizeToTrayInstance(Window window) {
                if(window == null)
                    throw new ArgumentException("window parameter is null.");
                _window = window;
            }
 
            /// 
            /// Enables minimization for this Window.
            /// 
            public void Enable() {
                _window.StateChanged += new EventHandler(HandleStateChanged);
            }
 
            /// 
            /// Disables minimization for this Window.
            /// 
            public void Disable() {
                _window.StateChanged -= new EventHandler(HandleStateChanged);
            }
 
            /// 
            /// Handles the Window's StateChanged event.
            /// 
            /// The sender.
            /// The  instance containing the event data.
            private void HandleStateChanged(object sender, EventArgs e) {
                if(_notifyIcon == null) {
                    _notifyIcon = new NotifyIcon();
                    _notifyIcon.Icon = Icon.ExtractAssociatedIcon(Assembly.GetEntryAssembly().Location);
                    _notifyIcon.MouseClick += new System.Windows.Forms.MouseEventHandler(HandleNotifyIconOrBalloonClicked);
                    _notifyIcon.BalloonTipClicked += new EventHandler(HandleNotifyIconOrBalloonClicked);
                }
                _notifyIcon.Text = _window.Title;
 
                // Show/hide Window and NotifyIcon
                var minimized = (_window.WindowState == WindowState.Minimized);
                _window.ShowInTaskbar = !minimized;
                _notifyIcon.Visible = minimized;
                if(minimized && !Settings.Default.MinimizeBalloonShown) {
                    // If this is the first time minimizing to the tray, show the user what happened
                    _notifyIcon.ShowBalloonTip(1000, _window.Title, "I'm still running!", ToolTipIcon.None);
                    Settings.Default.MinimizeBalloonShown = true;
                    Settings.Default.Save();
                }
            }
 
            /// 
            /// Restores a window when the notify icon or its balloon are clicked.
            /// 
            /// The sender.
            /// The  instance containing the event data.
            private void HandleNotifyIconOrBalloonClicked(object sender, EventArgs e) {
                _window.WindowState = WindowState.Normal;
            }
        }
        #endregion
    }
}

WPF: TextBox Error Notification Through Style

Harry Jennerway — Mon, 07 Sep 2009 08:40:36 +0000

By default, WPF doesn’t provide any visual indication when ValidationRules aren’t met for TextBoxes. When I was learning WPF, I read a post about providing error notification for TextBoxes through the user of a style. I can’t find the article/post, but it never worked properly for me so I’ve modified and fixed what I had. This only works if there are ValidationRules bound to the TextBox, and it only displays the first failed rule.

 TargetType="{x:Type TextBoxBase}" x:Key="{x:Type TextBox}">
   Property="Margin" Value="2" />
   Property="SnapsToDevicePixels" Value="True"/>
   Property="OverridesDefaultStyle" Value="false"/>
   Property="KeyboardNavigation.TabNavigation" Value="None"/>
   Property="FocusVisualStyle" Value="{x:Null}"/>
   Property="MinWidth" Value="80"/>
   Property="MinHeight" Value="20"/>
   Property="AllowDrop" Value="true"/>
   Property="Background" Value="{StaticResource WindowBackgroundBrush}" />
   Property="BorderBrush" Value="{StaticResource SolidBorderBrush}" />
   Property="Template">
...

The rest is after the jump.

    >
       TargetType="{x:Type TextBoxBase}">
         Name="Border" CornerRadius="1" Padding="2"
                Background="{TemplateBinding Background}" BorderBrush="{TemplateBinding BorderBrush}" BorderThickness="1">
           Name="ErrorContainer">
               Margin="0" x:Name="PART_ContentHost" Background="Transparent"/>
          >
        >
        >
           Property="IsEnabled" Value="False">
             TargetName="Border" Property="Background" Value="{StaticResource DisabledBackgroundBrush}"/>
             Property="Foreground" Value="{StaticResource DisabledForegroundBrush}"/>
          >
           Property="Validation.HasError" Value="true">
               TargetName="PART_ContentHost" Property="ToolTip" Value="{Binding RelativeSource={RelativeSource Self},Path=(Validation.Errors)[0].ErrorContent}" />
               TargetName="ErrorContainer" Property="Padding" Value="0,0,18,0" />
               TargetName="ErrorContainer" Property="Background">
                  >
                       ImageSource="pack://application:,,,/Resources/images/error_16.png" Stretch="None" AlignmentX="Right" AlignmentY="Center" />
                  >
              >
          >
        >
      >
    >
  >
>

WPF: Changing Input Focus to Hidden Elements

Harry Jennerway — Fri, 31 Jul 2009 07:39:13 +0000

When trying to change the focused element in the WPF recipe management app I develop, ChickenPing, I recently ran into a problem. I wanted a shortcut key (Ctrl + something) to change the selected tab in a TabControl, then focus an element in that tab. There are a few ways you might try doing this, both do more or less the same thing and both will fail unless the tab in question is already selected. For example:

 tabControl.SelectedItem = someTab;
 someTextBox.Focus();
 FocusManager.SetFocusedElement(this, someTextBox);
 // both only work unless the tab which contains them is visible.

The problem is that an element can only be focused if it is visible. Making the item visible just before trying to focus it fails because the change hasn’t had time to take effect.

After trying different combinations and trawling, I found a method suggested by Mark Smith which used a delegate to wait for an element to load if it was not yet loaded. Taking this idea and using it instead for the IsVisibleChanged event did exactly when I needed.

tabControl.SelectedItem = someTab;
if(!someTextBox.IsVisible) {
    DependencyPropertyChangedEventHandler deferredFocus = null;
    deferredFocus = delegate {
        someTextBox.Focus();
        someTextBox.IsVisibleChanged -= deferredFocus;
    };
    someTextBox.IsVisibleChanged += deferredFocus;
} else {
    someTextBox.Focus();
}

No need to call Dispatcher.Invoke and run into complications with cross-thread access, in my tests it works perfectly.

TopMost Window In XAML

Harry Jennerway — Wed, 29 Jul 2009 12:41:48 +0000

I was kind of looking forward to delving into some native call to make a Window always on top in WPF, but it was actually surprisingly easy, a single binding in the Window’s declaration:

 ...
	Topmost="{Binding ElementName=itmTopMost,Path=IsChecked}"
...
	 Header="_Always on Top" x:Name="itmTopMost" IsCheckable="True" />

No code involved!

Editable ComboBox with XCeed DataGrid

Harry Jennerway — Sat, 13 Jun 2009 05:39:49 +0000

I’ve recently started using XCeed’s DataGrid for WPF instead of he WPF toolkit DataGrid because overall it seems to have more features. One of the problems which I couldn’t find any reference to was using editable comboboxes when editing an item. I’m using an ObjectDataProvider as the ItemsSource for a ComboBox, but I wanted to let a user type a value as well as select one from the list.

The solution I eventually used lets a user add an item to the list of items which can then be selected when editing other items in the DataGrid.

Once you’ve declared the ObjectDataProvider in XAML, you need a CellEditor template for the column which will use the ComboBox (code below).

>
    >
        >
            >
                 x:Name="cboMeasurement" IsVisibleChanged="cbo_IsVisibleChanged"
                      ItemsSource="{Binding Collection,Source={StaticResource measurementProvider}}" SelectedValue="{xcdg:CellEditorBinding}" IsEditable="True" Foreground="Black" IsSynchronizedWithCurrentItem="True" />
            >
        >
    >
>

In my example, measurementProvider is an ObjectDataProvider bound to a wrapper class containing a list of objects (of class Ingredient) in the Collection property. The event which adds a new item to the data source fires when the ComboBox loses visibility (because the row is exiting edit mode), then the new item is added with:

/// 
/// Adds a new measurement to the list of available measurements when a new value is typed.
/// 
/// The source of the event.
/// The  instance containing the event data.
private void cbo_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
    ComboBox cbo = sender as ComboBox;
    if(cbo != null && !Measurements.Contains(cbo.Text)) {
        string itm = cbo.Text.Trim();
        Measurements.Add(itm);
        Ingredient currentIngredient = dgIngredients.CurrentItem as Ingredient;
        if(currentIngredient != null) {
            currentIngredient.Measurement = itm;
        }
    }
}

Update 27th September 2009: This method introduces a bug with XCeed’s control which means that the first time a row is edited, the change from the ComboBox is not saved. For some reason, the ComboBox is not null, but it’s Text property is null.

After spending hours trying to start, then cancel an edit, cancelling edits and virtually everything else I used the following (hacky) solution.

private bool firstEdit = true;
 
private void InsertionRow_Loaded(object sender, RoutedEventArgs e) {
    insertionRow = sender as BetterInsertionRow;
}
 
/// 
/// Adds a new measurement to the list of available measurements when a new value is typed.
/// 
private void cbo_IsVisibleChanged(object sender, DependencyPropertyChangedEventArgs e) {
    if(firstEdit) {
        firstEdit = false;
        return;
    }
    ComboBox cbo = sender as ComboBox;
    if(cbo != null && !Measurements.Contains(cbo.Text)) {
        string itm = cbo.Text.Trim();
        Measurements.Add(itm);
        Ingredient currentIngredient;
        if(dgIngredients.CurrentItem != null) { // row being edited
            currentIngredient = dgIngredients.CurrentItem as Ingredient;
        } else { // insertionrow is in focus (new item being added)
            currentIngredient = insertionRow.DataContext as Ingredient;
        }
        if(currentIngredient != null) {
            currentIngredient.Measurement = itm;
        }
    }
}

This still doesn’t fix the problem, and seems to work intermittently, though it’s better than the default behaviour. The consequence is that the first time a row is edited, if a new item is added to the list, it’s not saved due to the text still being empty. Subsequent edits seem to work.

WPF: DataGrid And The Return Key

Harry Jennerway — Fri, 01 May 2009 17:57:47 +0000

A decent DataGrid is really the only thing WPF doesn’t have. The WPF Toolkit DataGrid is a great addition but it’s still lacking in a few places.

To me, it would seem natural for the Tab key to move to the next column and Enter to move to the next row, but there isn’t really support for this.

After experimenting with KeyUp and KeyDown events, I came up with the following method, based on a similar technique by Vincent Sibal. It makes the DataGrid more usable in my opinion.

/// 
/// Focuses the next row when enter or return is pressed
/// 
/// The source of the event.
/// The  instance containing the event data.
private void dgResources_RowEditEnding(object sender, DataGridRowEditEndingEventArgs e) {
    if(e.EditAction == DataGridEditAction.Commit && dgResources.SelectionUnit == DataGridSelectionUnit.Cell) {
        if(Keyboard.IsKeyDown(Key.Enter) || Keyboard.IsKeyDown(Key.Return)) {
            // get the row and column indexes of the currently selected cell
            int currentColIndex = dgResources.Columns.IndexOf(dgResources.CurrentColumn),
                currentRowIndex = dgResources.Items.IndexOf(e.Row.Item);
            var rowToSelect = dgResources.Items[currentRowIndex + 1]; // get the next row
            var colToSelect = dgResources.Columns[currentColIndex];
            int rowIndex = dgResources.Items.IndexOf(rowToSelect);
            // select the new cell
            dgResources.SelectedCells.Clear();
            dgResources.SelectedCells.Add(new DataGridCellInfo(rowToSelect, colToSelect));
            this.Dispatcher.BeginInvoke(new DispatcherOperationCallback((param) => {
                // get the new cell, set focus, then open for edit
                var cell = DataGridUtils.GetCell(dgResources, rowIndex, currentColIndex);
                cell.Focus();
                dgResources.BeginEdit();
                return null;
            }), DispatcherPriority.Background, new object[] { null });
        }
    }
}

I also found it difficult to select a control when a Cell enters edit mode, but after vastly overthinking the problem used the Initialized event of the TextBox in the CellEditingTemplate:

/// 
/// Focuses and selects all text in the TextBox used for editing when it is selected.
/// 
/// The source of the event.
/// The  instance containing the event data.
private void txt_Initialized(object sender, EventArgs e) {
    TextBox tb = sender as TextBox;
    if(tb != null) {
        tb.Focus();
        tb.SelectAll();
    }
}

C#: AutoSave with WPF

Harry Jennerway — Mon, 27 Apr 2009 07:22:32 +0000

Creating an automatic save for ResourceBlender Express was actually a lot easier than I thought it would be but I’ll post the source here for anyone else wondering how to do it.

My .xaml.cs file has four class variables to make it work, and the save method executes in a separate thread to prevent it locking the UI during saving (actually a BackgroundWorker).

BackgroundWorker worker;
DispatcherTimer timer;
int autoSaveInterval = 3000;
DateTime lastSave;

The DispatcherTimer times the save at a specified interval and the BackgroundWorker executes the operation. In the class constructor I setup the DispatchTimer:

public WinEditRbt() {
	...
	timer = new DispatcherTimer(TimeSpan.FromMilliseconds(autoSaveInterval), DispatcherPriority.Background, new EventHandler(DoAutoSave), this.Dispatcher);
}

I wanted to allow the user to save manually regardless of whether an autosave had just executed, but prevent autosaving if the user had just recently saved, so the DoWork delegate checks to see when the save method last executed before saving.

private void Save(object sender, ExecutedRoutedEventArgs e) {
    if(worker != null && worker.IsBusy) {
        while(worker.IsBusy) {
            Dispatcher.Invoke(DispatcherPriority.Background, new ThreadStart(delegate() { }));
        }
    }
    ...
    worker.DoWork += (s, dwe) => {
        DateTime dtStart = DateTime.Now;
	if((DateTime.Now - dtStart).TotalSeconds < 4) { // give the user chance to see the message
            worker.ReportProgress(0, "Save Complete");
            Thread.Sleep(2000);
        }
    };
}

Lambdas help minimize the amount of method garbage in the class by reducing the number of methods to one per worker task instead of three (ProgressChanged, DoWork and RunWorkerCompleted). To manually save, you just need to trigger the ApplicationCommands.Save command.

private void CanExecuteSave(object sender, CanExecuteRoutedEventArgs e) {
    e.CanExecute = this.IsLoaded && (worker == null || !worker.IsBusy);
}
 
private void DoAutoSave(object sender, EventArgs e) {
    if((worker == null || (worker != null && !worker.IsBusy)) && DateTime.Now.Subtract(lastSave).TotalMilliseconds >= autoSaveInterval) {
        ApplicationCommands.Save.Execute(null, this);
    }
}