Thanks, Graham.  You wouldn't happen to have an attached property for THIS lying around anywhere, would you?

Challenge accepted:

<Window x:Class="WpfApplication24.Window1"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    Title="Window1" Height="300" Width="300"
        xmlns:igChart="http://infragistics.com/Chart"
        xmlns:local="clr-namespace:WpfApplication24">

    <Window.Resources>
        <DataTemplate DataType="{x:Type igChart:ColumnChartTemplate}">
            <Border Background="{Binding Path=Fill}" BorderBrush="{Binding Path=Stroke}" 
		BorderThickness="{Binding Path=BorderThickness}" ToolTip="{Binding ToolTip}"
               local:DataManager.OwningChart="{Binding RelativeSource={RelativeSource FindAncestor, AncestorType={x:Type igChart:XamChart}}}"
                        >
                <local:DataManager.ItemInfoFetcher>
                    <local:ItemInfoFetcher x:Name="itemInfo"
                     />
                </local:DataManager.ItemInfoFetcher>
                <TextBlock Text="{Binding Item.Label, ElementName=itemInfo}" />
            </Border>
        </DataTemplate>
    </Window.Resources>

    <Grid x:Name="testGrid">
        <igChart:XamChart Name="testChart">
            <igChart:XamChart.Series>
                <igChart:Series ChartType="Column" 
                                DataSource="{Binding}"
                                DataMapping="Label=Label;Value=Value;ToolTip=Label"
                                UseDataTemplate="True"/>
            </igChart:XamChart.Series>
        </igChart:XamChart>
    </Grid>
</Window>

The code behind:

