Question

I have a TabControl, and I want to do the following:

1. Take first and last of the TabItems in TabControl.Items
2. Get their Margins
3. Supply those Thicknesses to the converter to convert these two structs into final value

Here is a related code showing what I am trying to do:

<Border.Padding>
    <MultiBinding Converter="{StaticResource MarginsToPaddingConverter}">
        <Binding Path="Margin">
            <Binding.Source>
                <Binding RelativeSource="{RelativeSource AncestorType=TabControl}" Path="Items" Converter="{StaticResource ItemCollectionToFirstItemConverter}" ConverterParameter="{x:Type TabItem}" />
            </Binding.Source>
        </Binding>
        <Binding Path="Margin">
            <Binding.Source>
                <Binding RelativeSource="{RelativeSource AncestorType=TabControl}" Path="Items" Converter="{StaticResource ItemCollectionToLastItemConverter}" ConverterParameter="{x:Type TabItem}" />
            </Binding.Source>
        </Binding>
    </MultiBinding>
</Border.Padding>

But I can’t set Binding as RelativeSource or Source of other Binding. Basically the solution at hand is to create converter, which would take TabControl.Items and convert it to the final value, but the problem is I want to animate Margins of both TabItems, so I need to bind specifically to these properties. If I would bind to TabControl.Items, the Border.Padding would not get refreshed if Margin of any TabItem would change. So what should I do?

Update

Ok, so one of the possible solutions is to hook into TabItem.Loaded event, and then use DependencyPropertyDescriptor to hook Changed event on appropriate properties, then hook all items in TabItem.Items collection, hook any new items and automatically unhook all old items, and hook like million other stuff. But this is quite complicated and it’s like 400 LOC. Isn’t there anything simpler? Preferably in pure XAML.

Answer 1

Unfortunately this modified response is not as elegant as I’d like, but it should work.

Basically, use another dummy control as a relay for the binding. Specifically, this scenario arises when you want to pull the first and last of a collection. You can’t just use a converter to grab the first/last and the property all at once, because if you change a property on the first or last item, the converter won’t pick up the change. So you have to do something that melds in with dependency properties – almost like some sort of a second order dependency property would be nice.

Anyways, here’s some code:

using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Windows.Controls;
using System.Windows;
using System.Collections;

namespace WpfApplication1
{
    public class CollectionHelper : Control
    {
        public static DependencyProperty CollectionProperty = DependencyProperty.Register(
            "Collection",
            typeof(IEnumerable),
            typeof(CollectionHelper),
            new FrameworkPropertyMetadata(OnCollectionChanged));

        public IEnumerable Collection
        {
            get { return GetValue(CollectionProperty) as IEnumerable; }
            set { SetValue(CollectionProperty, value); }
        }

        private static void OnCollectionChanged(object rawSender, DependencyPropertyChangedEventArgs args)
        {
            CollectionHelper sender = (CollectionHelper)rawSender;
            IEnumerable value = args.NewValue as IEnumerable;
            if(value==null)
            {
                sender.First = null;
                sender.Last = null;
                return;
            }
            bool isFirstSet = false;
            object lastItemTemp = null;
            foreach (var item in value)
            {
                if (!isFirstSet)
                {
                    sender.First = item;
                    isFirstSet = true;
                }
                lastItemTemp = item;
            }
            if (!isFirstSet)
                sender.First = null;
            sender.Last = lastItemTemp;
        }

        public DependencyProperty FirstProperty = DependencyProperty.Register(
            "First",
            typeof(object),
            typeof(CollectionHelper));

        public object First
        {
            get { return GetValue(FirstProperty); }
            set { SetValue(FirstProperty, value); }
        }

        public DependencyProperty LastProperty = DependencyProperty.Register(
            "Last",
            typeof(object),
            typeof(CollectionHelper));

        public object Last
        {
            get { return GetValue(LastProperty); }
            set { SetValue(LastProperty, value); }
        }
    }
}

And an actual use case:

<Window x:Class="WpfApplication1.MainWindow"
        xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
        xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
        xmlns:Helper="clr-namespace:WpfApplication1"
        Title="MainWindow" Height="350" Width="525">
    <StackPanel>
        <Helper:CollectionHelper x:Name="Helper" Collection="{Binding SomeStrings}" />
        <TextBlock Text="{Binding ElementName=Helper, Path=First}" />
        <TextBlock Text="{Binding ElementName=Helper, Path=Last}" />
    </StackPanel>
</Window>

So the idea here would be to grab the first and last item using the relay control and then bind to there margins.