I get System.Windows.Style as text of the tooltip of the header in a datagrid

Question

I want to define a style for the datagrid columns that get the text of the tooltip through an attached property. But I get the text System.Windows.Style instead of the text.

The code is this.

XML resource file that defines the style:

The code in the axml:

The attached property:

namespace GTS.CMMS.Client.AttachedProperties
{
    public static class CabeceraDatagridAttachedProperty
    {
        public static readonly DependencyProperty TooltipProperty =
            DependencyProperty.RegisterAttached(
            "Tooltip",
            typeof(string),
            typeof(CabeceraDatagridAttachedProperty));

        public static string GetTooltip(DependencyObject obj)
        {
            return (string)obj.GetValue(TooltipProperty);
        }

        public static void SetTooltip(DependencyObject obj, string value)
        {
            obj.SetValue(TooltipProperty, value);
        }
    }
}

Thanks.

EDIT: I will add a complite simple example to simplify the code.

the view:

The view model:

   using System.Collections.ObjectModel;



namespace TestStyleWithAttachedProperties.ViewModels
{
    public class MainWindowViewModel : BaseViewModel
    {
        public MainWindowViewModel()
        {
            Items = new ObservableCollection();

            Data miData01 = new Data()
            {
                Price = 1m,
                Discount = 0m,
                Tooltip = "Tooltip Data01",
                ErrorDescription = "No errors",
                IsDataCorrect = true,
            };

            Items.Add(miData01);


            Data miData02 = new Data()
            {
                Price = 2m,
                Discount = 10m,
                Tooltip = "Tooltip Data02",
                ErrorDescription = "No errors",
                IsDataCorrect = true,
            };

            Items.Add(miData02);


            Data miData03 = new Data()
            {
                Price = -1m,
                Discount = 0m,
                Tooltip = "Tooltip Data03",
                ErrorDescription = "Price has to be greater than 0.",
                IsDataCorrect = false,
            };

            Items.Add(miData03);
        }


        private ObservableCollection _items;

        public ObservableCollection Items
        {
            get { return _items; }
            set
            {
                _items = value;
                base.RaisePropertyChangedEvent(nameof(Items));
            }
        }




        private string _priceTooltip = "Tooltip for Price column";

        public string PriceTooltip
        {
            get { return _priceTooltip; }
            set { _priceTooltip = value; }
        }
    }
}

The view model base, for notify when a property is changed:

using System.ComponentModel;

namespace TestStyleWithAttachedProperties.ViewModels
{
    public abstract class BaseViewModel : INotifyPropertyChanging, INotifyPropertyChanged
    {
        #region INotifyPropertyChanging Members

        public event PropertyChangingEventHandler PropertyChanging;

        #endregion

        #region INotifyPropertyChanged Members

        public event PropertyChangedEventHandler PropertyChanged;

        #endregion

        #region Administrative Properties

        /// 
        /// Whether the view model should ignore property-change events.
        /// 
        public virtual bool IgnorePropertyChangeEvents { get; set; }

        #endregion

        #region Public Methods
        /// 
        /// Raises the PropertyChanged event.
        /// 
        /// The name of the changed property.
        public virtual void RaisePropertyChangedEvent(string propertyName)
        {
            // Exit if changes ignored
            if (IgnorePropertyChangeEvents) return;

            // Exit if no subscribers
            if (PropertyChanged == null) return;

            // Raise event
            var e = new PropertyChangedEventArgs(propertyName);
            PropertyChanged(this, e);
        }

        /// 
        /// Raises the PropertyChanging event.
        /// 
        /// The name of the changing property.
        public virtual void RaisePropertyChangingEvent(string propertyName)
        {
            // Exit if changes ignored
            if (IgnorePropertyChangeEvents) return;

            // Exit if no subscribers
            if (PropertyChanging == null) return;

            // Raise event
            var e = new PropertyChangingEventArgs(propertyName);
            PropertyChanging(this, e);
        }

        #endregion
    }
}

The class Data:

using TestStyleWithAttachedProperties.ViewModels;

namespace TestStyleWithAttachedProperties
{
    public class Data : BaseViewModel
    {
        private decimal _price;

        public decimal Price
        {
            get { return _price; }
            set
            {
                _price = value;
                base.RaisePropertyChangedEvent(nameof(Price));
            }
        }

        private decimal _disocunt;

        public decimal Discount
        {
            get { return _disocunt; }
            set
            {
                _disocunt = value;
                base.RaisePropertyChangedEvent(nameof(Discount));
            }
        }


        private string _tooltip;

        public string Tooltip
        {
            get { return _tooltip; }
            set
            {
                _tooltip = value;
                base.RaisePropertyChangedEvent(nameof(Tooltip));
            }
        }



        private string _errorDescription;

        public string ErrorDescription
        {
            get { return _errorDescription; }
            set
            {
                _errorDescription = value;
                base.RaisePropertyChangedEvent(nameof(ErrorDescription));
            }
        }



        private bool _isDataCorrect;

        public bool IsDataCorrect
        {
            get { return _isDataCorrect; }
            set
            {
                _isDataCorrect = value;
                base.RaisePropertyChangedEvent(nameof(IsDataCorrect));
            }
        }
    }
}

The dictionery with the resources: the styles for the hearder and the cells:

