RadGridView CellTemplate

Question

I need to change the CellTemplate of a RadGridView. All of the examples I can find online defines the Columns statically in the Xaml, and then in that Column tag, they define the CellTemplate:

The above example loads the CellTemplate only for the column with the heading "ID", and does that for all of the cells in that column.

I have managed to load the CellTemplates in the code behind but this required me to pass an instance of the whole grid to the ViewModel, and also had to add a dependency Property to the GridView to bind the Columns of the grid to a GridViewColumnCollection in the ViewModel.

This is a very messy workaround, one that I'm sure will get me fired if seen by the wrong eyes. What I need to do is something similar to this:


    
        
            
                ...Some [Normal] template...
            
        
            
                ...Some [ComboBox] template...

I honestly have no idea why this RadGridView makes it so difficult to change the CellTemplate, because this prevents you from changing a common property such as the Foreground Color in the Label found in the ContentTemplate in the Cell itself.. Any ideas as to what I can do?

Daniel Brose · Accepted Answer

So in advance, Im not sure about the "proper" way to do this, as WPF seems so highly contextual that it really seems to be a case of what suits your particular needs best.

My own approach to this probably issnt the most recommended, but i had the need to centralise all styleselector and cellselector variants and use logic written in code, not in xaml.

What i went with is something similar to telerik.StyleRule approach, but much simpler, as just in code-behind atm. Rather than perhaps defining in in shared xaml resource library or defining in each view, i use classes in a single folder and simply call it using CLR namespace and ect in the xaml (though could be set in code-behind ofcourse)

It uses the column name and very easy to define conditions using:

Expression>

The actual resources (datatemplate and styles) that it uses are defined in shared xaml resource library, but those can be quite generic if needed.

Its a little rough, and ill leave in comments in case of interest.

MyProject.CellStyleSelector

/// 
/// Used in CellStyleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// 
/// NOTE - tried extending telerik.StyleRule, issues with setting condition value
/// 
public class CellStyleRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use , but ONLY if needed
    Expression> _Condition;
    public Expression> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    Style _Style;
    public Style Style
    {
        get
        {
            return this._Style;
        }
        set
        {
            this._Style = value;
        }
    }



    public CellStyleRule(Expression> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Style = d as Style;
        else
            throw new Exception("No such style resource as '" + s + "'");

        // Value = v;
        Condition = c;
    }



    /*
    public CellStyleRule(string c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            Style = d as Style;
        else
            throw new Exception("No such style resource as '" + s + "'");

        // TODO - test - guessing at how to do this based on telerik classes

        // Value = v;
        Telerik.Windows.Data.ExpressionTypeConverter converter = new Telerik.Windows.Data.ExpressionTypeConverter();
        Condition = (System.Linq.Expressions.Expression) converter.ConvertFromString(c);

        c.ToString();
    }
     */
}






// NOTE IMPORTANT - use of xaml defined ConditionalStyleSelectors is not a bad alternative approach, though diferent selector
//                  for each column it could all be defined in same resource dictionary
//                - problem is that issues encountered with Enums, so decided on this approach instead

/// 
/// A variation of StyleSelecter not unlike telerik:ConditionalStyleSelector. 
/// 
/// However, rules are defined using a Dictionary to distinct columns and use same 
/// selector, with rules (currently) defined not declarativly (xaml), but in inheriting classes, 
/// typically one for each entity type requiring a RadGridView and conditional styling.
/// 
public abstract class CellStyleSelector : StyleSelector
{
    // public Dictionary> conditions { get; set; }


    // Use a Dictionary mapping X columns to individual Lists of rules to check
    Dictionary> _Rules;
    public Dictionary> Rules
    {
        get
        {
            if (this._Rules == null)
            {
                this._Rules = new Dictionary>();
            }

            return this._Rules;
        }
        set { this._Rules = value; }
    }

    public override Style SelectStyle(object item, DependencyObject container)
    {
        if (item is BaseDataModel)
        {
            GridViewCell cell = container as GridViewCell;
            var currentColumn = cell.Column as GridViewDataColumn;
            string key = currentColumn.DataMemberBinding.Path.Path;


            if (Rules.ContainsKey(key))
            {
                foreach (CellStyleRule rule in Rules[key])
                {
                    // string debug = DebugHelper.Debug(rule.Condition);

                    // REVERTED NOTE - if just Func<>
                    // if (rule.Condition((BaseDataModel)item))

                    // NOTE - if Expression>, first compile then pass in param
                    if (rule.Condition.Compile()((BaseDataModel)item))
                    {
                        return rule.Style;
                    }
                }
            }

        }
        return null;
    }


}


/// 
/// Used in CellCellTemplateRuleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// 
public class CellTemplateRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use , but ONLY if needed
    Expression> _Condition;
    public Expression> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    DataTemplate _Template;
    public DataTemplate Template
    {
        get
        {
            return this._Template;
        }
        set
        {
            this._Template = value;
        }
    }



    public CellTemplateRule(Expression> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Template = d as DataTemplate;
        else
            throw new Exception("No such template resource as '" + s + "'");

        Condition = c;
    }


}

// Implementing class, used for any licence table
public class LicenceTableCellStyleSelector : CellStyleSelector
{
    public LicenceTableCellStyleSelector()
        : base()
    {
        this.Rules = new Dictionary>()
        {
            { "LicenceStatus" , new List()
                {
                    // Always most specific rules at top

                    // Error catcher, leave in as visual cue just in case
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < DateTime.Now && ((Licence)x).LicenceStatus != LicenceStatus.Expired, "CellStyle_Licence_ExpiryMismatch") } ,

                    { new CellStyleRule(x => ((Licence)x).LicenceStatus == LicenceStatus.Active, "CellStyle_Status_Active") } ,

                    // Same as != Active, as only those would through this far
                    { new CellStyleRule(x => x != null, "CellStyle_Status_Inactive") } ,


                }
            },

