//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use objc2::__framework_prelude::*;

use crate::*;

pub type NSPointPointer = *mut NSPoint;

pub type NSPointArray = *mut NSPoint;

pub type NSSizePointer = *mut NSSize;

pub type NSSizeArray = *mut NSSize;

pub type NSRectPointer = *mut NSRect;

pub type NSRectArray = *mut NSRect;

#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct NSEdgeInsets {
    pub top: CGFloat,
    pub left: CGFloat,
    pub bottom: CGFloat,
    pub right: CGFloat,
}

unsafe impl Encode for NSEdgeInsets {
    const ENCODING: Encoding = Encoding::Struct(
        "NSEdgeInsets",
        &[
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
            <CGFloat>::ENCODING,
        ],
    );
}

unsafe impl RefEncode for NSEdgeInsets {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

unsafe impl Send for NSEdgeInsets {}

unsafe impl Sync for NSEdgeInsets {}

// NS_OPTIONS
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct NSAlignmentOptions(pub c_ulonglong);
impl NSAlignmentOptions {
    pub const NSAlignMinXInward: Self = Self(1 << 0);
    pub const NSAlignMinYInward: Self = Self(1 << 1);
    pub const NSAlignMaxXInward: Self = Self(1 << 2);
    pub const NSAlignMaxYInward: Self = Self(1 << 3);
    pub const NSAlignWidthInward: Self = Self(1 << 4);
    pub const NSAlignHeightInward: Self = Self(1 << 5);
    pub const NSAlignMinXOutward: Self = Self(1 << 8);
    pub const NSAlignMinYOutward: Self = Self(1 << 9);
    pub const NSAlignMaxXOutward: Self = Self(1 << 10);
    pub const NSAlignMaxYOutward: Self = Self(1 << 11);
    pub const NSAlignWidthOutward: Self = Self(1 << 12);
    pub const NSAlignHeightOutward: Self = Self(1 << 13);
    pub const NSAlignMinXNearest: Self = Self(1 << 16);
    pub const NSAlignMinYNearest: Self = Self(1 << 17);
    pub const NSAlignMaxXNearest: Self = Self(1 << 18);
    pub const NSAlignMaxYNearest: Self = Self(1 << 19);
    pub const NSAlignWidthNearest: Self = Self(1 << 20);
    pub const NSAlignHeightNearest: Self = Self(1 << 21);
    pub const NSAlignRectFlipped: Self = Self(1 << 63);
    pub const NSAlignAllEdgesInward: Self = Self(
        NSAlignmentOptions::NSAlignMinXInward.0
            | NSAlignmentOptions::NSAlignMaxXInward.0
            | NSAlignmentOptions::NSAlignMinYInward.0
            | NSAlignmentOptions::NSAlignMaxYInward.0,
    );
    pub const NSAlignAllEdgesOutward: Self = Self(
        NSAlignmentOptions::NSAlignMinXOutward.0
            | NSAlignmentOptions::NSAlignMaxXOutward.0
            | NSAlignmentOptions::NSAlignMinYOutward.0
            | NSAlignmentOptions::NSAlignMaxYOutward.0,
    );
    pub const NSAlignAllEdgesNearest: Self = Self(
        NSAlignmentOptions::NSAlignMinXNearest.0
            | NSAlignmentOptions::NSAlignMaxXNearest.0
            | NSAlignmentOptions::NSAlignMinYNearest.0
            | NSAlignmentOptions::NSAlignMaxYNearest.0,
    );
}

unsafe impl Encode for NSAlignmentOptions {
    const ENCODING: Encoding = c_ulonglong::ENCODING;
}

unsafe impl RefEncode for NSAlignmentOptions {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

extern "C" {
    pub static NSZeroPoint: NSPoint;
}

extern "C" {
    pub static NSZeroSize: NSSize;
}

extern "C" {
    pub static NSZeroRect: NSRect;
}

extern "C" {
    pub static NSEdgeInsetsZero: NSEdgeInsets;
}

// TODO: pub fn NSMakePoint(x: CGFloat,y: CGFloat,) -> NSPoint;

// TODO: pub fn NSMakeSize(w: CGFloat,h: CGFloat,) -> NSSize;

// TODO: pub fn NSMakeRect(x: CGFloat,y: CGFloat,w: CGFloat,h: CGFloat,) -> NSRect;

// TODO: pub fn NSMaxX(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSMaxY(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSMidX(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSMidY(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSMinX(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSMinY(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSWidth(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSHeight(a_rect: NSRect,) -> CGFloat;

// TODO: pub fn NSRectFromCGRect(cgrect: CGRect,) -> NSRect;

// TODO: pub fn NSRectToCGRect(nsrect: NSRect,) -> CGRect;

// TODO: pub fn NSPointFromCGPoint(cgpoint: CGPoint,) -> NSPoint;

// TODO: pub fn NSPointToCGPoint(nspoint: NSPoint,) -> CGPoint;

// TODO: pub fn NSSizeFromCGSize(cgsize: CGSize,) -> NSSize;

// TODO: pub fn NSSizeToCGSize(nssize: NSSize,) -> CGSize;

// TODO: pub fn NSEdgeInsetsMake(top: CGFloat,left: CGFloat,bottom: CGFloat,right: CGFloat,) -> NSEdgeInsets;

extern "C" {
    pub fn NSEqualPoints(a_point: NSPoint, b_point: NSPoint) -> Bool;
}

extern "C" {
    pub fn NSEqualSizes(a_size: NSSize, b_size: NSSize) -> Bool;
}

extern "C" {
    pub fn NSEqualRects(a_rect: NSRect, b_rect: NSRect) -> Bool;
}

extern "C" {
    pub fn NSIsEmptyRect(a_rect: NSRect) -> Bool;
}

extern "C" {
    pub fn NSEdgeInsetsEqual(a_insets: NSEdgeInsets, b_insets: NSEdgeInsets) -> Bool;
}

extern "C" {
    pub fn NSInsetRect(a_rect: NSRect, d_x: CGFloat, d_y: CGFloat) -> NSRect;
}

extern "C" {
    pub fn NSIntegralRect(a_rect: NSRect) -> NSRect;
}

extern "C" {
    pub fn NSIntegralRectWithOptions(a_rect: NSRect, opts: NSAlignmentOptions) -> NSRect;
}

extern "C" {
    pub fn NSUnionRect(a_rect: NSRect, b_rect: NSRect) -> NSRect;
}

extern "C" {
    pub fn NSIntersectionRect(a_rect: NSRect, b_rect: NSRect) -> NSRect;
}

extern "C" {
    pub fn NSOffsetRect(a_rect: NSRect, d_x: CGFloat, d_y: CGFloat) -> NSRect;
}

extern "C" {
    pub fn NSDivideRect(
        in_rect: NSRect,
        slice: NonNull<NSRect>,
        rem: NonNull<NSRect>,
        amount: CGFloat,
        edge: NSRectEdge,
    );
}

extern "C" {
    pub fn NSPointInRect(a_point: NSPoint, a_rect: NSRect) -> Bool;
}

extern "C" {
    pub fn NSMouseInRect(a_point: NSPoint, a_rect: NSRect, flipped: Bool) -> Bool;
}

extern "C" {
    pub fn NSContainsRect(a_rect: NSRect, b_rect: NSRect) -> Bool;
}

extern "C" {
    pub fn NSIntersectsRect(a_rect: NSRect, b_rect: NSRect) -> Bool;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSStringFromPoint(a_point: NSPoint) -> NonNull<NSString>;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSStringFromSize(a_size: NSSize) -> NonNull<NSString>;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSStringFromRect(a_rect: NSRect) -> NonNull<NSString>;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSPointFromString(a_string: &NSString) -> NSPoint;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSSizeFromString(a_string: &NSString) -> NSSize;
}

extern "C" {
    #[cfg(feature = "NSString")]
    pub fn NSRectFromString(a_string: &NSString) -> NSRect;
}

extern_methods!(
    /// NSValueGeometryExtensions
    #[cfg(feature = "NSValue")]
    unsafe impl NSValue {
        #[method_id(@__retain_semantics Other valueWithPoint:)]
        pub unsafe fn valueWithPoint(point: NSPoint) -> Id<NSValue>;

        #[method_id(@__retain_semantics Other valueWithSize:)]
        pub unsafe fn valueWithSize(size: NSSize) -> Id<NSValue>;

        #[method_id(@__retain_semantics Other valueWithRect:)]
        pub unsafe fn valueWithRect(rect: NSRect) -> Id<NSValue>;

        #[method_id(@__retain_semantics Other valueWithEdgeInsets:)]
        pub unsafe fn valueWithEdgeInsets(insets: NSEdgeInsets) -> Id<NSValue>;

        #[method(pointValue)]
        pub unsafe fn pointValue(&self) -> NSPoint;

        #[method(sizeValue)]
        pub unsafe fn sizeValue(&self) -> NSSize;

        #[method(rectValue)]
        pub unsafe fn rectValue(&self) -> NSRect;

        #[method(edgeInsetsValue)]
        pub unsafe fn edgeInsetsValue(&self) -> NSEdgeInsets;
    }
);

extern_methods!(
    /// NSGeometryCoding
    #[cfg(feature = "NSCoder")]
    unsafe impl NSCoder {
        #[method(encodePoint:)]
        pub unsafe fn encodePoint(&self, point: NSPoint);

        #[method(decodePoint)]
        pub unsafe fn decodePoint(&self) -> NSPoint;

        #[method(encodeSize:)]
        pub unsafe fn encodeSize(&self, size: NSSize);

        #[method(decodeSize)]
        pub unsafe fn decodeSize(&self) -> NSSize;

        #[method(encodeRect:)]
        pub unsafe fn encodeRect(&self, rect: NSRect);

        #[method(decodeRect)]
        pub unsafe fn decodeRect(&self) -> NSRect;
    }
);

extern_methods!(
    /// NSGeometryKeyedCoding
    #[cfg(feature = "NSCoder")]
    unsafe impl NSCoder {
        #[cfg(feature = "NSString")]
        #[method(encodePoint:forKey:)]
        pub unsafe fn encodePoint_forKey(&self, point: NSPoint, key: &NSString);

        #[cfg(feature = "NSString")]
        #[method(encodeSize:forKey:)]
        pub unsafe fn encodeSize_forKey(&self, size: NSSize, key: &NSString);

        #[cfg(feature = "NSString")]
        #[method(encodeRect:forKey:)]
        pub unsafe fn encodeRect_forKey(&self, rect: NSRect, key: &NSString);

        #[cfg(feature = "NSString")]
        #[method(decodePointForKey:)]
        pub unsafe fn decodePointForKey(&self, key: &NSString) -> NSPoint;

        #[cfg(feature = "NSString")]
        #[method(decodeSizeForKey:)]
        pub unsafe fn decodeSizeForKey(&self, key: &NSString) -> NSSize;

        #[cfg(feature = "NSString")]
        #[method(decodeRectForKey:)]
        pub unsafe fn decodeRectForKey(&self, key: &NSString) -> NSRect;
    }
);