The value converter for the tooltip of the cells:

using System;
using System.Globalization;
using System.Windows.Data;



namespace TestStyleWithAttachedProperties.Converters
{
    public class CellTooltipMultiValueConverter : IMultiValueConverter
    {
        public object Convert(object[] values, Type targetType, object parameter, CultureInfo culture)
        {
            //here values are unset values.
            //If I return a string, it is shown in the datagrid. But I can't do any logic because the values are null.
            return "Hola";
        }



        public object[] ConvertBack(object value, Type[] targetTypes, object parameter, CultureInfo culture)
        {
            throw new NotImplementedException();
        }
    }
}

Then attached properties for the cells, to can communicate the view with the cell style in the resource dictionary:

using System.Windows;




namespace TestStyleWithAttachedProperties.AttachedProperties
{
    public static class CellWithErrorsAttachedProperty
    {
        //TextoTooltip01
        //Primer texto del tooltip que se mostrará.
        public static readonly DependencyProperty TextoTooltip01Property =
            DependencyProperty.RegisterAttached(
            "TextoTooltip01",
            typeof(string),
            typeof(CellWithErrorsAttachedProperty));

        public static string GetTextoTooltip01(DependencyObject obj)
        {
            return (string)obj.GetValue(TextoTooltip01Property);
        }

        public static void SetTextoTooltip01(DependencyObject obj, string value)
        {
            obj.SetValue(TextoTooltip01Property, value);
        }



        //TextoTooltip02
        //Primer texto del tooltip que se mostrará.
        public static readonly DependencyProperty TextoTooltip02Property =
            DependencyProperty.RegisterAttached(
            "TextoTooltip02",
            typeof(string),
            typeof(CellWithErrorsAttachedProperty));

        public static string GetTextoTooltip02(DependencyObject obj)
        {
            return (string)obj.GetValue(TextoTooltip01Property);
        }

        public static void SetTextoTooltip02(DependencyObject obj, string value)
        {
            obj.SetValue(TextoTooltip01Property, value);
        }





        //ES DATO CORRECTO
        //Indica si el dato de la celda es correcto o no.
        public static readonly DependencyProperty EsDatoCorrectoProperty =
            DependencyProperty.RegisterAttached(
            "EsDatoCorrecto",
            typeof(bool),
            typeof(CellWithErrorsAttachedProperty));

        public static bool GetEsDatoCorrecto(DependencyObject obj)
        {
            return (bool)obj.GetValue(EsDatoCorrectoProperty);
        }

        public static void SetEsDatoCorrecto(DependencyObject obj, bool value)
        {
            obj.SetValue(EsDatoCorrectoProperty, value);
        }
    }
}

The attached property to use with headers:

using System.Windows;




namespace TestStyleWithAttachedProperties.AttachedProperties
{
    public static class HeaderAttachedProperty
    {
        //TextoTooltip01
        //Primer texto del tooltip que se mostrará.
        public static readonly DependencyProperty TooltipProperty =
            DependencyProperty.RegisterAttached(
            "Tooltip",
            typeof(string),
            typeof(HeaderAttachedProperty));

        public static string GetTooltip(DependencyObject obj)
        {
            return (string)obj.GetValue(TooltipProperty);
        }

        public static void SetTooltip(DependencyObject obj, string value)
        {
            obj.SetValue(TooltipProperty, value);
        }
    }
}

This example shows the text in the tooltip. The key line is in the view and is this:

But if I try to use a binding then it doesn't work. The code that I am trying to use to bind a property in the object that is data source of the row is this:

ap:HeaderAttachedProperty.Tooltip="{Binding Price, Source={x:Reference dummyElement}}"

So I could advance a bit in the solution, but I would like to can bind a property of the source object of tupe Data.

Answer

Hi ComptonAlvaro,
I check your post and it works fine in my demo:

XAML:

and code:

using System;  
using System.Collections.ObjectModel;  
using System.ComponentModel;  
using System.Windows;  
using System.Windows.Data;  
  
namespace WpfApp111  
{  
  public class ViewModel  
  {  
    public ViewModel()  
    {  
      for (int i = 1; i < 10; i++) col.Add(new Data() { ID = i, Price = i*111 });  
      cvs.Source = col;  
    }  
    private CollectionViewSource cvs = new CollectionViewSource();  
    private ObservableCollection col = new ObservableCollection();  
    private Random rnd = new Random();  
    public ICollectionView View { get => cvs.View; }  
    public string PriceTooltip { get; set; } = "Tooltip for Price column";  
  }  
  
  public class Data  
  {  
    public int ID { get; set; }  
    public decimal Price { get; set; }  
  }  
  
  public static class HeaderAttachedProperty  
  {  
    public static readonly DependencyProperty TooltipProperty =  
        DependencyProperty.RegisterAttached(  
        "Tooltip",  
        typeof(string),  
        typeof(HeaderAttachedProperty));  
    public static string GetTooltip(DependencyObject obj) => (string)obj.GetValue(TooltipProperty);  
    public static void SetTooltip(DependencyObject obj, string value) => obj.SetValue(TooltipProperty, value);  
  }  
}

Result:

Share via

I get System.Windows.Style as text of the tooltip of the header in a datagrid

1 answer