microsoft-ui-xaml/controls/dev/Generated/TableViewColumn.properties.cpp

// Copyright (c) Microsoft Corporation. All rights reserved.
// Licensed under the MIT License. See LICENSE in the project root for license information.

// DO NOT EDIT! This file was generated by CustomTasks.DependencyPropertyCodeGen
#include "pch.h"
#include "common.h"
#include "TableViewColumn.h"

namespace winrt::Microsoft::UI::Xaml::Controls::Tabular
{
    CppWinRTActivatableClassWithDPFactory(TableViewColumn)
}

#include "TableViewColumn.g.cpp"

GlobalDependencyProperty TableViewColumnProperties::s_ActualWidthProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_CanResizeProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_CanSortProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_CellContextFlyoutProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_CellEditingTemplateProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_FrozenEdgeProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderContextFlyoutProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderStyleProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderTemplateProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderTemplateSelectorProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_HeaderToolTipProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_IsReadOnlyProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_MaxWidthProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_MinWidthProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_SortCycleProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_SortDirectionProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_SortMemberPathProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_VisibilityProperty{ nullptr };
GlobalDependencyProperty TableViewColumnProperties::s_WidthProperty{ nullptr };

TableViewColumnProperties::TableViewColumnProperties()
{
    EnsureProperties();
}

