Q:

Getting binding of transform property from code behind in ItemsControl

Xaml as below:
<ItemsControl
    x:Class="PowersOf2.Windows10.Views.Controls.Board"
    xmlns="http://schemas.microsoft.com/winfx/2006/xaml/presentation"
    xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml"
    xmlns:local="using:PowersOf2.Windows10.Views.Controls"
    xmlns:d="http://schemas.microsoft.com/expression/blend/2008"
    xmlns:mc="http://schemas.openxmlformats.org/markup-compatibility/2006"
    x:Name="Root" ItemsSource="{Binding Fields, ElementName=Root}" Loaded="Root_Loaded"
>
    <ItemsControl.ItemsPanel>
        <ItemsPanelTemplate>
            <Canvas/>
        </ItemsPanelTemplate>
    </ItemsControl.ItemsPanel>
    <ItemsControl.ItemTemplate>
        <DataTemplate>
            <Grid
                Width="{Binding FieldWidth, ElementName=Root}"
                Height="{Binding FieldHeight, ElementName=Root}"
                Loaded="Grid_Loaded" Background="White"
            >
                <Grid.RenderTransform>
                    <TranslateTransform X="{Binding X}" Y="{Binding Y}"/>
                </Grid.RenderTransform>
                <TextBlock Text="{Binding Text}" Foreground="Black"/>
            </Grid>
        </DataTemplate>
    </ItemsControl.ItemTemplate>
</ItemsControl>

Fields is IEnumerable of Field which has coordinates X and Y. They are managed by view model. FieldWidth and FieldHeight are dependency properties calculated in code behind.
How to get binding object of nested dependency properties such as TranslateTransform.X and TranslateTransform.Y in code behind?
UPDATE:
Based on this question: Fredrik's answer works as expected until you work with single embedded object in xaml with binding to non-nested properties, but not for nested ones. This issue is more complicated due to ItemsControl containing my Grid.
Code behind below:
using System.Collections.Generic;
using System.Collections.ObjectModel;
using System.ComponentModel;
using Windows.UI.Xaml;

namespace Controls
{
    public sealed partial class Board
    {
        public Board()
        {
            InitializeComponent();
        }

        private void Root_Loaded(object sender, RoutedEventArgs e)
        {
            FieldWidth = 100.0;
            FieldHeight = 100.0;
            Fields =
                new Field[]
                {
                    new Field { X = 100, Y = 100, Text = "one" },
                    new Field { X = 300, Y = 300, Text = "two" }
                };
        }

        public double FieldWidth
        {
            get { return (double)GetValue(FieldWidthProperty); }
            set { SetValue(FieldWidthProperty, value); }
        }
        public static readonly DependencyProperty FieldWidthProperty = DependencyProperty.Register(
            "FieldWidth", typeof(double), typeof(Board), new PropertyMetadata(0.0)
        );

        public double FieldHeight
        {
            get { return (double)GetValue(FieldHeightProperty); }
            set { SetValue(FieldHeightProperty, value); }
        }
        public static readonly DependencyProperty FieldHeightProperty = DependencyProperty.Register(
            "FieldHeight", typeof(double), typeof(Board), new PropertyMetadata(0.0)
        );

        public IEnumerable<Field> Fields
        {
            get { return (ObservableCollection<Field>)GetValue(FieldsProperty); }
            set { SetValue(FieldsProperty, value); }
        }
        public static readonly DependencyProperty FieldsProperty = DependencyProperty.Register(
            "Fields", typeof(IEnumerable<Field>), typeof(Board), new PropertyMetadata(null)
        );

        private void Grid_Loaded(object sender, RoutedEventArgs e)
        {
            // here I want to get binding of RenderTransform's properties
        }
    }

    public class Field : INotifyPropertyChanged
    {
        private int _x;
        public int X
        {
            get { return _x; }
            set
            {
                _x = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("X"));
            }
        }

        private int _y;
        public int Y
        {
            get { return _y; }
            set
            {
                _y = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Y"));
            }
        }

        private string _text;
        public string Text
        {
            get { return _text; }
            set
            {
                _text = value;
                PropertyChanged?.Invoke(this, new PropertyChangedEventArgs("Text"));
            }
        }

        public event PropertyChangedEventHandler PropertyChanged;
    }
}

A:

I hope I haven't misinterpreted the question but you can get the transformation and the bound item like this.
private void Grid_Loaded(object sender, RoutedEventArgs e)
{
    var grid = (Grid)sender;
    //the actual transformation
    var render = (Transform)grid.GetValue(RenderTransformProperty);
    //the field the transformation is bound to
    var field = (Field)grid.DataContext;

    //for now this only works in WPF
    var binding = BindingOperations.GetBinding(render, TranslateTransform.XProperty);
}

Made an edit for this, but it does not work for winrt.
The method BindingOperations.GetBinding is only available in WPF.
Hope that winrt gets this soon.

