Question: I need ti display with ng-table in one column datetime:

var renderGrid = function(tableData) {

```
        $scope.tableData = tableData;

        if($scope.tableParams) { 
            $scope.tableParams.reload();
        } else {
            $scope.tableParams = new ngTableParams({
                page: 1,
                count: 10,
                sorting: {
                    date: 'asc'
                },
                filter: {
                    date: ''
                }
            }, {
                getData: function($defer, params) {
                    var sliceStart = (params.page() - 1) * params.count();
                    var sliceEnd = params.page() * params.count();
                    var orderedData = params.filter() ? $filter('filter')($scope.tableData, params.filter()) : $scope.tableData;
                    var filteredData = params.sorting() ? $filter('orderBy')(orderedData, params.orderBy()) : $scope.tableData;
                    $scope.totalCount = filteredData.length;
                    params.total(filteredData.length);
                    $defer.resolve(filteredData.slice(sliceStart, sliceEnd));
                }
            });                     
        }
    };

    <table ng-table="tableParams" template-pagination="tcTableNav" class="tcTable">
            <tr ng-repeat="item in $data">
                <td style="width:34%" sortable="'date'" data-title="'Date'"><div>{{item.date}}</div></td>
            <td style="width:33%" sortable="'autor'" data-title="'Autor'"><div>{{item.autor}}</div></td>
            <td style="width:33%" sortable="'article'" data-title="'Article'"><div>{{item.article}}</div></td>
        </tr>
      </table> 

```

How form datetime correctly that sorting + filtering work correctly?

Answer: 
Inspired by the answer of "HDW Production", here's the code for Windows Store and Windows Phone Store apps:

```
public class FadingVisibilityGrid : Grid
{
    public static readonly DependencyProperty DeferredVisibilityProperty = DependencyProperty.Register(
        "DeferredVisibility", typeof (Visibility), typeof (FadingVisibilityGrid), new PropertyMetadata(default(Visibility), DeferredVisibilityChanged));

    private static void DeferredVisibilityChanged(DependencyObject sender, DependencyPropertyChangedEventArgs e)
    {
        var newVisibility = (Visibility)e.NewValue;
        var grid = (FadingVisibilityGrid)sender;

        var animation = new DoubleAnimation
        {
            Duration = new Duration(TimeSpan.FromMilliseconds(200))
        };
        Storyboard.SetTarget(animation, grid);
        Storyboard.SetTargetProperty(animation, "Grid.Opacity");
        grid.FadeStoryBoard.Stop();
        grid.FadeStoryBoard = new Storyboard();
        grid.FadeStoryBoard.Children.Add(animation);

        if (newVisibility == Visibility.Visible)
        {
            animation.From = 0;
            animation.To = 1;
            grid.Visibility = Visibility.Visible;
            grid.FadeStoryBoard.Begin();
        }
        else
        {
            animation.From = 1;
            animation.To = 0;
            grid.FadeStoryBoard.Completed += (o, o1) =>
            {
                grid.Visibility = newVisibility;
            };
            grid.FadeStoryBoard.Begin();
        }

    }

    public Visibility DeferredVisibility
    {
        get { return (Visibility) GetValue(DeferredVisibilityProperty); }
        set { SetValue(DeferredVisibilityProperty, value); }
    }

    private Storyboard _fadeStoryBoard = new Storyboard();

    public Storyboard FadeStoryBoard
    {
        get { return _fadeStoryBoard; }
        set { _fadeStoryBoard = value; }
    }
}

```
You need a new DependencyProperty, either by inheriting from Grid and adding one or by creating an attached property. Let's call it DeferredVisibility and let it be of type Visibility.

When DeferredVisibility is changed to Visible, set the Visibility to Visible and animate the opacity from 0 to 1.

When DeferredVisibility is changed to Collapsed, animate the opacity from 1 to 0 and THEN set the Visibility to Collapsed.