void TableViewColumnProperties::EnsureProperties()
{
    if (!s_ActualWidthProperty)
    {
        s_ActualWidthProperty =
            InitializeDependencyProperty(
                L"ActualWidth",
                winrt::name_of<double>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<double>::BoxValueIfNecessary(120.0),
                nullptr);
    }
    if (!s_CanResizeProperty)
    {
        s_CanResizeProperty =
            InitializeDependencyProperty(
                L"CanResize",
                winrt::name_of<bool>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<bool>::BoxValueIfNecessary(true),
                winrt::PropertyChangedCallback(&OnCanResizePropertyChanged));
    }
    if (!s_CanSortProperty)
    {
        s_CanSortProperty =
            InitializeDependencyProperty(
                L"CanSort",
                winrt::name_of<bool>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<bool>::BoxValueIfNecessary(true),
                winrt::PropertyChangedCallback(&OnCanSortPropertyChanged));
    }
    if (!s_CellContextFlyoutProperty)
    {
        s_CellContextFlyoutProperty =
            InitializeDependencyProperty(
                L"CellContextFlyout",
                winrt::name_of<winrt::FlyoutBase>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::FlyoutBase>::BoxedDefaultValue(),
                nullptr);
    }
    if (!s_CellEditingTemplateProperty)
    {
        s_CellEditingTemplateProperty =
            InitializeDependencyProperty(
                L"CellEditingTemplate",
                winrt::name_of<winrt::DataTemplate>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::DataTemplate>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnCellEditingTemplatePropertyChanged));
    }
    if (!s_FrozenEdgeProperty)
    {
        s_FrozenEdgeProperty =
            InitializeDependencyProperty(
                L"FrozenEdge",
                winrt::name_of<winrt::TableViewFrozenEdge>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::TableViewFrozenEdge>::BoxValueIfNecessary(winrt::TableViewFrozenEdge::None),
                winrt::PropertyChangedCallback(&OnFrozenEdgePropertyChanged));
    }
    if (!s_HeaderProperty)
    {
        s_HeaderProperty =
            InitializeDependencyProperty(
                L"Header",
                winrt::name_of<winrt::IInspectable>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::IInspectable>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnHeaderPropertyChanged));
    }
    if (!s_HeaderContextFlyoutProperty)
    {
        s_HeaderContextFlyoutProperty =
            InitializeDependencyProperty(
                L"HeaderContextFlyout",
                winrt::name_of<winrt::FlyoutBase>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::FlyoutBase>::BoxedDefaultValue(),
                nullptr);
    }
    if (!s_HeaderStyleProperty)
    {
        s_HeaderStyleProperty =
            InitializeDependencyProperty(
                L"HeaderStyle",
                winrt::name_of<winrt::Style>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::Style>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnHeaderStylePropertyChanged));
    }
    if (!s_HeaderTemplateProperty)
    {
        s_HeaderTemplateProperty =
            InitializeDependencyProperty(
                L"HeaderTemplate",
                winrt::name_of<winrt::DataTemplate>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::DataTemplate>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnHeaderTemplatePropertyChanged));
    }
    if (!s_HeaderTemplateSelectorProperty)
    {
        s_HeaderTemplateSelectorProperty =
            InitializeDependencyProperty(
                L"HeaderTemplateSelector",
                winrt::name_of<winrt::DataTemplateSelector>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::DataTemplateSelector>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnHeaderTemplateSelectorPropertyChanged));
    }
    if (!s_HeaderToolTipProperty)
    {
        s_HeaderToolTipProperty =
            InitializeDependencyProperty(
                L"HeaderToolTip",
                winrt::name_of<winrt::IInspectable>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::IInspectable>::BoxedDefaultValue(),
                winrt::PropertyChangedCallback(&OnHeaderToolTipPropertyChanged));
    }
    if (!s_IsReadOnlyProperty)
    {
        s_IsReadOnlyProperty =
            InitializeDependencyProperty(
                L"IsReadOnly",
                winrt::name_of<bool>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<bool>::BoxValueIfNecessary(false),
                winrt::PropertyChangedCallback(&OnIsReadOnlyPropertyChanged));
    }
    if (!s_MaxWidthProperty)
    {
        s_MaxWidthProperty =
            InitializeDependencyProperty(
                L"MaxWidth",
                winrt::name_of<double>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<double>::BoxValueIfNecessary(std::numeric_limits<double>::infinity()),
                winrt::PropertyChangedCallback(&OnMaxWidthPropertyChanged));
    }
    if (!s_MinWidthProperty)
    {
        s_MinWidthProperty =
            InitializeDependencyProperty(
                L"MinWidth",
                winrt::name_of<double>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<double>::BoxValueIfNecessary(20.0),
                winrt::PropertyChangedCallback(&OnMinWidthPropertyChanged));
    }
    if (!s_SortCycleProperty)
    {
        s_SortCycleProperty =
            InitializeDependencyProperty(
                L"SortCycle",
                winrt::name_of<winrt::TableViewSortCycle>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::TableViewSortCycle>::BoxValueIfNecessary(winrt::TableViewSortCycle::AscendingDescending),
                nullptr);
    }
    if (!s_SortDirectionProperty)
    {
        s_SortDirectionProperty =
            InitializeDependencyProperty(
                L"SortDirection",
                winrt::name_of<winrt::SortDirection>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::SortDirection>::BoxValueIfNecessary(winrt::SortDirection::None),
                nullptr);
    }
    if (!s_SortMemberPathProperty)
    {
        s_SortMemberPathProperty =
            InitializeDependencyProperty(
                L"SortMemberPath",
                winrt::name_of<winrt::hstring>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::hstring>::BoxedDefaultValue(),
                nullptr);
    }
    if (!s_VisibilityProperty)
    {
        s_VisibilityProperty =
            InitializeDependencyProperty(
                L"Visibility",
                winrt::name_of<winrt::Visibility>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::Visibility>::BoxValueIfNecessary(winrt::Visibility::Visible),
                winrt::PropertyChangedCallback(&OnVisibilityPropertyChanged));
    }
    if (!s_WidthProperty)
    {
        s_WidthProperty =
            InitializeDependencyProperty(
                L"Width",
                winrt::name_of<winrt::GridLength>(),
                winrt::name_of<winrt::TableViewColumn>(),
                false /* isAttached */,
                ValueHelper<winrt::GridLength>::BoxValueIfNecessary(c_widthDefault),
                winrt::PropertyChangedCallback(&OnWidthPropertyChanged));
    }
}

