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;
  }
}

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

namespace Lime49.WPF {
    /// <summary>
    /// Tray minimization utility, based on Delay's code - http://blogs.msdn.com/delay/.
    /// </summary>
    public static class TrayMinimizer {
        /// <summary>
        /// Enables "minimize to tray" behavior for the specified Window.
        /// </summary>
        /// <param name="window">Window to enable the behavior for.</param>
        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);
            }
        }

 
        /// <summary>
        /// Disables "minimize to tray" behavior for the specified Window.
        /// </summary>
        /// <param name="window">Window to enable the behavior for.</param>
        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;
        /// <summary>
        /// Gets or sets the windows for which tray minimization is currently enabled.
        /// </summary>
        /// <value>The windows for which tray minimization is currently enabled.</value>
        private static Dictionary<Window, MinimizeToTrayInstance> MinimizeInstances {
            get {
                if(_minimizeInstances == null) {
                    _minimizeInstances = new Dictionary<Window, MinimizeToTrayInstance>();
                }
                return _minimizeInstances;
            }
            set { _minimizeInstances = value; }
        }
 
        /// <summary>
        /// Allows minimization of a window to the tray.
        /// </summary>
        private class MinimizeToTrayInstance {
            private Window _window;
            private NotifyIcon _notifyIcon;
 
            /// <summary>
            /// Initializes a new instance of the MinimizeToTrayInstance class.
            /// </summary>
            /// <param name="window">Window instance to attach to.</param>
            public MinimizeToTrayInstance(Window window) {
                if(window == null)
                    throw new ArgumentException("window parameter is null.");
                _window = window;
            }
 
            /// <summary>
            /// Enables minimization for this Window.
            /// </summary>
            public void Enable() {
                _window.StateChanged += new EventHandler(HandleStateChanged);
            }
 
            /// <summary>
            /// Disables minimization for this Window.
            /// </summary>
            public void Disable() {
                _window.StateChanged -= new EventHandler(HandleStateChanged);
            }
 
            /// <summary>
            /// Handles the Window's StateChanged event.
            /// </summary>
            /// <param name="sender">The sender.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
            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();
                }
            }
 
            /// <summary>
            /// Restores a window when the notify icon or its balloon are clicked.
            /// </summary>
            /// <param name="sender">The sender.</param>
            /// <param name="e">The <see cref="System.EventArgs"/> instance containing the event data.</param>
            private void HandleNotifyIconOrBalloonClicked(object sender, EventArgs e) {
                _window.WindowState = WindowState.Normal;
            }
        }
        #endregion
    }
}

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

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

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

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

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

<xcdg:Column.CellEditor>
    <xcdg:CellEditor>
        <xcdg:CellEditor.EditTemplate>
            <DataTemplate>
                <ComboBox x:Name="cboMeasurement" IsVisibleChanged="cbo_IsVisibleChanged"
                      ItemsSource="{Binding Collection,Source={StaticResource measurementProvider}}" SelectedValue="{xcdg:CellEditorBinding}" IsEditable="True" Foreground="Black" IsSynchronizedWithCurrentItem="True" />
            </DataTemplate>
        </xcdg:CellEditor.EditTemplate>
    </xcdg:CellEditor>
</xcdg:Column.CellEditor>

/// <summary>
/// Adds a new measurement to the list of available measurements when a new value is typed.
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="System.Windows.DependencyPropertyChangedEventArgs"/> instance containing the event data.</param>
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;
        }
    }
}

private bool firstEdit = true;
 
private void InsertionRow_Loaded(object sender, RoutedEventArgs e) {
    insertionRow = sender as BetterInsertionRow;
}
 
/// <summary>
/// Adds a new measurement to the list of available measurements when a new value is typed.
/// </summary>
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;
        }
    }
}

/// <summary>
/// Focuses the next row when enter or return is pressed
/// </summary>
/// <param name="sender">The source of the event.</param>
/// <param name="e">The <see cref="Microsoft.Windows.Controls.DataGridRowEditEndingEventArgs"/> instance containing the event data.</param>
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 });
        }
    }
}

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

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

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

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);
        }
    };
}

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);
    }
}

// fills remaining width in the ListView
<GridViewColumn Width="{Binding RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type ListView}},Converter={StaticResource WidthConverter}}">

// fills remaining width in the ListView, unless the remaining width is less than the parameter
<GridViewColumn Width="{Binding RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type ListView}},Converter={StaticResource WidthConverter},ConverterParameter=200}">

// calculates 30% of the ListView width
<GridViewColumn Width="{Binding RelativeSource={RelativeSource FindAncestor,AncestorType={x:Type ListView}},Converter={StaticResource WidthConverter},ConverterParameter=0.3*}">

/// <summary>
/// Calculates the column width required to fill the view in a GridView
/// For usage examples, see http://leghumped.com/blog/2009/03/11/wpf-gridview-column-width-calculator/
/// </summary>
public class WidthConverter : IValueConverter {
    /// <summary>
    /// Converts the specified value.
    /// </summary>
    /// <param name="value">The parent Listview.</param>
    /// <param name="type">The type.</param>
    /// <param name="parameter">
    /// If no parameter is given, the remaning with will be returned.
    /// If the parameter is an integer acts as MinimumWidth, the remaining with will be returned only if it's greater than the parameter
    /// If the parameter is anything else, it's taken to be a percentage. Eg: 0.3* = 30%, 0.15* = 15%
    /// </param>
    /// <param name="culture">The culture.</param>
    /// <returns>The width, as calculated by the parameter given</returns>
    public object Convert(object value, Type type, object parameter, CultureInfo culture) {
        if(value == null) return null;
        ListView listView = value as ListView;
        GridView grdView = listView.View as GridView;
        int minWidth = 0;
        bool widthIsPercentage = parameter != null && !int.TryParse(parameter.ToString(), out minWidth);
        if(widthIsPercentage) {
            string widthParam = parameter.ToString();
            double percentage = double.Parse(widthParam.Substring(0, widthParam.Length - 1));
            return listView.ActualWidth * percentage;
        } else {
            double total = 0;
            for(int i = 0; i < grdView.Columns.Count - 1; i++) {
                total += grdView.Columns[i].ActualWidth;
            }
            double remainingWidth = listView.ActualWidth - total;
            if(remainingWidth > minWidth) { // fill the remaining width in the ListView
                return remainingWidth;
            } else { // fill remaining space with MinWidth
                return minWidth;
            }
        }            
    }
 
    public object ConvertBack(object o, Type type, object parameter, CultureInfo culture) {
        throw new NotSupportedException();
    }
}