更新TextBlock绑定不起作用

Question

I have a question about databinding! I am writing code for a 'node editor' that has some (different) nodes in it. I use a BaseViewModel class that derives from INotifyPropertyChanged .

There is a 'base' NodeViewModel (that derives from it) with an ObservableCollection and other Properties, like the Node's Name property. It's implementation looks like this:

(in public class NodeViewModel : BaseViewModel ):

protected String mName = String.Empty;

public String Name {
    get { return mName; }
    set {
        if (mName == value) {
            return;
        }
        mName = value;
        OnPropertyChanged("Name");
    }
}

With an OnPropertyChanged handler that looks like this:

(in BaseViewModel )

protected virtual void OnPropertyChanged(string propertyName) {
    if (PropertyChanged != null) {
        PropertyChanged(this, new PropertyChangedEventArgs(propertyName));
    }
}

Now I have one additional RoomViewModel that derives from NodeViewModel .

I use another different ViewModel that I call RoomCollectionViewModel to group some rooms. Now when I add a room to my roomcollection (by drawing a connection between them) I test all connected rooms for the same name.

If an already connected room exists in the collection with the same room name (eg "new room") I want to change those two room's names to eg "new room #1" and "new room #2". No problem so far.

Every node control (created using DataTemplates with set DataContext set to the ViewModel) contains a TextBlock (a modified one) that displays the node's name.

This is where it gets problematic:

I use a modified Textblock because I want to be able to modify the node's name by double-clicking on it. And that works perfectly, only if I modify the RoomViewModel's name in Code, this (modified) TextBlock won't update.

The strange thing is this: When two equally named rooms in a collection get renamed by my code and I then double-click on the editable TextBlock (which converts to a TextBox in that process), I already see the modified Text. So I assume my DataBinding and my code is correct, just not complete :)

So how is it possible to force an update of my EditableTextBlock , the Text (DependencyProperty) seems to be updated correctly...

I hope you understand what my problem is! Thank you for any help.

