use core::cell::UnsafeCell;
use core::ffi::*;
use core::marker::{PhantomData, PhantomPinned};
use objc2::__framework_prelude::*;
use crate::*;
pub const kCGLMonoscopicBit: c_uint = 0x00000001;
pub const kCGLStereoscopicBit: c_uint = 0x00000002;
pub const kCGLSingleBufferBit: c_uint = 0x00000004;
pub const kCGLDoubleBufferBit: c_uint = 0x00000008;
pub const kCGLTripleBufferBit: c_uint = 0x00000010;
pub const kCGL0Bit: c_uint = 0x00000001;
pub const kCGL1Bit: c_uint = 0x00000002;
pub const kCGL2Bit: c_uint = 0x00000004;
pub const kCGL3Bit: c_uint = 0x00000008;
pub const kCGL4Bit: c_uint = 0x00000010;
pub const kCGL5Bit: c_uint = 0x00000020;
pub const kCGL6Bit: c_uint = 0x00000040;
pub const kCGL8Bit: c_uint = 0x00000080;
pub const kCGL10Bit: c_uint = 0x00000100;
pub const kCGL12Bit: c_uint = 0x00000200;
pub const kCGL16Bit: c_uint = 0x00000400;
pub const kCGL24Bit: c_uint = 0x00000800;
pub const kCGL32Bit: c_uint = 0x00001000;
pub const kCGL48Bit: c_uint = 0x00002000;
pub const kCGL64Bit: c_uint = 0x00004000;
pub const kCGL96Bit: c_uint = 0x00008000;
pub const kCGL128Bit: c_uint = 0x00010000;
pub const kCGLRGB444Bit: c_uint = 0x00000040;
pub const kCGLARGB4444Bit: c_uint = 0x00000080;
pub const kCGLRGB444A8Bit: c_uint = 0x00000100;
pub const kCGLRGB555Bit: c_uint = 0x00000200;
pub const kCGLARGB1555Bit: c_uint = 0x00000400;
pub const kCGLRGB555A8Bit: c_uint = 0x00000800;
pub const kCGLRGB565Bit: c_uint = 0x00001000;
pub const kCGLRGB565A8Bit: c_uint = 0x00002000;
pub const kCGLRGB888Bit: c_uint = 0x00004000;
pub const kCGLARGB8888Bit: c_uint = 0x00008000;
pub const kCGLRGB888A8Bit: c_uint = 0x00010000;
pub const kCGLRGB101010Bit: c_uint = 0x00020000;
pub const kCGLARGB2101010Bit: c_uint = 0x00040000;
pub const kCGLRGB101010_A8Bit: c_uint = 0x00080000;
pub const kCGLRGB121212Bit: c_uint = 0x00100000;
pub const kCGLARGB12121212Bit: c_uint = 0x00200000;
pub const kCGLRGB161616Bit: c_uint = 0x00400000;
pub const kCGLRGBA16161616Bit: c_uint = 0x00800000;
pub const kCGLRGBFloat64Bit: c_uint = 0x01000000;
pub const kCGLRGBAFloat64Bit: c_uint = 0x02000000;
pub const kCGLRGBFloat128Bit: c_uint = 0x04000000;
pub const kCGLRGBAFloat128Bit: c_uint = 0x08000000;
pub const kCGLRGBFloat256Bit: c_uint = 0x10000000;
pub const kCGLRGBAFloat256Bit: c_uint = 0x20000000;
pub const kCGLSupersampleBit: c_uint = 0x00000001;
pub const kCGLMultisampleBit: c_uint = 0x00000002;
pub const kCGLARGB16161616Bit: c_uint = kCGLRGBA16161616Bit;
pub type CGLContextObj = *mut _CGLContextObject;
#[repr(C)]
#[derive(Debug)]
pub struct _CGLPixelFormatObject {
inner: [u8; 0],
_p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
}
unsafe impl RefEncode for _CGLPixelFormatObject {
const ENCODING_REF: Encoding =
Encoding::Pointer(&Encoding::Struct("_CGLPixelFormatObject", &[]));
}
pub type CGLPixelFormatObj = *mut _CGLPixelFormatObject;
#[repr(C)]
#[derive(Debug)]
pub struct _CGLRendererInfoObject {
inner: [u8; 0],
_p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
}
unsafe impl RefEncode for _CGLRendererInfoObject {
const ENCODING_REF: Encoding =
Encoding::Pointer(&Encoding::Struct("_CGLRendererInfoObject", &[]));
}
pub type CGLRendererInfoObj = *mut _CGLRendererInfoObject;
#[repr(C)]
#[derive(Debug)]
pub struct _CGLPBufferObject {
inner: [u8; 0],
_p: UnsafeCell<PhantomData<(*const UnsafeCell<()>, PhantomPinned)>>,
}
unsafe impl RefEncode for _CGLPBufferObject {
const ENCODING_REF: Encoding = Encoding::Pointer(&Encoding::Struct("_CGLPBufferObject", &[]));
}
pub type CGLPBufferObj = *mut _CGLPBufferObject;
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLPixelFormatAttribute(pub c_uint);
impl CGLPixelFormatAttribute {
#[doc(alias = "kCGLPFAAllRenderers")]
pub const CGLPFAAllRenderers: Self = Self(1);
#[doc(alias = "kCGLPFATripleBuffer")]
pub const CGLPFATripleBuffer: Self = Self(3);
#[doc(alias = "kCGLPFADoubleBuffer")]
pub const CGLPFADoubleBuffer: Self = Self(5);
#[doc(alias = "kCGLPFAColorSize")]
pub const CGLPFAColorSize: Self = Self(8);
#[doc(alias = "kCGLPFAAlphaSize")]
pub const CGLPFAAlphaSize: Self = Self(11);
#[doc(alias = "kCGLPFADepthSize")]
pub const CGLPFADepthSize: Self = Self(12);
#[doc(alias = "kCGLPFAStencilSize")]
pub const CGLPFAStencilSize: Self = Self(13);
#[doc(alias = "kCGLPFAMinimumPolicy")]
pub const CGLPFAMinimumPolicy: Self = Self(51);
#[doc(alias = "kCGLPFAMaximumPolicy")]
pub const CGLPFAMaximumPolicy: Self = Self(52);
#[doc(alias = "kCGLPFASampleBuffers")]
pub const CGLPFASampleBuffers: Self = Self(55);
#[doc(alias = "kCGLPFASamples")]
pub const CGLPFASamples: Self = Self(56);
#[doc(alias = "kCGLPFAColorFloat")]
pub const CGLPFAColorFloat: Self = Self(58);
#[doc(alias = "kCGLPFAMultisample")]
pub const CGLPFAMultisample: Self = Self(59);
#[doc(alias = "kCGLPFASupersample")]
pub const CGLPFASupersample: Self = Self(60);
#[doc(alias = "kCGLPFASampleAlpha")]
pub const CGLPFASampleAlpha: Self = Self(61);
#[doc(alias = "kCGLPFARendererID")]
pub const CGLPFARendererID: Self = Self(70);
#[doc(alias = "kCGLPFANoRecovery")]
pub const CGLPFANoRecovery: Self = Self(72);
#[doc(alias = "kCGLPFAAccelerated")]
pub const CGLPFAAccelerated: Self = Self(73);
#[doc(alias = "kCGLPFAClosestPolicy")]
pub const CGLPFAClosestPolicy: Self = Self(74);
#[doc(alias = "kCGLPFABackingStore")]
pub const CGLPFABackingStore: Self = Self(76);
#[doc(alias = "kCGLPFABackingVolatile")]
pub const CGLPFABackingVolatile: Self = Self(77);
#[doc(alias = "kCGLPFADisplayMask")]
pub const CGLPFADisplayMask: Self = Self(84);
#[doc(alias = "kCGLPFAAllowOfflineRenderers")]
pub const CGLPFAAllowOfflineRenderers: Self = Self(96);
#[doc(alias = "kCGLPFAAcceleratedCompute")]
pub const CGLPFAAcceleratedCompute: Self = Self(97);
#[doc(alias = "kCGLPFAOpenGLProfile")]
pub const CGLPFAOpenGLProfile: Self = Self(99);
#[doc(alias = "kCGLPFASupportsAutomaticGraphicsSwitching")]
pub const CGLPFASupportsAutomaticGraphicsSwitching: Self = Self(101);
#[doc(alias = "kCGLPFAVirtualScreenCount")]
pub const CGLPFAVirtualScreenCount: Self = Self(128);
#[doc(alias = "kCGLPFAAuxBuffers")]
pub const CGLPFAAuxBuffers: Self = Self(7);
#[doc(alias = "kCGLPFAAccumSize")]
pub const CGLPFAAccumSize: Self = Self(14);
#[doc(alias = "kCGLPFAAuxDepthStencil")]
pub const CGLPFAAuxDepthStencil: Self = Self(57);
#[doc(alias = "kCGLPFAStereo")]
pub const CGLPFAStereo: Self = Self(6);
#[doc(alias = "kCGLPFAOffScreen")]
pub const CGLPFAOffScreen: Self = Self(53);
#[doc(alias = "kCGLPFAWindow")]
pub const CGLPFAWindow: Self = Self(80);
#[doc(alias = "kCGLPFACompliant")]
pub const CGLPFACompliant: Self = Self(83);
#[doc(alias = "kCGLPFAPBuffer")]
pub const CGLPFAPBuffer: Self = Self(90);
#[doc(alias = "kCGLPFARemotePBuffer")]
pub const CGLPFARemotePBuffer: Self = Self(91);
#[doc(alias = "kCGLPFASingleRenderer")]
pub const CGLPFASingleRenderer: Self = Self(71);
#[doc(alias = "kCGLPFARobust")]
pub const CGLPFARobust: Self = Self(75);
#[doc(alias = "kCGLPFAMPSafe")]
pub const CGLPFAMPSafe: Self = Self(78);
#[doc(alias = "kCGLPFAMultiScreen")]
pub const CGLPFAMultiScreen: Self = Self(81);
#[doc(alias = "kCGLPFAFullScreen")]
pub const CGLPFAFullScreen: Self = Self(54);
}
unsafe impl Encode for CGLPixelFormatAttribute {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLPixelFormatAttribute {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLRendererProperty(pub c_uint);
impl CGLRendererProperty {
#[doc(alias = "kCGLRPOffScreen")]
pub const CGLRPOffScreen: Self = Self(53);
#[doc(alias = "kCGLRPRendererID")]
pub const CGLRPRendererID: Self = Self(70);
#[doc(alias = "kCGLRPAccelerated")]
pub const CGLRPAccelerated: Self = Self(73);
#[doc(alias = "kCGLRPBackingStore")]
pub const CGLRPBackingStore: Self = Self(76);
#[doc(alias = "kCGLRPWindow")]
pub const CGLRPWindow: Self = Self(80);
#[doc(alias = "kCGLRPCompliant")]
pub const CGLRPCompliant: Self = Self(83);
#[doc(alias = "kCGLRPDisplayMask")]
pub const CGLRPDisplayMask: Self = Self(84);
#[doc(alias = "kCGLRPBufferModes")]
pub const CGLRPBufferModes: Self = Self(100);
#[doc(alias = "kCGLRPColorModes")]
pub const CGLRPColorModes: Self = Self(103);
#[doc(alias = "kCGLRPAccumModes")]
pub const CGLRPAccumModes: Self = Self(104);
#[doc(alias = "kCGLRPDepthModes")]
pub const CGLRPDepthModes: Self = Self(105);
#[doc(alias = "kCGLRPStencilModes")]
pub const CGLRPStencilModes: Self = Self(106);
#[doc(alias = "kCGLRPMaxAuxBuffers")]
pub const CGLRPMaxAuxBuffers: Self = Self(107);
#[doc(alias = "kCGLRPMaxSampleBuffers")]
pub const CGLRPMaxSampleBuffers: Self = Self(108);
#[doc(alias = "kCGLRPMaxSamples")]
pub const CGLRPMaxSamples: Self = Self(109);
#[doc(alias = "kCGLRPSampleModes")]
pub const CGLRPSampleModes: Self = Self(110);
#[doc(alias = "kCGLRPSampleAlpha")]
pub const CGLRPSampleAlpha: Self = Self(111);
#[doc(alias = "kCGLRPGPUVertProcCapable")]
pub const CGLRPGPUVertProcCapable: Self = Self(122);
#[doc(alias = "kCGLRPGPUFragProcCapable")]
pub const CGLRPGPUFragProcCapable: Self = Self(123);
#[doc(alias = "kCGLRPRendererCount")]
pub const CGLRPRendererCount: Self = Self(128);
#[doc(alias = "kCGLRPOnline")]
pub const CGLRPOnline: Self = Self(129);
#[doc(alias = "kCGLRPAcceleratedCompute")]
pub const CGLRPAcceleratedCompute: Self = Self(130);
#[doc(alias = "kCGLRPVideoMemoryMegabytes")]
pub const CGLRPVideoMemoryMegabytes: Self = Self(131);
#[doc(alias = "kCGLRPTextureMemoryMegabytes")]
pub const CGLRPTextureMemoryMegabytes: Self = Self(132);
#[doc(alias = "kCGLRPMajorGLVersion")]
pub const CGLRPMajorGLVersion: Self = Self(133);
#[doc(alias = "kCGLRPRegistryIDLow")]
pub const CGLRPRegistryIDLow: Self = Self(140);
#[doc(alias = "kCGLRPRegistryIDHigh")]
pub const CGLRPRegistryIDHigh: Self = Self(141);
#[doc(alias = "kCGLRPRemovable")]
pub const CGLRPRemovable: Self = Self(142);
#[doc(alias = "kCGLRPRobust")]
pub const CGLRPRobust: Self = Self(75);
#[doc(alias = "kCGLRPMPSafe")]
pub const CGLRPMPSafe: Self = Self(78);
#[doc(alias = "kCGLRPMultiScreen")]
pub const CGLRPMultiScreen: Self = Self(81);
#[doc(alias = "kCGLRPFullScreen")]
pub const CGLRPFullScreen: Self = Self(54);
#[doc(alias = "kCGLRPVideoMemory")]
pub const CGLRPVideoMemory: Self = Self(120);
#[doc(alias = "kCGLRPTextureMemory")]
pub const CGLRPTextureMemory: Self = Self(121);
}
unsafe impl Encode for CGLRendererProperty {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLRendererProperty {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLContextEnable(pub c_uint);
impl CGLContextEnable {
#[doc(alias = "kCGLCESwapRectangle")]
pub const CGLCESwapRectangle: Self = Self(201);
#[doc(alias = "kCGLCESwapLimit")]
pub const CGLCESwapLimit: Self = Self(203);
#[doc(alias = "kCGLCERasterization")]
pub const CGLCERasterization: Self = Self(221);
#[doc(alias = "kCGLCEStateValidation")]
pub const CGLCEStateValidation: Self = Self(301);
#[doc(alias = "kCGLCESurfaceBackingSize")]
pub const CGLCESurfaceBackingSize: Self = Self(305);
#[doc(alias = "kCGLCEDisplayListOptimization")]
pub const CGLCEDisplayListOptimization: Self = Self(307);
#[doc(alias = "kCGLCEMPEngine")]
pub const CGLCEMPEngine: Self = Self(313);
#[doc(alias = "kCGLCECrashOnRemovedFunctions")]
pub const CGLCECrashOnRemovedFunctions: Self = Self(316);
}
unsafe impl Encode for CGLContextEnable {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLContextEnable {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLGPURestartStatus(pub c_uint);
impl CGLGPURestartStatus {
#[doc(alias = "kCGLCPGPURestartStatusNone")]
pub const CGLCPGPURestartStatusNone: Self = Self(0);
#[doc(alias = "kCGLCPGPURestartStatusCaused")]
pub const CGLCPGPURestartStatusCaused: Self = Self(1);
#[doc(alias = "kCGLCPGPURestartStatusBlacklisted")]
pub const CGLCPGPURestartStatusBlacklisted: Self = Self(2);
#[doc(alias = "kCGLCPGPURestartStatusDenied")]
pub const CGLCPGPURestartStatusDenied: Self = Self(2);
}
unsafe impl Encode for CGLGPURestartStatus {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLGPURestartStatus {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLContextParameter(pub c_uint);
impl CGLContextParameter {
#[doc(alias = "kCGLCPSwapRectangle")]
pub const CGLCPSwapRectangle: Self = Self(200);
#[doc(alias = "kCGLCPSwapInterval")]
pub const CGLCPSwapInterval: Self = Self(222);
#[doc(alias = "kCGLCPDispatchTableSize")]
pub const CGLCPDispatchTableSize: Self = Self(224);
#[doc(alias = "kCGLCPClientStorage")]
pub const CGLCPClientStorage: Self = Self(226);
#[doc(alias = "kCGLCPSurfaceTexture")]
pub const CGLCPSurfaceTexture: Self = Self(228);
#[doc(alias = "kCGLCPSurfaceOrder")]
pub const CGLCPSurfaceOrder: Self = Self(235);
#[doc(alias = "kCGLCPSurfaceOpacity")]
pub const CGLCPSurfaceOpacity: Self = Self(236);
#[doc(alias = "kCGLCPSurfaceBackingSize")]
pub const CGLCPSurfaceBackingSize: Self = Self(304);
#[doc(alias = "kCGLCPSurfaceSurfaceVolatile")]
pub const CGLCPSurfaceSurfaceVolatile: Self = Self(306);
#[doc(alias = "kCGLCPReclaimResources")]
pub const CGLCPReclaimResources: Self = Self(308);
#[doc(alias = "kCGLCPCurrentRendererID")]
pub const CGLCPCurrentRendererID: Self = Self(309);
#[doc(alias = "kCGLCPGPUVertexProcessing")]
pub const CGLCPGPUVertexProcessing: Self = Self(310);
#[doc(alias = "kCGLCPGPUFragmentProcessing")]
pub const CGLCPGPUFragmentProcessing: Self = Self(311);
#[doc(alias = "kCGLCPHasDrawable")]
pub const CGLCPHasDrawable: Self = Self(314);
#[doc(alias = "kCGLCPMPSwapsInFlight")]
pub const CGLCPMPSwapsInFlight: Self = Self(315);
#[doc(alias = "kCGLCPGPURestartStatus")]
pub const CGLCPGPURestartStatus: Self = Self(317);
#[doc(alias = "kCGLCPAbortOnGPURestartStatusBlacklisted")]
pub const CGLCPAbortOnGPURestartStatusBlacklisted: Self = Self(318);
#[doc(alias = "kCGLCPAbortOnGPURestartStatusDenied")]
pub const CGLCPAbortOnGPURestartStatusDenied: Self = Self(318);
#[doc(alias = "kCGLCPSupportGPURestart")]
pub const CGLCPSupportGPURestart: Self = Self(319);
#[doc(alias = "kCGLCPSupportSeparateAddressSpace")]
pub const CGLCPSupportSeparateAddressSpace: Self = Self(320);
#[doc(alias = "kCGLCPContextPriorityRequest")]
pub const CGLCPContextPriorityRequest: Self = Self(608);
}
unsafe impl Encode for CGLContextParameter {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLContextParameter {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLCPContextPriorityRequest(pub c_uint);
impl CGLCPContextPriorityRequest {
#[doc(alias = "kCGLCPContextPriorityRequestHigh")]
pub const High: Self = Self(0);
#[doc(alias = "kCGLCPContextPriorityRequestNormal")]
pub const Normal: Self = Self(1);
#[doc(alias = "kCGLCPContextPriorityRequestLow")]
pub const Low: Self = Self(2);
}
unsafe impl Encode for CGLCPContextPriorityRequest {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLCPContextPriorityRequest {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLGlobalOption(pub c_uint);
impl CGLGlobalOption {
#[doc(alias = "kCGLGOFormatCacheSize")]
pub const CGLGOFormatCacheSize: Self = Self(501);
#[doc(alias = "kCGLGOClearFormatCache")]
pub const CGLGOClearFormatCache: Self = Self(502);
#[doc(alias = "kCGLGORetainRenderers")]
pub const CGLGORetainRenderers: Self = Self(503);
#[doc(alias = "kCGLGOUseBuildCache")]
pub const CGLGOUseBuildCache: Self = Self(506);
#[doc(alias = "kCGLGOResetLibrary")]
pub const CGLGOResetLibrary: Self = Self(504);
#[doc(alias = "kCGLGOUseErrorHandler")]
pub const CGLGOUseErrorHandler: Self = Self(505);
}
unsafe impl Encode for CGLGlobalOption {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLGlobalOption {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLOpenGLProfile(pub c_uint);
impl CGLOpenGLProfile {
#[doc(alias = "kCGLOGLPVersion_Legacy")]
pub const CGLOGLPVersion_Legacy: Self = Self(0x1000);
#[doc(alias = "kCGLOGLPVersion_3_2_Core")]
pub const CGLOGLPVersion_3_2_Core: Self = Self(0x3200);
#[doc(alias = "kCGLOGLPVersion_GL3_Core")]
pub const CGLOGLPVersion_GL3_Core: Self = Self(0x3200);
#[doc(alias = "kCGLOGLPVersion_GL4_Core")]
pub const CGLOGLPVersion_GL4_Core: Self = Self(0x4100);
}
unsafe impl Encode for CGLOpenGLProfile {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLOpenGLProfile {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}
#[repr(transparent)]
#[derive(Clone, Copy, Debug, PartialEq, Eq, Hash, PartialOrd, Ord)]
pub struct CGLError(pub c_uint);
impl CGLError {
#[doc(alias = "kCGLNoError")]
pub const NoError: Self = Self(0);
#[doc(alias = "kCGLBadAttribute")]
pub const BadAttribute: Self = Self(10000);
#[doc(alias = "kCGLBadProperty")]
pub const BadProperty: Self = Self(10001);
#[doc(alias = "kCGLBadPixelFormat")]
pub const BadPixelFormat: Self = Self(10002);
#[doc(alias = "kCGLBadRendererInfo")]
pub const BadRendererInfo: Self = Self(10003);
#[doc(alias = "kCGLBadContext")]
pub const BadContext: Self = Self(10004);
#[doc(alias = "kCGLBadDrawable")]
pub const BadDrawable: Self = Self(10005);
#[doc(alias = "kCGLBadDisplay")]
pub const BadDisplay: Self = Self(10006);
#[doc(alias = "kCGLBadState")]
pub const BadState: Self = Self(10007);
#[doc(alias = "kCGLBadValue")]
pub const BadValue: Self = Self(10008);
#[doc(alias = "kCGLBadMatch")]
pub const BadMatch: Self = Self(10009);
#[doc(alias = "kCGLBadEnumeration")]
pub const BadEnumeration: Self = Self(10010);
#[doc(alias = "kCGLBadOffScreen")]
pub const BadOffScreen: Self = Self(10011);
#[doc(alias = "kCGLBadFullScreen")]
pub const BadFullScreen: Self = Self(10012);
#[doc(alias = "kCGLBadWindow")]
pub const BadWindow: Self = Self(10013);
#[doc(alias = "kCGLBadAddress")]
pub const BadAddress: Self = Self(10014);
#[doc(alias = "kCGLBadCodeModule")]
pub const BadCodeModule: Self = Self(10015);
#[doc(alias = "kCGLBadAlloc")]
pub const BadAlloc: Self = Self(10016);
#[doc(alias = "kCGLBadConnection")]
pub const BadConnection: Self = Self(10017);
}
unsafe impl Encode for CGLError {
const ENCODING: Encoding = c_uint::ENCODING;
}
unsafe impl RefEncode for CGLError {
const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}