void TableViewColumnProperties::ClearProperties()
{
    s_ActualWidthProperty = nullptr;
    s_CanResizeProperty = nullptr;
    s_CanSortProperty = nullptr;
    s_CellContextFlyoutProperty = nullptr;
    s_CellEditingTemplateProperty = nullptr;
    s_FrozenEdgeProperty = nullptr;
    s_HeaderProperty = nullptr;
    s_HeaderContextFlyoutProperty = nullptr;
    s_HeaderStyleProperty = nullptr;
    s_HeaderTemplateProperty = nullptr;
    s_HeaderTemplateSelectorProperty = nullptr;
    s_HeaderToolTipProperty = nullptr;
    s_IsReadOnlyProperty = nullptr;
    s_MaxWidthProperty = nullptr;
    s_MinWidthProperty = nullptr;
    s_SortCycleProperty = nullptr;
    s_SortDirectionProperty = nullptr;
    s_SortMemberPathProperty = nullptr;
    s_VisibilityProperty = nullptr;
    s_WidthProperty = nullptr;
}

void TableViewColumnProperties::OnCanResizePropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnCanSortPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnCellEditingTemplatePropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnFrozenEdgePropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnHeaderPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnHeaderStylePropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnHeaderTemplatePropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnHeaderTemplateSelectorPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnHeaderToolTipPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnIsReadOnlyPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnMaxWidthPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnMinWidthPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnVisibilityPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::OnWidthPropertyChanged(
    winrt::DependencyObject const& sender,
    winrt::DependencyPropertyChangedEventArgs const& args)
{
    auto owner = sender.as<winrt::TableViewColumn>();
    winrt::get_self<TableViewColumn>(owner)->OnPropertyChanged(args);
}

void TableViewColumnProperties::ActualWidth(double value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_ActualWidthProperty, ValueHelper<double>::BoxValueIfNecessary(value));
    }
}

double TableViewColumnProperties::ActualWidth()
{
    return ValueHelper<double>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_ActualWidthProperty));
}

void TableViewColumnProperties::CanResize(bool value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_CanResizeProperty, ValueHelper<bool>::BoxValueIfNecessary(value));
    }
}

bool TableViewColumnProperties::CanResize()
{
    return ValueHelper<bool>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_CanResizeProperty));
}

void TableViewColumnProperties::CanSort(bool value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_CanSortProperty, ValueHelper<bool>::BoxValueIfNecessary(value));
    }
}

bool TableViewColumnProperties::CanSort()
{
    return ValueHelper<bool>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_CanSortProperty));
}

void TableViewColumnProperties::CellContextFlyout(winrt::FlyoutBase const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_CellContextFlyoutProperty, ValueHelper<winrt::FlyoutBase>::BoxValueIfNecessary(value));
    }
}

winrt::FlyoutBase TableViewColumnProperties::CellContextFlyout()
{
    return ValueHelper<winrt::FlyoutBase>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_CellContextFlyoutProperty));
}

void TableViewColumnProperties::CellEditingTemplate(winrt::DataTemplate const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_CellEditingTemplateProperty, ValueHelper<winrt::DataTemplate>::BoxValueIfNecessary(value));
    }
}

winrt::DataTemplate TableViewColumnProperties::CellEditingTemplate()
{
    return ValueHelper<winrt::DataTemplate>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_CellEditingTemplateProperty));
}

void TableViewColumnProperties::FrozenEdge(winrt::TableViewFrozenEdge const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_FrozenEdgeProperty, ValueHelper<winrt::TableViewFrozenEdge>::BoxValueIfNecessary(value));
    }
}

winrt::TableViewFrozenEdge TableViewColumnProperties::FrozenEdge()
{
    return ValueHelper<winrt::TableViewFrozenEdge>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_FrozenEdgeProperty));
}

void TableViewColumnProperties::Header(winrt::IInspectable const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderProperty, ValueHelper<winrt::IInspectable>::BoxValueIfNecessary(value));
    }
}

winrt::IInspectable TableViewColumnProperties::Header()
{
    return ValueHelper<winrt::IInspectable>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderProperty));
}

void TableViewColumnProperties::HeaderContextFlyout(winrt::FlyoutBase const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderContextFlyoutProperty, ValueHelper<winrt::FlyoutBase>::BoxValueIfNecessary(value));
    }
}

winrt::FlyoutBase TableViewColumnProperties::HeaderContextFlyout()
{
    return ValueHelper<winrt::FlyoutBase>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderContextFlyoutProperty));
}

void TableViewColumnProperties::HeaderStyle(winrt::Style const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderStyleProperty, ValueHelper<winrt::Style>::BoxValueIfNecessary(value));
    }
}