            { "LicenceType" , new List()
                {                        
                    { new CellStyleRule(x => ((Licence)x).LicenceType == LicenceType.Full, "CellStyle_Licence_Full") } ,
                    { new CellStyleRule(x => ((Licence)x).LicenceType == LicenceType.Upgrade, "CellStyle_Licence_Upgrade") } ,

                    // Timed, uses fallthrough so no need to actually check unless wanting to distinct types of timed
                    { new CellStyleRule(x => x != null, "CellStyle_Licence_Timed") } ,
                }
            },

            { "LicenceExpired" , new List()
                {                        
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < DateTime.Now && ((Licence)x).LicenceStatus != LicenceStatus.Expired, "CellStyle_Licence_ExpiryMismatch")  }, 
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < ((Licence)x).LicenceIssued, "CellStyle_Licence_ExpiryMismatch") } ,
                }
            },

            { "LicenceIssued" , new List()
                {
                    { new CellStyleRule(x => ((Licence)x).LicenceExpires < ((Licence)x).LicenceIssued, "CellStyle_Licence_ExpiryMismatch") } ,
                }
            }
        };
    }
}

CellTemplateSelector

/// 
/// Used in CellCellTemplateRuleSelector and its inheriting classes.
/// 
/// Wouldnt be too hard to modify to allow declarative if highly desired.
/// 
public class CellTemplateRule
{
    /*
    object _Value;
    public object Value
    {
        get
        {
            return this._Value;
        }
        set
        {
            this._Value = value;
        }
    }
     */

    // NOTE - if needing to widen use case, use , but ONLY if needed
    Expression> _Condition;
    public Expression> Condition
    {
        get
        {
            return this._Condition;
        }
        set
        {
            this._Condition = value;
        }
    }


    DataTemplate _Template;
    public DataTemplate Template
    {
        get
        {
            return this._Template;
        }
        set
        {
            this._Template = value;
        }
    }



    public CellTemplateRule(Expression> c, string s)
    {
        var d = App.Current.FindResource(s);
        if (d != null)
            this.Template = d as DataTemplate;
        else
            throw new Exception("No such template resource as '" + s + "'");

        Condition = c;
    }


}

// NOTE IMPORTANT - use of xaml defined ConditionalTemplateSelectors is not a bad alternative approach, though diferent selector
//                  for each column it could all be defined in same resource dictionary
//                - problem is that issues encountered with Enums, so decided on this approach instead

/// 
/// See CellStyleSelector, this is a variant used with the CellTemplateSelector property
/// 
public abstract class CellTemplateSelector : DataTemplateSelector
{
    // public Dictionary> conditions { get; set; }


    // Use a Dictionary mapping X columns to individual Lists of rules to check
    Dictionary> _Rules;
    public Dictionary> Rules
    {
        get
        {
            if (this._Rules == null)
            {
                this._Rules = new Dictionary>();
            }

            return this._Rules;
        }
        set { this._Rules = value; }
    }

    public override DataTemplate SelectTemplate(object item, DependencyObject container)
    {
        if (item is BaseDataModel)
        {
            GridViewCell cell = container as GridViewCell;
            var currentColumn = cell.Column as GridViewDataColumn;
            string key = currentColumn.DataMemberBinding.Path.Path;


            if (Rules.ContainsKey(key))
            {
                foreach (CellTemplateRule rule in Rules[key])
                {
                    // string debug = DebugHelper.Debug(rule.Condition);

                    // REVERTED NOTE - if just Func<>
                    // if (rule.Condition((BaseDataModel)item))

                    // NOTE - if Expression>, first compile then pass in param
                    if (rule.Condition.Compile()((BaseDataModel)item))
                    {
                        return rule.Template;
                    }
                }
            }

        }
        return null;
    }


}


// Implementing class for a different table, though RadGridView can use both CellStyleSelector and CellTemplateSelector at same time, i just didnt need yet
public class OrderDongleWrapTableCellTemplateSelector : CellTemplateSelector
{
    public OrderDongleWrapTableCellTemplateSelector()
        : base()
    {
        this.Rules = new Dictionary>()
        {
            { "ReplacedDongle.DongleID" , new List()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).IsReplacementDongle == false  , "CellTemplate_OrderDongleWrap_NotReplacementDongler_NAField") },


                }
            },
            { "ReplacedDongleStatus" , new List()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).IsReplacementDongle == false  , "CellTemplate_OrderDongleWrap_NotReplacementDongler_NAField") },


                }
            },
            /*
             * // REVERTED - better to just set to UNKNOWN CUSTOMER explicitly before shown in table, rather than overwrite datatemplate
            { "Customer.CustomerName" , new List()
                {
                    // Always most specific rules at top


                    { new CellTemplateRule(x => ((OrderDongleWrap)x).Customer == null || ((OrderDongleWrap)x).Customer.CustomerID == 1 , "CellTemplate_OrderDongleWrap_UnknownCustomerField") },


                }
            },
            */
        };
    }
}

xaml resources

N/A

implementing xaml for CellStyleSelector

Ive only had one case for CellTemplateSelector so far, and here it is:

implementing xaml for CellTemplateSelector

So this is my own approach, but it centralises the conditional logic and the styles into just 1 cs class per target class (GridView ItemsSource object) and just 1 resource sheet for all GridView.

You can refactor fairly easily into being declarative if you wanted, I saw it was possible but didnt need or want to do that so I didnt.

You can also refactor so the rules cascade off single cs class for all tables, or even to declare styles on the fly..? (by new Style and adding attributes?)

In any case, I hope this helps anyone else with this issue

RadGridView CellTemplate

Answers (1)

Related Questions