swiftui-native 0.0.1

//! Style modifiers.

use super::*;
use crate::resolve;
use core::ffi::c_void;
//
// `.listStyle`, `.pickerStyle`, `.toggleStyle` and their siblings are generic
// over a protocol, so each takes a *concrete* style type. The enums below name
// the types conforming to each protocol; every one is a resilient struct with
// an `init()` and a witness table, which is all `style_modifier` needs.
//
// `.containerShape` is missing: it has two overloads differing only by an extra
// constraint, and picking between them needs more than the name.

/// The concrete types conforming to `SwiftUI.ShapeStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ShapeStyle {
    BackgroundStyle,
    ForegroundStyle,
    LinkShapeStyle,
    SelectionShapeStyle,
    SeparatorShapeStyle,
    TintShapeStyle,
    WindowBackgroundShapeStyle,
}

impl ShapeStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::BackgroundStyle => (resolve::background_style_ma(), resolve::background_style_wt(), resolve::background_style_init()),
            Self::ForegroundStyle => (resolve::foreground_style_ma(), resolve::foreground_style_wt(), resolve::foreground_style_init()),
            Self::LinkShapeStyle => (resolve::link_shape_style_ma(), resolve::link_shape_style_wt(), resolve::link_shape_style_init()),
            Self::SelectionShapeStyle => (resolve::selection_shape_style_ma(), resolve::selection_shape_style_wt(), resolve::selection_shape_style_init()),
            Self::SeparatorShapeStyle => (resolve::separator_shape_style_ma(), resolve::separator_shape_style_wt(), resolve::separator_shape_style_init()),
            Self::TintShapeStyle => (resolve::tint_shape_style_ma(), resolve::tint_shape_style_wt(), resolve::tint_shape_style_init()),
            Self::WindowBackgroundShapeStyle => (resolve::window_background_shape_style_ma(), resolve::window_background_shape_style_wt(), resolve::window_background_shape_style_init()),
        }
    }
}


/// The concrete types conforming to `SwiftUI.ControlGroupStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ControlGroupStyle {
    AutomaticControlGroupStyle,
    CompactMenuControlGroupStyle,
    MenuControlGroupStyle,
    NavigationControlGroupStyle,
    PaletteControlGroupStyle,
}