winrt::Style TableViewColumnProperties::HeaderStyle()
{
    return ValueHelper<winrt::Style>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderStyleProperty));
}

void TableViewColumnProperties::HeaderTemplate(winrt::DataTemplate const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderTemplateProperty, ValueHelper<winrt::DataTemplate>::BoxValueIfNecessary(value));
    }
}

winrt::DataTemplate TableViewColumnProperties::HeaderTemplate()
{
    return ValueHelper<winrt::DataTemplate>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderTemplateProperty));
}

void TableViewColumnProperties::HeaderTemplateSelector(winrt::DataTemplateSelector const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderTemplateSelectorProperty, ValueHelper<winrt::DataTemplateSelector>::BoxValueIfNecessary(value));
    }
}

winrt::DataTemplateSelector TableViewColumnProperties::HeaderTemplateSelector()
{
    return ValueHelper<winrt::DataTemplateSelector>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderTemplateSelectorProperty));
}

void TableViewColumnProperties::HeaderToolTip(winrt::IInspectable const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_HeaderToolTipProperty, ValueHelper<winrt::IInspectable>::BoxValueIfNecessary(value));
    }
}

winrt::IInspectable TableViewColumnProperties::HeaderToolTip()
{
    return ValueHelper<winrt::IInspectable>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_HeaderToolTipProperty));
}

void TableViewColumnProperties::IsReadOnly(bool value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_IsReadOnlyProperty, ValueHelper<bool>::BoxValueIfNecessary(value));
    }
}

bool TableViewColumnProperties::IsReadOnly()
{
    return ValueHelper<bool>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_IsReadOnlyProperty));
}

void TableViewColumnProperties::MaxWidth(double value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_MaxWidthProperty, ValueHelper<double>::BoxValueIfNecessary(value));
    }
}

double TableViewColumnProperties::MaxWidth()
{
    return ValueHelper<double>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_MaxWidthProperty));
}

void TableViewColumnProperties::MinWidth(double value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_MinWidthProperty, ValueHelper<double>::BoxValueIfNecessary(value));
    }
}

double TableViewColumnProperties::MinWidth()
{
    return ValueHelper<double>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_MinWidthProperty));
}

void TableViewColumnProperties::SortCycle(winrt::TableViewSortCycle const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_SortCycleProperty, ValueHelper<winrt::TableViewSortCycle>::BoxValueIfNecessary(value));
    }
}

winrt::TableViewSortCycle TableViewColumnProperties::SortCycle()
{
    return ValueHelper<winrt::TableViewSortCycle>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_SortCycleProperty));
}

void TableViewColumnProperties::SortDirection(winrt::SortDirection const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_SortDirectionProperty, ValueHelper<winrt::SortDirection>::BoxValueIfNecessary(value));
    }
}

winrt::SortDirection TableViewColumnProperties::SortDirection()
{
    return ValueHelper<winrt::SortDirection>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_SortDirectionProperty));
}

void TableViewColumnProperties::SortMemberPath(winrt::hstring const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_SortMemberPathProperty, ValueHelper<winrt::hstring>::BoxValueIfNecessary(value));
    }
}

winrt::hstring TableViewColumnProperties::SortMemberPath()
{
    return ValueHelper<winrt::hstring>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_SortMemberPathProperty));
}

void TableViewColumnProperties::Visibility(winrt::Visibility const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_VisibilityProperty, ValueHelper<winrt::Visibility>::BoxValueIfNecessary(value));
    }
}

winrt::Visibility TableViewColumnProperties::Visibility()
{
    return ValueHelper<winrt::Visibility>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_VisibilityProperty));
}

void TableViewColumnProperties::Width(winrt::GridLength const& value)
{
    [[gsl::suppress(con)]]
    {
    static_cast<TableViewColumn*>(this)->SetValue(s_WidthProperty, ValueHelper<winrt::GridLength>::BoxValueIfNecessary(value));
    }
}

winrt::GridLength TableViewColumnProperties::Width()
{
    return ValueHelper<winrt::GridLength>::CastOrUnbox(static_cast<TableViewColumn*>(this)->GetValue(s_WidthProperty));
}