Update 1 This is the XAML code for my EditableTextBlock (it comes from here: http://www.codeproject.com/Articles/31592/Editable-TextBlock-in-WPF-for-In-place-Editing )

<UserControl x:Class="NetworkUI.EditableTextBlock"
         xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
         xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
         xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006" 
         xmlns:d="http://schemas.microsoft.com/expression/blend/2008" 
         xmlns:local="clr-namespace:NetworkUI"
         mc:Ignorable="d" 
         d:DesignHeight="60" d:DesignWidth="240" x:Name="mainControl">
<UserControl.Resources>
    <DataTemplate x:Key="EditModeTemplate">
        <TextBox KeyDown="TextBox_KeyDown" Loaded="TextBox_Loaded" LostFocus="TextBox_LostFocus"
                 Text="{Binding ElementName=mainControl, Path=Text, UpdateSourceTrigger=PropertyChanged}"
                 Margin="0" BorderThickness="1" />
    </DataTemplate>
    <DataTemplate x:Key="DisplayModeTemplate">
        <TextBlock Text="{Binding ElementName=mainControl, Path=FormattedText}" Margin="5,3,5,3" MouseDown="TextBlock_MouseDown" />
    </DataTemplate>

    <Style TargetType="{x:Type local:EditableTextBlock}">
        <Style.Triggers>
            <Trigger Property="IsInEditMode" Value="True">
                <Setter Property="ContentTemplate" Value="{StaticResource EditModeTemplate}" />
            </Trigger>
            <Trigger Property="IsInEditMode" Value="False">
                <Setter Property="ContentTemplate" Value="{StaticResource DisplayModeTemplate}" />
            </Trigger>
        </Style.Triggers>
    </Style>
</UserControl.Resources>

And here is the code-behind file:

using System;
using System.Windows;
using System.Windows.Controls;
using System.Windows.Input;

namespace NetworkUI {
/// <summary>
/// Interaction logic for EditableTextBlock.xaml
/// </summary>
public partial class EditableTextBlock : UserControl {
    #region Dependency Properties, Events
    public static readonly DependencyProperty TextProperty =
        DependencyProperty.Register("Text", typeof(String), typeof(EditableTextBlock),
        new FrameworkPropertyMetadata("", FrameworkPropertyMetadataOptions.BindsTwoWayByDefault));
    public static readonly DependencyProperty IsEditableProperty =
        DependencyProperty.Register("IsEditable", typeof(Boolean), typeof(EditableTextBlock), new PropertyMetadata(true));
    public static readonly DependencyProperty IsInEditModeProperty =
        DependencyProperty.Register("IsInEditMode", typeof(Boolean), typeof(EditableTextBlock), new PropertyMetadata(false));
    public static readonly DependencyProperty TextFormatProperty =
        DependencyProperty.Register("TextFormat", typeof(String), typeof(EditableTextBlock), new PropertyMetadata("{0}"));
    #endregion ///Dependency Properties, Events


    #region Variables and Properties
    /// <summary>
    /// We keep the old text when we go into editmode
    /// in case the user aborts with the escape key
    /// </summary>
    private String oldText;
    /// <summary>
    /// Text content of this EditableTextBlock
    /// </summary>
    public String Text {
        get { return (String)GetValue(TextProperty); }
        set { SetValue(TextProperty, value); }
    }
    /// <summary>
    /// Is this EditableTextBlock editable or not
    /// </summary>
    public Boolean IsEditable {
        get { return (Boolean)GetValue(IsEditableProperty); }
        set { SetValue(IsEditableProperty, value); }
    }
    /// <summary>
    /// Is this EditableTextBlock currently in edit mode
    /// </summary>
    public Boolean IsInEditMode {
        get {
            if (IsEditable)
                return (Boolean)GetValue(IsInEditModeProperty);
            else
                return false;
        }
        set {
            if (IsEditable) {
                if (value)
                    oldText = Text;
                SetValue(IsInEditModeProperty, value);
            }
        }
    }
    /// <summary>
    /// The text format for the TextBlock
    /// </summary>
    public String TextFormat {
        get { return (String)GetValue(TextFormatProperty); }
        set  {
            if (value == "")
                value = "{0}";
            SetValue(TextFormatProperty, value);
        }
    }
    /// <summary>
    /// The formatted text of this EditablTextBlock
    /// </summary>
    public String FormattedText {
        get { return String.Format(TextFormat, Text); }
    }
    #endregion ///Variables and Properties


    #region Constructor
    /// <summary>
    /// Default constructor for the editable text block
    /// </summary>
    public EditableTextBlock() {
        InitializeComponent();
        Focusable = true;
        FocusVisualStyle = null;
    }
    #endregion ///Constructor


    #region Methods, Functions and Eventhandler
    /// <summary>
    /// Invoked when we enter edit mode
    /// </summary>
    /// <param name="sender">Sender</param>
    /// <param name="e">Event arguments</param>
    void TextBox_Loaded(object sender, RoutedEventArgs e) {
        TextBox txt = sender as TextBox;
        /// Give the TextBox input focus
        txt.Focus();
        txt.SelectAll();
    }
    /// <summary>
    /// Invoked when we exit edit mode
    /// </summary>
    /// <param name="sender">Sender</param>
    /// <param name="e">Event arguments</param>
    void TextBox_LostFocus(object sender, RoutedEventArgs e) {
        IsInEditMode = false;
    }
    /// <summary>
    /// Invoked when the user edits the annotation.
    /// </summary>
    /// <param name="sender">Sender</param>
    /// <param name="e">Event arguments</param>
    void TextBox_KeyDown(object sender, KeyEventArgs e) {
        if (e.Key == Key.Enter) {
            IsInEditMode = false;
            e.Handled = true;
        }
        else if (e.Key == Key.Escape) {
            IsInEditMode = false;
            Text = oldText;
            e.Handled = true;
        }
    }
    /// <summary>
    /// Invoked when the user double-clicks on the textblock
    /// to edit the text
    /// </summary>
    /// <param name="sender">Sender (the Textblock)</param>
    /// <param name="e">Event arguments</param>
    private void TextBlock_MouseDown(object sender, MouseButtonEventArgs e) {
        if (e.ClickCount == 2)
            IsInEditMode = true;
    }
    #endregion ///Methods, Functions and Eventhandler

}

Thank you for any help!

Update 2

I changed the following line of code:

<TextBlock Text="{Binding ElementName=mainControl, Path=FormattedText}" Margin="5,3,5,3" MouseDown="TextBlock_MouseDown" />

to:

<TextBlock Text="{Binding ElementName=mainControl, Path=Text}" Margin="5,3,5,3" MouseDown="TextBlock_MouseDown" />

and now it is working!

I didn't see the TextBlock using the FormattedText in the first place! Ugh, thank you very much, now everything updates perfectly!

Answer 1

As postes by Lee O. the problem was indeed the bound property from my EditableTextBlock control.

The TextBlock used the FormattedText property that was updated by my Binding. Now I use the Text property for both, the TextBlock and the TextBox controls.

I simply removed the FormattedText property as well as the TextFormatProperty (DependencyProperty) and TextFormat property from my EditableTextBlock because I didn't plan to use those.

Thank you again!