public class DataManager
    {
        public static readonly DependencyProperty ItemInfoFetcherProperty =
        DependencyProperty.RegisterAttached("ItemInfoFetcher",
        typeof(ItemInfoFetcher),
        typeof(DataManager),
        new PropertyMetadata(null,
            (o, e) =>
            {
                AssignFetcher(o as FrameworkElement, e);
            }));

        private static void AssignFetcher(FrameworkElement frameworkElement,
            DependencyPropertyChangedEventArgs e)
        {
            if (e.OldValue != null)
            {
                ItemInfoFetcher oldFetcher = e.OldValue as ItemInfoFetcher;
                oldFetcher.Element = null;
                oldFetcher.ClearValue(ItemInfoFetcher.OwningChartProperty);
            }

            ItemInfoFetcher fetcher = e.NewValue as ItemInfoFetcher;
            fetcher.Element = frameworkElement;
            fetcher.SetBinding(ItemInfoFetcher.OwningChartProperty,
                new Binding()
                {
                    Source = frameworkElement,
                    Path = new PropertyPath(DataManager.OwningChartProperty)
                });
        }

        public static ItemInfoFetcher GetItemInfoFetcher(DependencyObject target)
        {
            return (ItemInfoFetcher)target.GetValue(ItemInfoFetcherProperty);
        }

        public static void SetItemInfoFetcher(DependencyObject target,
            ItemInfoFetcher value)
        {
            target.SetValue(ItemInfoFetcherProperty, value);
        }

        public static readonly DependencyProperty ItemIndexProperty =
        DependencyProperty.RegisterAttached("ItemIndex",
        typeof(int),
        typeof(DataManager),
        new PropertyMetadata(-1));

        public static int GetItemIndex(DependencyObject target)
        {
            return (int)target.GetValue(ItemIndexProperty);
        }

        public static void SetItemIndex(DependencyObject target,
            int value)
        {
            target.SetValue(ItemIndexProperty, value);
        }

       public static readonly DependencyProperty SeriesIndexProperty =
       DependencyProperty.RegisterAttached("SeriesIndex",
       typeof(int),
       typeof(DataManager),
       new PropertyMetadata(-1));

        public static int GetSeriesIndex(DependencyObject target)
        {
            return (int)target.GetValue(SeriesIndexProperty);
        }

        public static void SetSeriesIndex(DependencyObject target,
            int value)
        {
            target.SetValue(SeriesIndexProperty, value);
        }

        public static readonly DependencyProperty OwningChartProperty =
        DependencyProperty.RegisterAttached("OwningChart",
        typeof(XamChart),
        typeof(DataManager),
        new PropertyMetadata(null));

        public static XamChart GetOwningChart(DependencyObject target)
        {
            return (XamChart)target.GetValue(OwningChartProperty);
        }

        public static void SetOwningChart(DependencyObject target,
            XamChart value)
        {
            target.SetValue(OwningChartProperty, value);
        }
    }

    public class ItemInfoFetcher
        : FrameworkElement
    {
        public static readonly DependencyProperty OwningChartProperty =
            DependencyProperty.Register("OwningChart",
            typeof(XamChart),
            typeof(ItemInfoFetcher),
            new PropertyMetadata(null,
                (o, e) =>
                {
                    (o as ItemInfoFetcher).OnOwningChartChanged(e);
                }));

        private void OnOwningChartChanged(DependencyPropertyChangedEventArgs e)
        {
            UpdateItem();
        }

        private void UpdateItem()
        {
            AssertTooltips();

            if (OwningChart != null &&
                Element != null)
            {
                FrameworkElement template = Element as FrameworkElement;
                if (template != null && template.ToolTip != null
                    && template.ToolTip is DependencyObject)
                {
                    int seriesIndex =
                        DataManager.GetSeriesIndex(
                        (DependencyObject)template.ToolTip);
                    int dataPointIndex =
                        DataManager.GetItemIndex(
                        (DependencyObject)template.ToolTip);
                    IList dataSource =
                        OwningChart.Series[seriesIndex].DataSource
                        as IList;
                    if (dataSource != null)
                    {
                        Item = dataSource[dataPointIndex];
                    }
                }
            }
        }

        private void AssertTooltips()
        {
            if (OwningChart != null)
            {
                bool needsRefresh = false;

                for (int s = 0; s < OwningChart.Series.Count; s++)
                {
                    Series series = OwningChart.Series[s];
                    for (int i = 0;
                        i < series.DataPoints.Count;
                        i++)
                    {
                        DataPoint dataPoint =
                            series.DataPoints[i];

                        if (dataPoint.ToolTip != null)
                        {
                            if (!(dataPoint.ToolTip
                                is DependencyObject))
                            {
                                needsRefresh = true;
                                dataPoint.ToolTip =
                                    new ContentPresenter()
                                    {
                                        Content =
                                        dataPoint.ToolTip
                                    };
                            }
                            if (DataManager.GetItemIndex(
                                (DependencyObject)dataPoint.ToolTip) < 0)
                            {
                                needsRefresh = true;
                                DataManager.SetItemIndex(
                                    (DependencyObject)dataPoint.ToolTip,
                                    i);
                                DataManager.SetSeriesIndex(
                                    (DependencyObject)dataPoint.ToolTip,
                                    s);
                            }
                            else
                            {
                                break;
                            }
                        }
                    }
                }

                if (needsRefresh)
                {
                    OwningChart.Refresh();
                }
            }
        }

        public XamChart OwningChart
        {
            get
            {
                return (XamChart)GetValue(OwningChartProperty);
            }
            set
            {
                SetValue(OwningChartProperty, value);
            }
        }

        public FrameworkElement Element { get; set; }

        public static readonly DependencyProperty ItemProperty =
          DependencyProperty.Register("Item",
          typeof(object),
          typeof(ItemInfoFetcher),
          new PropertyMetadata(null));

        public object Item
        {
            get
            {
                return (object)GetValue(ItemProperty);
            }
            set
            {
                SetValue(ItemProperty, value);
            }
        }
    }

Note this relies on there being at least some form of ToolTip set on the chart.
If this is a problem you could probably style the ToolTips invisible.

-Graham

I can't that you enough.  I was doing this much less elegantly by passing all of the data through the ToolTip mapping and then refering to ToolTip.This and ToolTip.That in the ColumnChartTemplate.

You're welcome, glad I could help out.

-Graham