Editable TextBlock in WPF for In-place Editing

private void m_treeView_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.F2)
            {
                EditableTextBlock etb = null;
                DataTemplate dt = m_treeView.ItemTemplate;
                StackPanel sp = dt.LoadContent() as StackPanel; --> To test null....
                UIElementCollection cool = sp.Children;
                for (int i = 0; i < cool.Count; i++)
                {
                    object o = cool[i];
                    if (o as EditableTextBlock != null)
                    { etb = o as EditableTextBlock; break; }
                }
 
                if (etb != null)
                {
                    if (etb.IsEditable)
                    { 
                        etb.EditMode = true
                    }
                }
            }
        }

<TreeView TreeViewItem.Selected="OnItemSelected" ... />
...
<local:EditableTextBlock Name="myEditableTextBlock" ... />

private void treeView1_KeyDown(object sender, KeyEventArgs e)
{
    if (e.Key == Key.F2)
    {
        TreeViewItem tvi = tree.Tag as TreeViewItem;
        EditableTextBlock etb = getEditableTextBlock(tvi);
        if (etb != null)
        {
            if (etb.IsEditable)
            {
                etb.IsInEditMode = true;
            }
        }
    }
}
 
private childItem FindVisualChild<childItem>(DependencyObject obj)
    where childItem : DependencyObject
{
    for (int i = 0; i < System.Windows.Media.VisualTreeHelper.GetChildrenCount(obj); i++)
    {
        DependencyObject child = System.Windows.Media.VisualTreeHelper.GetChild(obj, i);
        if (child != null && child is childItem)
            return (childItem)child;
        else
        {
            childItem childOfChild = FindVisualChild<childItem>(child);
            if (childOfChild != null)
                return childOfChild;
        }
    }
    return null;
}
 
protected EditableTextBlock getEditableTextBlock(TreeViewItem selectedTVI)
{
    // Getting the ContentPresenter of TreeViewItem
    ContentPresenter myContentPresenter = FindVisualChild<ContentPresenter>(selectedTVI);
    if (myContentPresenter == null)
        return null;
    // Finding EditableTextBlock from the DataTemplate that is set on that ContentPresenter
    DataTemplate myDataTemplate = myContentPresenter.ContentTemplate;
    EditableTextBlock editBox = myDataTemplate.FindName("myEditableTextBlock", myContentPresenter) as EditableTextBlock;
    return editBox;
}
 
private void OnItemSelected(object sender, RoutedEventArgs e)
{
    tree.Tag = e.OriginalSource;
}
 

<DataTemplate x:Key="DisplayModeTemplate">
            <TextBlock PreviewMouseDown="TextBlock_MouseDown" Text="{Binding ElementName=mainControl, Path=Text, Mode=TwoWay}" Margin="0" />
        </DataTemplate>

/// <summary>
/// The minimum time between the last click and the current one that will allow the user to edit the text block.
/// This will help prevent against accidental edits when they are double clicking.
/// </summary>
public double MinimumClickTime
{
    get { return (double)GetValue(MinimumClickTimeProperty); }
    set { SetValue(MinimumClickTimeProperty, value); }
}
 
/// <summary>
/// The maximum time between the last click and the current one that will allow the user to edit the text block.
/// This will allow the user to still be able to "double click to close" the TreeViewItem.
/// </summary>
public double MaximumClickTime
{
    get { return (double)GetValue(MaximumClickTimeProperty); }
    set { SetValue(MaximumClickTimeProperty, value); }
}
 
// Using a DependencyProperty as the backing store for MaximumClickTime.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty MaximumClickTimeProperty =
    DependencyProperty.Register("MaximumClickTime", typeof(double), typeof(EditableTextBlock), new UIPropertyMetadata(700d));
 
// Using a DependencyProperty as the backing store for MinimumClickTime.  This enables animation, styling, binding, etc...
public static readonly DependencyProperty MinimumClickTimeProperty =
    DependencyProperty.Register("MinimumClickTime", typeof(double), typeof(EditableTextBlock), new UIPropertyMetadata(300d));

