/// <summary>
/// Occurs when the <see cref="Telerik.UI.Xaml.Controls.Primitives.TemplateProviderControl.ItemTemplateSelector" /> property has changed.
/// </summary>
/// <param name="oldSelector"></param>
protected override void OnItemTemplateSelectorChanged(DataTemplateSelector oldSelector)
{
base.OnItemTemplateSelectorChanged(oldSelector);
this.itemTemplateSelectorCache = this.ItemTemplateSelector;
this.ValidateDisplayMemberPath();
this.ResetOnTemplateChange();
}
private void changeAge(object sender, TextChangedEventArgs e)
{
DataTemplateSelector selector = List.ItemTemplateSelector;
List.ItemTemplateSelector = null;
List.ItemTemplateSelector = selector;
}
protected virtual void OnDataTemplateSelectorChanged(DataTemplateSelector oldValue, DataTemplateSelector newValue)
{
// check to see we don't have an ItemTemplate set
if (ItemTemplate != null && newValue != null)
throw new ArgumentException("Cannot set both ItemTemplate and ItemTemplateSelector");
_currentItemSelector = newValue;
}
public void TestLastChildFill()
{
var cb = GroupBox();
var selector = new DataTemplateSelector();
cb.HeaderTemplateSelector(selector).HeaderTemplateSelector.Should().Be(selector);
}
public override DataTemplate SelectTemplate(object item, DependencyObject container)
{
DataTemplateSelector currentCellTemplateSelector = GetCurrentCellTemplateSelector();
if (currentCellTemplateSelector != null && !ReferenceEquals(this, currentCellTemplateSelector))
{
throw new ArgumentException("I'm about to twiddle the wrong selector");
}
object cellValue = GetCellValue(item);
if (cellValue == null)
{//Let's late bind when we get a value
var comboFactory = new FrameworkElementFactory(typeof(NullCell));
comboFactory.SetValue(NullCell.CellTemplateSelectorProperty, this);
comboFactory.SetValue(FrameworkElement.DataContextProperty, Binding);
var itemsTemplate = new DataTemplate {
VisualTree = comboFactory
};
return(itemsTemplate);
}
else
{
SetCellTemplate(cellValue);
return(null);
}
}
private void OnItemTemplateSelectorChanged(DataTemplateSelector oldValue, DataTemplateSelector newValue)
{
if (this.ItemTemplate == null)
{
ReloadAllItems();
}
}
public ViewPresenter(DataTemplate viewTemplate, DataTemplateSelector viewTemplateSelector) {
ContentTemplate = viewTemplate;
#if !SILVERLIGHT
ContentTemplateSelector = viewTemplateSelector;
#endif
Loaded += ViewPresenter_Loaded;
}
public static DataTemplate ResolveTemplate(
DataTemplate dataTemplate,
DataTemplateSelector dataTemplateSelector,
object data,
DependencyObject container)
{
var template = dataTemplate;
if (template != null)
{
return(template);
}
if (dataTemplateSelector != null)
{
var result = dataTemplateSelector.SelectTemplate(data);
if (result == null &&
container != null &&
!FeatureConfiguration.DataTemplateSelector.UseLegacyTemplateSelectorOverload)
{
result = dataTemplateSelector.SelectTemplate(data, container);
}
return(result);
}
return(null);
}
private void cmdApplyChange_Click(object sender, RoutedEventArgs e)
{
((ObservableCollection <Product>)products)[1].CategoryName = "Travel";
DataTemplateSelector selector = lstProducts.ItemTemplateSelector;
lstProducts.ItemTemplateSelector = null;
lstProducts.ItemTemplateSelector = selector;
}
public static DataTemplateSelector GetDefaultSelector()
{
Type type = typeof(ContentPresenter).Assembly.GetType("System.Windows.Controls.ContentPresenter+DefaultSelector");
ConstructorInfo constructor = type.GetConstructor(Type.EmptyTypes);
DataTemplateSelector defaultSelector = (DataTemplateSelector)constructor.Invoke(null);
return(defaultSelector);
}
/// <summary>
/// Handles changes to the ItemTemplateSelector property.
/// </summary>
/// <param name="d">Source dependendency o bject</param>
/// <param name="e">Event argument</param>
private static void OnItemTemplateSelectorChanged(DependencyObject d, DependencyPropertyChangedEventArgs e)
{
MiniMap target = (MiniMap)d;
DataTemplateSelector oldValue = (DataTemplateSelector)e.OldValue;
DataTemplateSelector newValue = target.ItemTemplateSelector;
target.OnItemTemplateSelectorChanged(oldValue, newValue);
}
public ViewPresenter(DataTemplate viewTemplate, DataTemplateSelector viewTemplateSelector)
{
ContentTemplate = viewTemplate;
#if !SILVERLIGHT
ContentTemplateSelector = viewTemplateSelector;
#endif
Loaded += ViewPresenter_Loaded;
}
public void When_Base_Container_Is_Null()
{
var sut = new DataTemplateSelector();
var act = () => sut.SelectTemplate(0, null);
act.Should().Throw <ArgumentException>();
}
private void OnItemTemplateSelectorChanged(DataTemplateSelector p)
{
if (listBox == null)
{
return;
}
listBox.ItemTemplateSelector = p;
}
void SaveDefaultTemplates()
{
defaultCellTemplate = pivotGrid.PrintFieldCellTemplate;
defaultValueTemplate = pivotGrid.PrintFieldValueTemplate;
defaultHeaderTemplate = pivotGrid.PrintFieldHeaderTemplate;
defaultCellTemplateSelector = pivotGrid.PrintFieldCellTemplateSelector;
defaultValueTemplateSelector = pivotGrid.PrintFieldValueTemplateSelector;
}
private void NotifySurrogateContentTemplateSelectorIfDifferent()
{
if (SurrogateContentTemplateSelector != this._oldSurrogateContentTemplateSelector)
{
this._oldSurrogateContentTemplateSelector = SurrogateContentTemplateSelector;
Notify("SurrogateContentTemplateSelector");
}
}
// ReSharper disable VirtualMemberNeverOverriden.Global
protected virtual void OnHeaderTemplateSelectorChanged(DataTemplateSelector oldHeaderTemplateSelector, DataTemplateSelector newHeaderTemplateSelector)
// ReSharper restore VirtualMemberNeverOverriden.Global
{
if (HeaderTemplate != null && newHeaderTemplateSelector != null)
{
Trace.TraceError("HeaderTemplate and HeaderTemplateSelector defined");
}
}
public static void SetPopupContentTemplateSelector(DependencyObject o, DataTemplateSelector value)
{
if (o == null)
{
throw new ArgumentNullException("o");
}
o.SetValue(PopupContentTemplateSelectorProperty, value);
}
public void ApplyBinding()
{
object dataContext = base.DataContext;
if (dataContext != null)
{
DataTemplate dataTemplate = this.HeaderTemplate;
DataTemplateSelector headerTemplateSelector = this.HeaderTemplateSelector;
if (headerTemplateSelector != null)
{
dataTemplate = headerTemplateSelector.SelectTemplate(dataContext, this);
}
if (dataTemplate == null)
{
DataTemplateKey resourceKey = BreadcrumbItem.GetResourceKey(dataContext);
if (resourceKey != null)
{
dataTemplate = (base.TryFindResource(resourceKey) as DataTemplate);
}
}
this.SelectedItem = null;
HierarchicalDataTemplate hierarchicalDataTemplate = dataTemplate as HierarchicalDataTemplate;
if (dataTemplate != null)
{
this.Header = dataTemplate.LoadContent();
}
else
{
this.Header = dataContext;
}
this.DataContext = dataContext;
if (hierarchicalDataTemplate != null)
{
this.SetBinding(ItemsControl.ItemsSourceProperty, hierarchicalDataTemplate.ItemsSource);
}
BreadcrumbBar breadcrumbBar = this.BreadcrumbBar;
if (breadcrumbBar != null)
{
if (this.TraceBinding == null)
{
this.TraceBinding = breadcrumbBar.TraceBinding;
}
if (this.ImageBinding == null)
{
this.ImageBinding = breadcrumbBar.ImageBinding;
}
}
if (this.TraceBinding != null)
{
this.SetBinding(BreadcrumbItem.TraceProperty, this.TraceBinding);
}
if (this.ImageBinding != null)
{
this.SetBinding(BreadcrumbItem.ImageProperty, this.ImageBinding);
}
this.ApplyProperties(dataContext);
}
}
public static object CreateView(IViewLocator viewLocator, string documentType, DataTemplate viewTemplate = null, DataTemplateSelector viewTemplateSelector = null) {
if(documentType == null && viewTemplate == null & viewTemplateSelector == null)
throw new InvalidOperationException(string.Format("{0}{1}To learn more, see: {2}", Error_CreateViewMissArguments, System.Environment.NewLine, HelpLink_CreateViewMissArguments));
if(viewTemplate != null || viewTemplateSelector != null) {
return new ViewPresenter(viewTemplate, viewTemplateSelector);
}
IViewLocator actualLocator = viewLocator ?? (ViewLocator.Default ?? ViewLocator.Instance);
return actualLocator.ResolveView(documentType);
}
protected override void OnContentTemplateSelectorChanged(DataTemplateSelector oldContentTemplateSelector, DataTemplateSelector newContentTemplateSelector)
{
base.OnContentTemplateSelectorChanged(oldContentTemplateSelector, newContentTemplateSelector);
if (!_changingTemplates)
{
this.SlimContentTemplateSelector = this.ContentTemplateSelector;
}
}
public DefaultContentItemGeneratorImplementation(string itemContentMember, DataTemplate itemContentTemplate, DataTemplateSelector itemContentTemplateSelector, string itemContentStringFormat)
{
_itemContentMember = itemContentMember;
_itemContentTemplate = itemContentTemplate;
_itemContentTemplateSelector = itemContentTemplateSelector;
_itemContentStringFormat = itemContentStringFormat;
CreateItemContentMemberBinding();
}
/// <summary>
/// Handles changes to the EditableContentTemplateSelector property.
/// </summary>
/// <param name="d">
/// The <see cref="DependencyObject"/> on which
/// the property has changed value.
/// </param>
/// <param name="e">
/// Event data that is issued by any event that
/// tracks changes to the effective value of this property.
/// </param>
private static void OnEditableContentTemplateSelectorChanged(
DependencyObject d, DependencyPropertyChangedEventArgs e)
{
var target = (EditableListBoxItem)d;
DataTemplateSelector oldEditableContentTemplateSelector = (DataTemplateSelector)e.OldValue;
DataTemplateSelector newEditableContentTemplateSelector = target.EditableContentTemplateSelector;
target.OnEditableContentTemplateSelectorChanged(oldEditableContentTemplateSelector, newEditableContentTemplateSelector);
}
public void ShowWindow(object viewModel, DataTemplateSelector templateSelector)
{
var win = new Window {
Content = viewModel
};
win.ContentTemplateSelector = templateSelector;
win.Show();
}
protected virtual void OnDataTemplateSelectorChanged(DataTemplateSelector oldValue, DataTemplateSelector newValue)
{
// check to see we don't have an ItemTemplate set
if (ItemTemplate != null && newValue != null)
{
throw new ArgumentException("Cannot set both ItemTemplate and ItemTemplateSelector", "ItemTemplateSelector");
}
currentItemSelector = newValue;
}
/// <summary>
/// The method to invoke when the <c>ItemTemplateSelector</c> has changed.
/// </summary>
/// <param name="oldValue">The old value.</param>
/// <param name="newValue">The new value.</param>
/// <exception cref="ArgumentException">Thrown when setting both ItemTemplate and ItemTemplateSelector.</exception>
protected virtual void OnDataTemplateSelectorChanged(DataTemplateSelector oldValue, DataTemplateSelector newValue)
{
// checks to see that no ItemTemplate is created.
if (ItemTemplate != null && newValue != null)
{
throw new ArgumentException("Cannot set both ItemTemplate and ItemTemplateSelector", "ItemTemplateSelector");
}
_currentItemSelector = newValue;
}
protected override void PrepareContainerForItemOverride(DependencyObject element, object item)
{
base.PrepareContainerForItemOverride(element, item);
DataTemplateSelector selector = this.ItemTemplateSelector;
if (selector != null)
{
((ContentPresenter)element).ContentTemplate = selector.SelectTemplate(item, element);
}
}
/// <summary>
/// Generates an container element for the specified input data object.
/// </summary>
/// <param name="item">The data object for which to generate container.</param>
/// <returns>The container element for the <paramref name="item"/>.</returns>
private DependencyObject GetContainer(object item)
{
DataTemplate template = ItemTemplate;
DataTemplateSelector templateSelector = template == null ? ItemTemplateSelector : null;
Style style = ItemContainerStyle;
StyleSelector styleSelector = style == null ? ItemContainerStyleSelector : null;
return(GetContainer(item, template, templateSelector, style, styleSelector));
}
public XambAdorner(UIElement adornedElement, object content, DataTemplateSelector selector) : base(adornedElement)
{
_visual = new VisualCollection(this);
_adornerContent = new ContentControl
{
Content = content,
ContentTemplateSelector = selector
};
_visual.Add(_adornerContent);
}
public AttributeModelDataTemplateSelectors()
{
var attributeDataTemplateSelector = new AttributeDataTemplateSelector();
HeaderDataTemplateSelector = attributeDataTemplateSelector;
ContentDataTemplateSelector = attributeDataTemplateSelector;
ItemDataTemplateSelector = attributeDataTemplateSelector;
}
internal EditableContentListBoxItem(
DataTemplate regularContentTemplate,
DataTemplateSelector regularContentTemplateSelector,
DataTemplate editContentTemplate,
DataTemplateSelector editContentTemplateSelector)
{
this.regularContentTemplate = regularContentTemplate;
this.regularContentTemplateSelector = regularContentTemplateSelector;
this.editContentTemplate = editContentTemplate;
this.editContentTemplateSelector = editContentTemplateSelector;
}
public void WhenContentWithoutMatchingResourceSet_SetsTemplateToNull()
{
var selector = new DataTemplateSelector();
var originalDataTemplate = new DataTemplate();
selector.ContentTemplate = originalDataTemplate;
selector.Content = new FirstContentType();
Assert.IsNull(selector.ContentTemplate);
}
public DragAdorner(object data, DataTemplate dataTemplate, DataTemplateSelector dataTemplateSelector, UIElement adornedElement, AdornerLayer adornerLayer)
: base(adornedElement)
{
_adornerLayer = adornerLayer;
_contentPresenter = new ContentPresenter()
{
Content = data, ContentTemplate = dataTemplate, ContentTemplateSelector = dataTemplateSelector, Opacity = 0.75
};
_contentPresenter.Name = "WSS";
_adornerLayer.Add(this);
}
public static View ViewFor(this BindableObject This, object item, DataTemplateSelector selector)
{
if (selector != null)
{
var template = selector.SelectTemplate(item, This);
if (template != null)
{
var templateInstance = template.CreateContent();
// see if it's a view or a cell
var templateView = templateInstance as View;
if (templateView == null)
throw new InvalidOperationException("DataTemplate must be a View");
return templateView;
}
}
return null;
}
/// <summary>
/// Cells for.
/// </summary>
/// <param name="This">The this.</param>
/// <param name="item">The item.</param>
/// <param name="selector">The selector.</param>
/// <returns>Cell.</returns>
/// <exception cref="System.InvalidOperationException">DataTemplate must be either a Cell or a View</exception>
public static Cell CellFor(this BindableObject This, object item, DataTemplateSelector selector)
{
if (selector != null)
{
var template = selector.SelectTemplate(item, This);
if (template != null)
{
var templateInstance = template.CreateContent();
// see if it's a view or a cell
var templateView = templateInstance as View;
var templateCell = templateInstance as Cell;
if (templateView == null && templateCell == null)
throw new InvalidOperationException("DataTemplate must be either a Cell or a View");
if (templateView != null) // we got a view, wrap in a cell
templateCell = new ViewCell { View = templateView };
return templateCell;
}
}
return null;
}
protected virtual void OnViewTemplateSelectorChanged(DataTemplateSelector oldValue, DataTemplateSelector newValue) { }
private static void OnDataTemplateSelectorChanged(BindableObject bindable, DataTemplateSelector oldvalue, DataTemplateSelector newvalue)
{
((ExtendedListView)bindable).OnDataTemplateSelectorChanged(oldvalue, newvalue);
}
public static object CreateAndInitializeView(IViewLocator viewLocator, string documentType, object parameter, object parentViewModel = null, bool useParameterAsViewModel = false, DataTemplate viewTemplate = null, DataTemplateSelector viewTemplateSelector = null) {
if(useParameterAsViewModel)
return CreateAndInitializeView(viewLocator, documentType, parameter, parameter, parentViewModel, viewTemplate, viewTemplateSelector);
else
return CreateAndInitializeView(viewLocator, documentType, null, parameter, parentViewModel, viewTemplate, viewTemplateSelector);
}
public static object CreateAndInitializeView(IViewLocator viewLocator, string documentType, object viewModel, object parameter, object parentViewModel, DataTemplate viewTemplate = null, DataTemplateSelector viewTemplateSelector = null) {
return CreateAndInitializeView(viewLocator, documentType, viewModel, parameter, parentViewModel, null, viewTemplate, viewTemplateSelector);
}
public static object CreateAndInitializeView(IViewLocator viewLocator, string documentType, object viewModel, object parameter, object parentViewModel, IDocumentOwner documentOwner, DataTemplate viewTemplate = null, DataTemplateSelector viewTemplateSelector = null) {
object view = CreateView(viewLocator, documentType, viewTemplate, viewTemplateSelector);
InitializeView(view, viewModel, parameter, parentViewModel, documentOwner);
return view;
}
public ViewPresenter(DataTemplate viewTemplate, DataTemplateSelector viewTemplateSelector) {
ContentTemplate = viewTemplate;
ContentTemplateSelector = viewTemplateSelector;
Loaded += ViewPresenter_Loaded;
}