impl ControlGroupStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticControlGroupStyle => (resolve::automatic_control_group_style_ma(), resolve::automatic_control_group_style_wt(), resolve::automatic_control_group_style_init()),
            Self::CompactMenuControlGroupStyle => (resolve::compact_menu_control_group_style_ma(), resolve::compact_menu_control_group_style_wt(), resolve::compact_menu_control_group_style_init()),
            Self::MenuControlGroupStyle => (resolve::menu_control_group_style_ma(), resolve::menu_control_group_style_wt(), resolve::menu_control_group_style_init()),
            Self::NavigationControlGroupStyle => (resolve::navigation_control_group_style_ma(), resolve::navigation_control_group_style_wt(), resolve::navigation_control_group_style_init()),
            Self::PaletteControlGroupStyle => (resolve::palette_control_group_style_ma(), resolve::palette_control_group_style_wt(), resolve::palette_control_group_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.DatePickerStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DatePickerStyle {
    CompactDatePickerStyle,
    DefaultDatePickerStyle,
    FieldDatePickerStyle,
    GraphicalDatePickerStyle,
    StepperFieldDatePickerStyle,
}

impl DatePickerStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::CompactDatePickerStyle => (resolve::compact_date_picker_style_ma(), resolve::compact_date_picker_style_wt(), resolve::compact_date_picker_style_init()),
            Self::DefaultDatePickerStyle => (resolve::default_date_picker_style_ma(), resolve::default_date_picker_style_wt(), resolve::default_date_picker_style_init()),
            Self::FieldDatePickerStyle => (resolve::field_date_picker_style_ma(), resolve::field_date_picker_style_wt(), resolve::field_date_picker_style_init()),
            Self::GraphicalDatePickerStyle => (resolve::graphical_date_picker_style_ma(), resolve::graphical_date_picker_style_wt(), resolve::graphical_date_picker_style_init()),
            Self::StepperFieldDatePickerStyle => (resolve::stepper_field_date_picker_style_ma(), resolve::stepper_field_date_picker_style_wt(), resolve::stepper_field_date_picker_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.DisclosureGroupStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum DisclosureGroupStyle {
    AutomaticDisclosureGroupStyle,
}

impl DisclosureGroupStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticDisclosureGroupStyle => (resolve::automatic_disclosure_group_style_ma(), resolve::automatic_disclosure_group_style_wt(), resolve::automatic_disclosure_group_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.FormStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum FormStyle {
    AutomaticFormStyle,
    ColumnsFormStyle,
    GroupedFormStyle,
}

impl FormStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticFormStyle => (resolve::automatic_form_style_ma(), resolve::automatic_form_style_wt(), resolve::automatic_form_style_init()),
            Self::ColumnsFormStyle => (resolve::columns_form_style_ma(), resolve::columns_form_style_wt(), resolve::columns_form_style_init()),
            Self::GroupedFormStyle => (resolve::grouped_form_style_ma(), resolve::grouped_form_style_wt(), resolve::grouped_form_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.GaugeStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GaugeStyle {
    AccessoryCircularCapacityGaugeStyle,
    AccessoryCircularGaugeStyle,
    AccessoryLinearCapacityGaugeStyle,
    AccessoryLinearGaugeStyle,
    DefaultGaugeStyle,
    LinearCapacityGaugeStyle,
}

impl GaugeStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AccessoryCircularCapacityGaugeStyle => (resolve::accessory_circular_capacity_gauge_style_ma(), resolve::accessory_circular_capacity_gauge_style_wt(), resolve::accessory_circular_capacity_gauge_style_init()),
            Self::AccessoryCircularGaugeStyle => (resolve::accessory_circular_gauge_style_ma(), resolve::accessory_circular_gauge_style_wt(), resolve::accessory_circular_gauge_style_init()),
            Self::AccessoryLinearCapacityGaugeStyle => (resolve::accessory_linear_capacity_gauge_style_ma(), resolve::accessory_linear_capacity_gauge_style_wt(), resolve::accessory_linear_capacity_gauge_style_init()),
            Self::AccessoryLinearGaugeStyle => (resolve::accessory_linear_gauge_style_ma(), resolve::accessory_linear_gauge_style_wt(), resolve::accessory_linear_gauge_style_init()),
            Self::DefaultGaugeStyle => (resolve::default_gauge_style_ma(), resolve::default_gauge_style_wt(), resolve::default_gauge_style_init()),
            Self::LinearCapacityGaugeStyle => (resolve::linear_capacity_gauge_style_ma(), resolve::linear_capacity_gauge_style_wt(), resolve::linear_capacity_gauge_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.GroupBoxStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum GroupBoxStyle {
    DefaultGroupBoxStyle,
}

impl GroupBoxStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultGroupBoxStyle => (resolve::default_group_box_style_ma(), resolve::default_group_box_style_wt(), resolve::default_group_box_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.LabelStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LabelStyle {
    DefaultLabelStyle,
    IconOnlyLabelStyle,
    TitleAndIconLabelStyle,
    TitleOnlyLabelStyle,
}

impl LabelStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultLabelStyle => (resolve::default_label_style_ma(), resolve::default_label_style_wt(), resolve::default_label_style_init()),
            Self::IconOnlyLabelStyle => (resolve::icon_only_label_style_ma(), resolve::icon_only_label_style_wt(), resolve::icon_only_label_style_init()),
            Self::TitleAndIconLabelStyle => (resolve::title_and_icon_label_style_ma(), resolve::title_and_icon_label_style_wt(), resolve::title_and_icon_label_style_init()),
            Self::TitleOnlyLabelStyle => (resolve::title_only_label_style_ma(), resolve::title_only_label_style_wt(), resolve::title_only_label_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.LabeledContentStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum LabeledContentStyle {
    AutomaticLabeledContentStyle,
}

impl LabeledContentStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticLabeledContentStyle => (resolve::automatic_labeled_content_style_ma(), resolve::automatic_labeled_content_style_wt(), resolve::automatic_labeled_content_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.ListStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ListStyle {
    BorderedListStyle,
    DefaultListStyle,
    InsetListStyle,
    PlainListStyle,
    SidebarListStyle,
}

impl ListStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::BorderedListStyle => (resolve::bordered_list_style_ma(), resolve::bordered_list_style_wt(), resolve::bordered_list_style_init()),
            Self::DefaultListStyle => (resolve::default_list_style_ma(), resolve::default_list_style_wt(), resolve::default_list_style_init()),
            Self::InsetListStyle => (resolve::inset_list_style_ma(), resolve::inset_list_style_wt(), resolve::inset_list_style_init()),
            Self::PlainListStyle => (resolve::plain_list_style_ma(), resolve::plain_list_style_wt(), resolve::plain_list_style_init()),
            Self::SidebarListStyle => (resolve::sidebar_list_style_ma(), resolve::sidebar_list_style_wt(), resolve::sidebar_list_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.MenuButtonStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MenuButtonStyle {
    BorderlessPullDownMenuButtonStyle,
    DefaultMenuButtonStyle,
    PullDownMenuButtonStyle,
}

impl MenuButtonStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::BorderlessPullDownMenuButtonStyle => (resolve::borderless_pull_down_menu_button_style_ma(), resolve::borderless_pull_down_menu_button_style_wt(), resolve::borderless_pull_down_menu_button_style_init()),
            Self::DefaultMenuButtonStyle => (resolve::default_menu_button_style_ma(), resolve::default_menu_button_style_wt(), resolve::default_menu_button_style_init()),
            Self::PullDownMenuButtonStyle => (resolve::pull_down_menu_button_style_ma(), resolve::pull_down_menu_button_style_wt(), resolve::pull_down_menu_button_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.MenuStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum MenuStyle {
    BorderedButtonMenuStyle,
    BorderlessButtonMenuStyle,
    ButtonMenuStyle,
    DefaultMenuStyle,
}

impl MenuStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::BorderedButtonMenuStyle => (resolve::bordered_button_menu_style_ma(), resolve::bordered_button_menu_style_wt(), resolve::bordered_button_menu_style_init()),
            Self::BorderlessButtonMenuStyle => (resolve::borderless_button_menu_style_ma(), resolve::borderless_button_menu_style_wt(), resolve::borderless_button_menu_style_init()),
            Self::ButtonMenuStyle => (resolve::button_menu_style_ma(), resolve::button_menu_style_wt(), resolve::button_menu_style_init()),
            Self::DefaultMenuStyle => (resolve::default_menu_style_ma(), resolve::default_menu_style_wt(), resolve::default_menu_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.PickerStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum PickerStyle {
    DefaultPickerStyle,
    InlinePickerStyle,
    MenuPickerStyle,
    PalettePickerStyle,
    PopUpButtonPickerStyle,
    RadioGroupPickerStyle,
    SegmentedPickerStyle,
}

impl PickerStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultPickerStyle => (resolve::default_picker_style_ma(), resolve::default_picker_style_wt(), resolve::default_picker_style_init()),
            Self::InlinePickerStyle => (resolve::inline_picker_style_ma(), resolve::inline_picker_style_wt(), resolve::inline_picker_style_init()),
            Self::MenuPickerStyle => (resolve::menu_picker_style_ma(), resolve::menu_picker_style_wt(), resolve::menu_picker_style_init()),
            Self::PalettePickerStyle => (resolve::palette_picker_style_ma(), resolve::palette_picker_style_wt(), resolve::palette_picker_style_init()),
            Self::PopUpButtonPickerStyle => (resolve::pop_up_button_picker_style_ma(), resolve::pop_up_button_picker_style_wt(), resolve::pop_up_button_picker_style_init()),
            Self::RadioGroupPickerStyle => (resolve::radio_group_picker_style_ma(), resolve::radio_group_picker_style_wt(), resolve::radio_group_picker_style_init()),
            Self::SegmentedPickerStyle => (resolve::segmented_picker_style_ma(), resolve::segmented_picker_style_wt(), resolve::segmented_picker_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.WindowStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WindowStyle {
    DefaultWindowStyle,
    HiddenTitleBarWindowStyle,
    PlainWindowStyle,
    TitleBarWindowStyle,
}

impl WindowStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultWindowStyle => (resolve::default_window_style_ma(), resolve::default_window_style_wt(), resolve::default_window_style_init()),
            Self::HiddenTitleBarWindowStyle => (resolve::hidden_title_bar_window_style_ma(), resolve::hidden_title_bar_window_style_wt(), resolve::hidden_title_bar_window_style_init()),
            Self::PlainWindowStyle => (resolve::plain_window_style_ma(), resolve::plain_window_style_wt(), resolve::plain_window_style_init()),
            Self::TitleBarWindowStyle => (resolve::title_bar_window_style_ma(), resolve::title_bar_window_style_wt(), resolve::title_bar_window_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.WindowToolbarStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum WindowToolbarStyle {
    DefaultWindowToolbarStyle,
    ExpandedWindowToolbarStyle,
    UnifiedCompactWindowToolbarStyle,
    UnifiedWindowToolbarStyle,
}

impl WindowToolbarStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultWindowToolbarStyle => (resolve::default_window_toolbar_style_ma(), resolve::default_window_toolbar_style_wt(), resolve::default_window_toolbar_style_init()),
            Self::ExpandedWindowToolbarStyle => (resolve::expanded_window_toolbar_style_ma(), resolve::expanded_window_toolbar_style_wt(), resolve::expanded_window_toolbar_style_init()),
            Self::UnifiedCompactWindowToolbarStyle => (resolve::unified_compact_window_toolbar_style_ma(), resolve::unified_compact_window_toolbar_style_wt(), resolve::unified_compact_window_toolbar_style_init()),
            Self::UnifiedWindowToolbarStyle => (resolve::unified_window_toolbar_style_ma(), resolve::unified_window_toolbar_style_wt(), resolve::unified_window_toolbar_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.ScrollTargetBehavior`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ScrollTargetBehavior {
    PagingScrollTargetBehavior,
}

impl ScrollTargetBehavior {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::PagingScrollTargetBehavior => (resolve::paging_scroll_target_behavior_ma(), resolve::paging_scroll_target_behavior_wt(), resolve::paging_scroll_target_behavior_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.TableStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TableStyle {
    AutomaticTableStyle,
    BorderedTableStyle,
    InsetTableStyle,
}

impl TableStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticTableStyle => (resolve::automatic_table_style_ma(), resolve::automatic_table_style_wt(), resolve::automatic_table_style_init()),
            Self::BorderedTableStyle => (resolve::bordered_table_style_ma(), resolve::bordered_table_style_wt(), resolve::bordered_table_style_init()),
            Self::InsetTableStyle => (resolve::inset_table_style_ma(), resolve::inset_table_style_wt(), resolve::inset_table_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.TextEditorStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TextEditorStyle {
    AutomaticTextEditorStyle,
    PlainTextEditorStyle,
}

impl TextEditorStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::AutomaticTextEditorStyle => (resolve::automatic_text_editor_style_ma(), resolve::automatic_text_editor_style_wt(), resolve::automatic_text_editor_style_init()),
            Self::PlainTextEditorStyle => (resolve::plain_text_editor_style_ma(), resolve::plain_text_editor_style_wt(), resolve::plain_text_editor_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.TextFieldStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TextFieldStyle {
    DefaultTextFieldStyle,
    PlainTextFieldStyle,
    RoundedBorderTextFieldStyle,
    SquareBorderTextFieldStyle,
}

impl TextFieldStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DefaultTextFieldStyle => (resolve::default_text_field_style_ma(), resolve::default_text_field_style_wt(), resolve::default_text_field_style_init()),
            Self::PlainTextFieldStyle => (resolve::plain_text_field_style_ma(), resolve::plain_text_field_style_wt(), resolve::plain_text_field_style_init()),
            Self::RoundedBorderTextFieldStyle => (resolve::rounded_border_text_field_style_ma(), resolve::rounded_border_text_field_style_wt(), resolve::rounded_border_text_field_style_init()),
            Self::SquareBorderTextFieldStyle => (resolve::square_border_text_field_style_ma(), resolve::square_border_text_field_style_wt(), resolve::square_border_text_field_style_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.TextSelectability`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum TextSelectability {
    DisabledTextSelectability,
    EnabledTextSelectability,
}

impl TextSelectability {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::DisabledTextSelectability => (resolve::disabled_text_selectability_ma(), resolve::disabled_text_selectability_wt(), resolve::disabled_text_selectability_init()),
            Self::EnabledTextSelectability => (resolve::enabled_text_selectability_ma(), resolve::enabled_text_selectability_wt(), resolve::enabled_text_selectability_init()),
        }
    }
}

/// The concrete types conforming to `SwiftUI.ToggleStyle`.
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum ToggleStyle {
    ButtonToggleStyle,
    CheckboxToggleStyle,
    DefaultToggleStyle,
    SwitchToggleStyle,
}

impl ToggleStyle {
    /// The style's metadata accessor, its witness table, and its `init()`.
    pub(crate) fn parts(self) -> (*const c_void, *const c_void, *const c_void) {
        match self {
            Self::ButtonToggleStyle => (resolve::button_toggle_style_ma(), resolve::button_toggle_style_wt(), resolve::button_toggle_style_init()),
            Self::CheckboxToggleStyle => (resolve::checkbox_toggle_style_ma(), resolve::checkbox_toggle_style_wt(), resolve::checkbox_toggle_style_init()),
            Self::DefaultToggleStyle => (resolve::default_toggle_style_ma(), resolve::default_toggle_style_wt(), resolve::default_toggle_style_init()),
            Self::SwitchToggleStyle => (resolve::switch_toggle_style_ma(), resolve::switch_toggle_style_wt(), resolve::switch_toggle_style_init()),
        }
    }
}

/// Apply `.backgroundStyle(_:)`.
pub fn background_shape_style(view: &ViewHandle, style: ShapeStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::background_style_fn(), resolve::background_style_oret(), view, meta, wt, init)
    }
}


/// Apply `.controlGroupStyle(_:)`.
pub fn control_group_style(view: &ViewHandle, style: ControlGroupStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::control_group_style_fn(), resolve::control_group_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.datePickerStyle(_:)`.
pub fn date_picker_style(view: &ViewHandle, style: DatePickerStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::date_picker_style_fn(), resolve::date_picker_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.disclosureGroupStyle(_:)`.
pub fn disclosure_group_style(view: &ViewHandle, style: DisclosureGroupStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::disclosure_group_style_fn(), resolve::disclosure_group_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.formStyle(_:)`.
pub fn form_style(view: &ViewHandle, style: FormStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::form_style_fn(), resolve::form_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.gaugeStyle(_:)`.
pub fn gauge_style(view: &ViewHandle, style: GaugeStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::gauge_style_fn(), resolve::gauge_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.groupBoxStyle(_:)`.
pub fn group_box_style(view: &ViewHandle, style: GroupBoxStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::group_box_style_fn(), resolve::group_box_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.labelStyle(_:)`.
pub fn label_style(view: &ViewHandle, style: LabelStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::label_style_fn(), resolve::label_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.labeledContentStyle(_:)`.
pub fn labeled_content_style(view: &ViewHandle, style: LabeledContentStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::labeled_content_style_fn(), resolve::labeled_content_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.listStyle(_:)`.
pub fn list_style(view: &ViewHandle, style: ListStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::list_style_fn(), resolve::list_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.menuButtonStyle(_:)`.
pub fn menu_button_style(view: &ViewHandle, style: MenuButtonStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::menu_button_style_fn(), resolve::menu_button_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.menuStyle(_:)`.
pub fn menu_style(view: &ViewHandle, style: MenuStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::menu_style_fn(), resolve::menu_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.pickerStyle(_:)`.
pub fn picker_style(view: &ViewHandle, style: PickerStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::picker_style_fn(), resolve::picker_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.presentedWindowStyle(_:)`.
pub fn presented_window_style(view: &ViewHandle, style: WindowStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::presented_window_style_fn(), resolve::presented_window_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.presentedWindowToolbarStyle(_:)`.
pub fn presented_window_toolbar_style(view: &ViewHandle, style: WindowToolbarStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::presented_window_toolbar_style_fn(), resolve::presented_window_toolbar_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.scrollTargetBehavior(_:)`.
pub fn scroll_target_behavior(view: &ViewHandle, style: ScrollTargetBehavior) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::scroll_target_behavior_fn(), resolve::scroll_target_behavior_oret(), view, meta, wt, init)
    }
}

/// Apply `.tableStyle(_:)`.
pub fn table_style(view: &ViewHandle, style: TableStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::table_style_fn(), resolve::table_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.textEditorStyle(_:)`.
pub fn text_editor_style(view: &ViewHandle, style: TextEditorStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::text_editor_style_fn(), resolve::text_editor_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.textFieldStyle(_:)`.
pub fn text_field_style(view: &ViewHandle, style: TextFieldStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::text_field_style_fn(), resolve::text_field_style_oret(), view, meta, wt, init)
    }
}

/// Apply `.textSelection(_:)`.
pub fn text_selection(view: &ViewHandle, style: TextSelectability) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::text_selection_fn(), resolve::text_selection_oret(), view, meta, wt, init)
    }
}

/// Apply `.toggleStyle(_:)`.
pub fn toggle_style(view: &ViewHandle, style: ToggleStyle) -> ViewHandle {
    unsafe {
        let (meta, wt, init) = style.parts();
        style_modifier(resolve::toggle_style_fn(), resolve::toggle_style_oret(), view, meta, wt, init)
    }
}