DateTime _lastClicked;

private void TextBlock_MouseDown(object sender, MouseButtonEventArgs e)
{
    double timeBetweenClicks = (DateTime.Now - _lastClicked).TotalMilliseconds;
    _lastClicked = DateTime.Now;
 
    if (timeBetweenClicks > MinimumClickTime && timeBetweenClicks < MaximumClickTime)
    {
        IsInEditMode = true;
    }
 
    e.Handled = false;
}

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Data;
using System.Windows.Documents;
using System.Windows.Input;
using System.Windows.Media;
using System.Windows.Media.Imaging;
using System.Windows.Navigation;
using System.Windows.Shapes;
using System.Windows.Threading;
 
namespace Borgstrup.DocBase.Client.Controls
{
    public partial class EditableTextBlock : UserControl
    {
 
        #region Constructor
 
        public EditableTextBlock()
        {
            InitializeComponent();
            base.Focusable = true;
            base.FocusVisualStyle = null;
        }
 
        #endregion Constructor
 
        #region Member Variables
 
        // We keep the old text when we go into editmode
        // in case the user aborts with the escape key
        private string oldText;
 
        #endregion Member Variables
 
        #region Properties
 
        public string Text
        {
            get { return (string)GetValue(TextProperty); }
            set { SetValue(TextProperty, value); }
        }
        public static readonly DependencyProperty TextProperty =
            DependencyProperty.Register(
            "Text",
            typeof(string),
            typeof(EditableTextBlock),
            new PropertyMetadata(""));
 
        public bool IsEditable
        {
            get { return (bool)GetValue(IsEditableProperty); }
            set { SetValue(IsEditableProperty, value); }
        }
        public static readonly DependencyProperty IsEditableProperty =
            DependencyProperty.Register(
            "IsEditable",
            typeof(bool),
            typeof(EditableTextBlock),
            new PropertyMetadata(true));
 
        public bool IsInEditMode
        {
            get 
            {
                if (IsEditable)
                    return (bool)GetValue(IsInEditModeProperty);
                else
                    return false;
            }
            set
            {
                if (IsEditable)
                {
                    if (value) oldText = Text;
                    SetValue(IsInEditModeProperty, value);
                }
            }
        }
        public static readonly DependencyProperty IsInEditModeProperty =
            DependencyProperty.Register(
            "IsInEditMode",
            typeof(bool),
            typeof(EditableTextBlock),
            new PropertyMetadata(false));
 
        public string TextFormat
        {
            get { return (string)GetValue(TextFormatProperty); }
            set
            {
                if (value == "") value = "{0}";
                SetValue(TextFormatProperty, value);
            }
        }
        public static readonly DependencyProperty TextFormatProperty =
            DependencyProperty.Register(
            "TextFormat",
            typeof(string),
            typeof(EditableTextBlock),
            new PropertyMetadata("{0}"));
 
        public string FormattedText
        {
            get { return String.Format(TextFormat, Text); }
        }
 
        #endregion Properties
 
        #region Event Handlers
 
        // Invoked when we enter edit mode.
        void TextBox_Loaded(object sender, RoutedEventArgs e)
        {
            TextBox txt = sender as TextBox;
 
            // Give the TextBox input focus
            txt.Focus();
 
            txt.SelectAll();
        }
 
        // Invoked when we exit edit mode.
        void TextBox_LostFocus(object sender, RoutedEventArgs e)
        {
            this.IsInEditMode = false;
        }
 
        // Invoked when the user edits the annotation.
        void TextBox_KeyDown(object sender, KeyEventArgs e)
        {
            if (e.Key == Key.Enter)
            {
                this.IsInEditMode = false;
                e.Handled = true;
            }
            else if (e.Key == Key.Escape)
            {
                this.IsInEditMode = false;
                Text = oldText;
                e.Handled = true;
            }
        }
 
        #endregion Event Handlers
 
    }
}