package core:sys/darwin/Foundation

Warning: This was generated for -target:darwin_arm64 and might not represent every target this package supports.

⌘K
Ctrl+K
or
/

    External Examples 12 ¶

    The programs in odin-lang/examples about this package, and how many of its declarations each uses.

    Index

    Types (138)
    Constants (66)
    Procedures (807)

    Types

    ActivationPolicy ¶

    ActivationPolicy :: enum UInteger {
    	Regular    = 0, 
    	Accessory  = 1, 
    	Prohibited = 2, 
    }

    ActivityOptionsBits ¶

    ActivityOptionsBits :: enum u64 {
    	IdleDisplaySleepDisabled             = log2(1099511627776),  // Require the screen to stay powered on.
    	IdleSystemSleepDisabled              = log2(1048576),        // Prevent idle sleep.
    	SuddenTerminationDisabled            = log2(16384),          // Prevent sudden termination.
    	AutomaticTerminationDisabled         = log2(32768),          // Prevent automatic termination.
    	AnimationTrackingEnabled             = log2(35184372088832), // Track activity with an animation signpost interval.
    	TrackingEnabled                      = log2(70368744177664), // Track activity with a signpost interval.
    	UserInitiated                        = log2(16777215),       // Performing a user-requested action.
    	UserInitiatedAllowingIdleSystemSleep = log2(15728639),       // Performing a user-requested action, but the system can sleep on idle.
    	Background                           = log2(255),            // Initiated some kind of work, but not as the direct result of a user request.
    	LatencyCritical                      = log2(1095216660480),  // Requires the highest amount of timer and I/O precision available.
    	UserInteractive                      = log2(1095233437695),  // Responding to user interaction.
    }

    Application ¶

    Application :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object

    ApplicationDelegate ¶

    ApplicationDelegate :: struct {
    	using _: Object,
    }
    Procedures Through `using` From Object
    Procedures Through `using` From objc_object

    ApplicationDelegateTemplate ¶

    ApplicationDelegateTemplate :: struct {
    	// Launching Applications
    	applicationWillFinishLaunching:                              proc(notification: ^Notification),
    	applicationDidFinishLaunching:                               proc(notification: ^Notification),
    	// Managing Active Status
    	applicationWillBecomeActive:                                 proc(notification: ^Notification),
    	applicationDidBecomeActive:                                  proc(notification: ^Notification),
    	applicationWillResignActive:                                 proc(notification: ^Notification),
    	applicationDidResignActive:                                  proc(notification: ^Notification),
    	// Terminating Applications
    	applicationShouldTerminate:                                  proc(sender: ^Application) -> ApplicationTerminateReply,
    	applicationShouldTerminateAfterLastWindowClosed:             proc(sender: ^Application) -> bool,
    	applicationWillTerminate:                                    proc(notification: ^Notification),
    	// Hiding Applications
    	applicationWillHide:                                         proc(notification: ^Notification),
    	applicationDidHide:                                          proc(notification: ^Notification),
    	applicationWillUnhide:                                       proc(notification: ^Notification),
    	applicationDidUnhide:                                        proc(notification: ^Notification),
    	// Managing Windows
    	applicationWillUpdate:                                       proc(notification: ^Notification),
    	applicationDidUpdate:                                        proc(notification: ^Notification),
    	applicationShouldHandleReopenHasVisibleWindows:              proc(sender: ^Application, flag: bool) -> bool,
    	// Managing the Dock Menu
    	applicationDockMenu:                                         proc(sender: ^Application) -> ^Menu,
    	// Localizing Keyboard Shortcuts
    	applicationShouldAutomaticallyLocalizeKeyEquivalents:        proc(application: ^Application) -> bool,
    	// Displaying Errors
    	applicationWillPresentError:                                 proc(application: ^Application, error: ^Error) -> ^Error,
    	// Managing the Screen
    	applicationDidChangeScreenParameters:                        proc(notification: ^Notification),
    	// Continuing User Activities
    	applicationWillContinueUserActivityWithType:                 proc(application: ^Application, userActivityType: ^String) -> bool,
    	applicationContinueUserActivityRestorationHandler:           proc(application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> bool,
    	applicationDidFailToContinueUserActivityWithTypeError:       proc(application: ^Application, userActivityType: ^String, error: ^Error),
    	applicationDidUpdateUserActivity:                            proc(application: ^Application, userActivity: ^UserActivity),
    	// Handling Push Notifications
    	applicationDidRegisterForRemoteNotificationsWithDeviceToken: proc(application: ^Application, deviceToken: ^Data),
    	applicationDidFailToRegisterForRemoteNotificationsWithError: proc(application: ^Application, error: ^Error),
    	applicationDidReceiveRemoteNotification:                     proc(application: ^Application, userInfo: ^Dictionary),
    	// Handling CloudKit Invitations
    	// TODO: if/when we have cloud kit bindings implement
    	// applicationUserDidAcceptCloudKitShareWithMetadata:        proc(application: ^Application, metadata: ^CKShareMetadata),
    	// Handling SiriKit Intents
    	// TODO: if/when we have siri kit bindings implement
    	// applicationHandlerForIntent:                              proc(application: ^Application, intent: ^INIntent) -> id,
    	// Opening Files
    	applicationOpenURLs:                                         proc(application: ^Application, urls: ^Array),
    	applicationOpenFile:                                         proc(sender: ^Application, filename: ^String) -> bool,
    	applicationOpenFileWithoutUI:                                proc(sender: ^intrinsics.objc_object, filename: ^String) -> bool,
    	applicationOpenTempFile:                                     proc(sender: ^Application, filename: ^String) -> bool,
    	applicationOpenFiles:                                        proc(sender: ^Application, filenames: ^Array),
    	applicationShouldOpenUntitledFile:                           proc(sender: ^Application) -> bool,
    	applicationOpenUntitledFile:                                 proc(sender: ^Application) -> bool,
    	// Printing
    	applicationPrintFile:                                        proc(sender: ^Application, filename: ^String) -> bool,
    	applicationPrintFilesWithSettingsShowPrintPanels:            proc(application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: bool) -> ApplicationPrintReply,
    	// Restoring Application State
    	applicationSupportsSecureRestorableState:                    proc(app: ^Application) -> bool,
    	applicationProtectedDataDidBecomeAvailable:                  proc(notification: ^Notification),
    	applicationProtectedDataWillBecomeUnavailable:               proc(notification: ^Notification),
    	applicationWillEncodeRestorableState:                        proc(app: ^Application, coder: ^Coder),
    	applicationDidDecodeRestorableState:                         proc(app: ^Application, coder: ^Coder),
    	// Handling Changes to the Occlusion State
    	applicationDidChangeOcclusionState:                          proc(notification: ^Notification),
    	// Scripting Your App
    	applicationDelegateHandlesKey:                               proc(sender: ^Application, key: ^String) -> bool,
    }

    ApplicationPresentationOptionFlag ¶

    ApplicationPresentationOptionFlag :: enum UInteger {
    	AutoHideDock                    = 0, 
    	HideDock                        = 1, 
    	AutoHideMenuBar                 = 2, 
    	HideMenuBar                     = 3, 
    	DisableAppleMenu                = 4, 
    	DisableProcessSwitching         = 5, 
    	DisableForceQuit                = 6, 
    	DisableSessionTermination       = 7, 
    	DisableHideApplication          = 8, 
    	DisableMenuBarTransparency      = 9, 
    	FullScreen                      = 10, 
    	AutoHideToolbar                 = 11, 
    	DisableCursorLocationAssistance = 12, 
    }

    ApplicationPrintReply ¶

    ApplicationPrintReply :: enum UInteger {
    	PrintingCancelled  = 0, 
    	PrintingSuccess    = 1, 
    	PrintingReplyLater = 2, 
    	PrintingFailure    = 3, 
    }

    ApplicationTerminateReply ¶

    ApplicationTerminateReply :: enum UInteger {
    	TerminateCancel = 0, 
    	TerminateNow    = 1, 
    	TerminateLater  = 2, 
    }

    Array ¶

    Array :: struct {
    	using _: Copying($T=Array),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    AutoreleasePool ¶

    AutoreleasePool :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    BOOL ¶

    BOOL :: bool
     

    TODO(bill): should this be distinct?

    Related Procedures With Parameters

    Related Procedures With Returns

    BackingStoreType ¶

    BackingStoreType :: enum UInteger {
    	Retained    = 0, 
    	Nonretained = 1, 
    	Buffered    = 2, 
    }

    BitmapFormatFlag ¶

    BitmapFormatFlag :: enum BitmapInteger {
    	AlphaFirst               = 0, 
    	AlphaNonpremultiplied    = 1, 
    	FloatingPointSamples     = 2, 
    	SixteenBitLittleEndian   = 8, 
    	ThirtyTwoBitLittleEndian = 9, 
    	SixteenBitBigEndian      = 10, 
    	ThirtyTwoBitBigEndian    = 11, 
    }

    BitmapImageRep ¶

    BitmapImageRep :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Block ¶

    Block :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Bundle ¶

    Bundle :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Class_VTable_Info ¶

    Class_VTable_Info :: struct {
    	_context:        runtime.Context,
    	super_vtable:    rawptr,
    	protocol_vtable: rawptr,
    }

    Related Procedures With Returns

    Coder ¶

    Coder :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    Color ¶

    Color :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    ColorSpace ¶

    ColorSpace :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    ComparisonResult ¶

    ComparisonResult :: enum Integer {
    	OrderedAscending  = -1, 
    	OrderedSame       = 0, 
    	OrderedDescending = 1, 
    }

    Condition ¶

    Condition :: struct {
    	using _: Locking($T=Condition),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Copying ¶

    Copying :: struct($T: typeid) {
    	… // See source for fields
    }

    Cursor ¶

    Cursor :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Data ¶

    Data :: struct {
    	using _: Copying($T=Data),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Date ¶

    Date :: struct {
    	using _: Copying($T=Date),
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object

    Depth ¶

    Depth :: enum UInteger {
    	onehundredtwentyeightBitRGB = 544, 
    	sixtyfourBitRGB             = 528, 
    	twentyfourBitRGB            = 520, 
    }

    Dictionary ¶

    Dictionary :: struct {
    	using _: Copying($T=Dictionary),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Enumerator ¶

    Enumerator :: struct($T: typeid) {
    	… // See source for fields
    }

    Error ¶

    Error :: struct {
    	using _: Copying($T=Error),
    }
    External examples metal/learn_metal/00-window · metal/learn_metal/01-primitive · metal/learn_metal/02-argbuffers +8

    Bound Objective-C Methods

    Methods Inherited From Object

    ErrorDomain ¶

    ErrorDomain :: ^String

    Related Procedures With Parameters

    Related Procedures With Returns

    ErrorUserInfoKey ¶

    ErrorUserInfoKey :: ^String

    Related Procedures With Parameters

    Related Procedures With Returns

    Event ¶

    Event :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object

    EventMask ¶

    EventMask :: distinct bit_set[EventType; UInteger]

    Related Constants

    EventModifierFlag ¶

    EventModifierFlag :: enum UInteger {
    	CapsLock   = 16, 
    	Shift      = 17, 
    	Control    = 18, 
    	Option     = 19, 
    	Command    = 20, 
    	NumericPad = 21, 
    	Help       = 22, 
    	Function   = 23, 
    }

    EventPhaseFlag ¶

    EventPhaseFlag :: enum UInteger {
    	Began      = 0, 
    	Stationary = 1, 
    	Changed    = 2, 
    	Ended      = 3, 
    	Cancelled  = 4, 
    	MayBegin   = 5, 
    }

    EventType ¶

    EventType :: enum UInteger {
    	LeftMouseDown      = 1, 
    	LeftMouseUp        = 2, 
    	RightMouseDown     = 3, 
    	RightMouseUp       = 4, 
    	MouseMoved         = 5, 
    	LeftMouseDragged   = 6, 
    	RightMouseDragged  = 7, 
    	MouseEntered       = 8, 
    	MouseExited        = 9, 
    	KeyDown            = 10, 
    	KeyUp              = 11, 
    	FlagsChanged       = 12, 
    	AppKitDefined      = 13, 
    	SystemDefined      = 14, 
    	ApplicationDefined = 15, 
    	Periodic           = 16, 
    	CursorUpdate       = 17, 
    	Rotate             = 18, 
    	BeginGesture       = 19, 
    	EndGesture         = 20, 
    	ScrollWheel        = 22, 
    	TabletPoint        = 23, 
    	TabletProximity    = 24, 
    	OtherMouseDown     = 25, 
    	OtherMouseUp       = 26, 
    	OtherMouseDragged  = 27, 
    	Gesture            = 29, 
    	Magnify            = 30, 
    	Swipe              = 31, 
    	SmartMagnify       = 32, 
    	QuickLook          = 33, 
    	Pressure           = 34, 
    	DirectTouch        = 37, 
    	ChangeMode         = 38, 
    }

    FastEnumeration ¶

    FastEnumeration :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    FastEnumerationState ¶

    FastEnumerationState :: struct #packed {
    	state:        u32,
    	itemsPtr:     [^]^Object,
    	mutationsPtr: [^]u32,
    	extra:        [5]u32,
    }

    IMP ¶

    IMP :: proc "c" (object: ^intrinsics.objc_object, sel: ^intrinsics.objc_selector, args: ..any) -> ^intrinsics.objc_object
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Related Procedures With Parameters

    Related Procedures With Returns

    Image ¶

    Image :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    ImageRep ¶

    ImageRep :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    Layer ¶

    Layer :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Locking ¶

    Locking :: struct($T: typeid) {
    	… // See source for fields
    }

    Related Procedures With Parameters

    Menu :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object
    MenuDelegate :: struct {
    	using _: Object,
    	using _: ObjectProtocol,
    }

    Bound Objective-C Methods

    Methods Inherited From Object
    MenuItem :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object
    MenuItemCallback :: proc "c" (unused: rawptr, name: ^intrinsics.objc_selector, sender: ^Object)
    MenuPresentationStyle :: enum i32 {
    	Regular = 0, 
    	Palette = 1, 
    }
    MenuProperties :: distinct bit_set[MenuPropertyItem; u32]
    MenuPropertyItem :: enum u32 {
    	Title                    = 0, 
    	AttributedTitle          = 1, 
    	KeyEquivalent            = 2, 
    	Image                    = 3, 
    	Enabled                  = 4, 
    	AccessibilityDescription = 5, 
    }
    MenuSelectionMode :: enum i32 {
    	Automatic = 0, 
    	SelectOne = 1, 
    	SelectAny = 2, 
    }

    ModalResponse ¶

    ModalResponse :: enum UInteger {
    	Cancel = 0, 
    	OK     = 1, 
    }

    MutableArray ¶

    MutableArray :: struct {
    	using _: Copying($T=MutableArray),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Notification ¶

    Notification :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object

    NotificationCenter ¶

    NotificationCenter :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    NotificationName ¶

    NotificationName :: ^String

    Related Procedures With Parameters

    Related Procedures With Returns

    Number ¶

    Number :: struct {
    	using _: Copying($T=Number),
    	using _: Value,
    }

    Bound Objective-C Methods

    Methods Inherited From Value
    Methods Inherited From Object

    Object ¶

    Object :: struct {
    	using _: intrinsics.objc_object,
    }

    Bound Objective-C Methods

    ObjectProtocol ¶

    ObjectProtocol :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    Object_VTable_Info ¶

    Object_VTable_Info :: struct {
    	vtable: rawptr,
    	size:   uint,
    	impl:   Subclasser_Proc,
    }

    OpenPanel ¶

    OpenPanel :: struct {
    	using _: SavePanel,
    }

    Bound Objective-C Methods

    Methods Inherited From SavePanel
    Methods Inherited From Window
    Methods Inherited From Object

    OperatingSystemVersion ¶

    OperatingSystemVersion :: struct #align (8) {
    	majorVersion: Integer,
    	minorVersion: Integer,
    	patchVersion: Integer,
    }

    Panel ¶

    Panel :: struct {
    	using _: Window,
    }
    Methods Inherited From Window
    Methods Inherited From Object

    Pasteboard ¶

    Pasteboard :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    PointingDeviceType ¶

    PointingDeviceType :: enum UInteger {
    	Unknown = 0, 
    	Pen     = 1, 
    	Cursor  = 2, 
    	Eraser  = 3, 
    }
     

    pointer types for NSTabletProximity events or mouse events with subtype NSTabletProximityEventSubtype

    ProcessInfo ¶

    ProcessInfo :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    ProcessInfoThermalState ¶

    ProcessInfoThermalState :: enum i32 {
    	Nominal, 
    	Fair, 
    	Serious, 
    	Critical, 
    }

    Protocol ¶

    Protocol :: struct {
    	using _: intrinsics.objc_object,
    }

    Range ¶

    Range :: struct {
    	location: UInteger,
    	length:   UInteger,
    }

    Related Procedures With Parameters

    Related Procedures With Returns

    Responder ¶

    Responder :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    RunLoop ¶

    RunLoop :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    RunLoopMode ¶

    RunLoopMode :: ^String

    Related Procedures With Parameters

    Related Procedures With Returns

    RunningApplication ¶

    RunningApplication :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    SavePanel ¶

    SavePanel :: struct {
    	using _: Panel,
    }

    Bound Objective-C Methods

    Methods Inherited From Window
    Methods Inherited From Object

    Screen ¶

    Screen :: struct {
    	using _: Object,
    }
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Bound Objective-C Methods

    Methods Inherited From Object

    Set ¶

    Set :: struct {
    	using _: Copying($T=Set),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Size ¶

    Size :: CoreFoundation.CGSize
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Related Procedures With Parameters

    String ¶

    String :: struct {
    	using _: Copying($T=String),
    }
    External examples metal/learn_metal/01-primitive · metal/learn_metal/02-argbuffers · metal/learn_metal/02-argbuffers-no-sdl +7

    Bound Objective-C Methods

    Methods Inherited From Object

    StringCompareOption ¶

    StringCompareOption :: enum UInteger {
    	CaseInsensitive      = 0, 
    	LiteralSearch        = 1, 
    	BackwardsSearch      = 2, 
    	AnchoredSearch       = 3, 
    	NumericSearch        = 6, 
    	DiacriticInsensitive = 7, 
    	WidthInsensitive     = 8, 
    	ForcedOrdering       = 9, 
    	RegularExpression    = 10, 
    }

    StringCompareOptions ¶

    StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger]

    StringEncoding ¶

    StringEncoding :: enum UInteger {
    	ASCII             = 1, 
    	NEXTSTEP          = 2, 
    	JapaneseEUC       = 3, 
    	UTF8              = 4, 
    	ISOLatin1         = 5, 
    	Symbol            = 6, 
    	NonLossyASCII     = 7, 
    	ShiftJIS          = 8, 
    	ISOLatin2         = 9, 
    	Unicode           = 10, 
    	WindowsCP1251     = 11, 
    	WindowsCP1252     = 12, 
    	WindowsCP1253     = 13, 
    	WindowsCP1254     = 14, 
    	WindowsCP1250     = 15, 
    	ISO2022JP         = 21, 
    	MacOSRoman        = 30, 
    	UTF16             = Unicode, 
    	UTF16BigEndian    = 0x90000100, 
    	UTF16LittleEndian = 0x94000100, 
    	UTF32             = 0x8c000100, 
    	UTF32BigEndian    = 0x98000100, 
    	UTF32LittleEndian = 0x9c000100, 
    }

    Related Procedures With Parameters

    Subclasser_Proc ¶

    Subclasser_Proc :: proc(cls: ^intrinsics.objc_class, vtable: rawptr)

    Timer ¶

    Timer :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Toolbar ¶

    Toolbar :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    URL ¶

    URL :: struct {
    	using _: Copying($T=URL),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    URLRequest ¶

    URLRequest :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    URLResponse ¶

    URLResponse :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    UndoManager ¶

    UndoManager :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    UserActivity ¶

    UserActivity :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    UserDefaults ¶

    UserDefaults :: struct {
    	using _: Object,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    UserInterfaceLayoutDirection ¶

    UserInterfaceLayoutDirection :: enum i32 {
    	LeftToRight = 0, 
    	RightToLeft = 1, 
    }

    Value ¶

    Value :: struct {
    	using _: Copying($T=Value),
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    View ¶

    View :: struct {
    	using _: Responder,
    }

    Bound Objective-C Methods

    Methods Inherited From Object

    Window ¶

    Window :: struct {
    	using _: Responder,
    }
    External examples metal/learn_metal/00-window · metal/learn_metal/01-primitive · metal/learn_metal/02-argbuffers +9

    Bound Objective-C Methods

    Methods Inherited From Object

    WindowCollectionBehaviorFlag ¶

    WindowCollectionBehaviorFlag :: enum UInteger {
    	CanJoinAllSpaces          = 0, 
    	MoveToActiveSpace         = 1, 
    	Managed                   = 2, 
    	Transient                 = 3, 
    	Stationary                = 4, 
    	ParticipatesInCycle       = 5, 
    	IgnoresCycle              = 6, 
    	FullScreenPrimary         = 7, 
    	FullScreenAuxiliary       = 8, 
    	FullScreenNone            = 9, 
    	FullScreenAllowsTiling    = 11, 
    	FullScreenDisallowsTiling = 12, 
    	Primary                   = 16, 
    	Auxiliary                 = 17, 
    	CanJoinAllApplications    = 18, 
    }

    WindowDelegate ¶

    WindowDelegate :: struct {
    	using _: Object,
    }
     

    This is not the same as NSWindowDelegate

    Related Procedures With Returns

    Procedures Through `using` From Object
    Procedures Through `using` From objc_object

    WindowDelegateTemplate ¶

    WindowDelegateTemplate :: struct {
    	// Managing Sheets
    	windowWillPositionSheetUsingRect:                                    proc(window: ^Window, sheet: ^Window, rect: CoreFoundation.CGRect) -> CoreFoundation.CGRect,
    	windowWillBeginSheet:                                                proc(notification: ^Notification),
    	windowDidEndSheet:                                                   proc(notification: ^Notification),
    	// Sizing Windows
    	windowWillResizeToSize:                                              proc(sender: ^Window, frameSize: CoreFoundation.CGSize) -> CoreFoundation.CGSize,
    	windowDidResize:                                                     proc(notification: ^Notification),
    	windowWillStartLiveResize:                                           proc(noitifcation: ^Notification),
    	windowDidEndLiveResize:                                              proc(notification: ^Notification),
    	// Minimizing Windows
    	windowWillMiniaturize:                                               proc(notification: ^Notification),
    	windowDidMiniaturize:                                                proc(notification: ^Notification),
    	windowDidDeminiaturize:                                              proc(notification: ^Notification),
    	// Zooming window
    	windowWillUseStandardFrameDefaultFrame:                              proc(window: ^Window, newFrame: CoreFoundation.CGRect) -> CoreFoundation.CGRect,
    	windowShouldZoomToFrame:                                             proc(window: ^Window, newFrame: CoreFoundation.CGRect) -> bool,
    	// Managing Full-Screen Presentation
    	windowWillUseFullScreenContentSize:                                  proc(window: ^Window, proposedSize: CoreFoundation.CGSize) -> CoreFoundation.CGSize,
    	windowWillUseFullScreenPresentationOptions:                          proc(window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions,
    	windowWillEnterFullScreen:                                           proc(notification: ^Notification),
    	windowDidEnterFullScreen:                                            proc(notification: ^Notification),
    	windowWillExitFullScreen:                                            proc(notification: ^Notification),
    	windowDidExitFullScreen:                                             proc(notification: ^Notification),
    	// Custom Full-Screen Presentation Animations
    	customWindowsToEnterFullScreenForWindow:                             proc(window: ^Window) -> ^Array,
    	customWindowsToEnterFullScreenForWindowOnScreen:                     proc(window: ^Window, screen: ^Screen) -> ^Array,
    	windowStartCustomAnimationToEnterFullScreenWithDuration:             proc(window: ^Window, duration: TimeInterval),
    	windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration:     proc(window: ^Window, screen: ^Screen, duration: TimeInterval),
    	windowDidFailToEnterFullScreen:                                      proc(window: ^Window),
    	customWindowsToExitFullScreenForWindow:                              proc(window: ^Window) -> ^Array,
    	windowStartCustomAnimationToExitFullScreenWithDuration:              proc(window: ^Window, duration: TimeInterval),
    	windowDidFailToExitFullScreen:                                       proc(window: ^Window),
    	// Moving Windows
    	windowWillMove:                                                      proc(notification: ^Notification),
    	windowDidMove:                                                       proc(notification: ^Notification),
    	windowDidChangeScreen:                                               proc(notification: ^Notification),
    	windowDidChangeScreenProfile:                                        proc(notification: ^Notification),
    	windowDidChangeBackingProperties:                                    proc(notification: ^Notification),
    	// Closing Windows
    	windowShouldClose:                                                   proc(sender: ^Window) -> bool,
    	windowWillClose:                                                     proc(notification: ^Notification),
    	// Managing Key Status
    	windowDidBecomeKey:                                                  proc(notification: ^Notification),
    	windowDidResignKey:                                                  proc(notification: ^Notification),
    	// Managing Main Status
    	windowDidBecomeMain:                                                 proc(notification: ^Notification),
    	windowDidResignMain:                                                 proc(notification: ^Notification),
    	// Managing Field Editors
    	windowWillReturnFieldEditorToObject:                                 proc(sender: ^Window, client: ^intrinsics.objc_object) -> ^intrinsics.objc_object,
    	// Updating Windows
    	windowDidUpdate:                                                     proc(notification: ^Notification),
    	// Exposing Windows
    	windowDidExpose:                                                     proc(notification: ^Notification),
    	// Managing Occlusion State
    	windowDidChangeOcclusionState:                                       proc(notification: ^Notification),
    	// Dragging Windows
    	windowShouldDragDocumentWithEventFromWithPasteboard:                 proc(window: ^Window, event: ^Event, dragImageLocation: CoreFoundation.CGPoint, pasteboard: ^Pasteboard) -> bool,
    	// Getting the Undo Manager
    	windowWillReturnUndoManager:                                         proc(window: ^Window) -> ^UndoManager,
    	// Managing Titles
    	windowShouldPopUpDocumentPathMenu:                                   proc(window: ^Window, menu: ^Menu) -> bool,
    	// Managing Restorable State
    	windowWillEncodeRestorableState:                                     proc(window: ^Window, state: ^Coder),
    	windowDidEncodeRestorableState:                                      proc(window: ^Window, state: ^Coder),
    	// Managing Presentation in Version Browsers
    	windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize: proc(window: ^Window, maxPreferredFrameSize: CoreFoundation.CGSize, maxAllowedFrameSize: CoreFoundation.CGSize) -> CoreFoundation.CGSize,
    	windowWillEnterVersionBrowser:                                       proc(notification: ^Notification),
    	windowDidEnterVersionBrowser:                                        proc(notification: ^Notification),
    	windowWillExitVersionBrowser:                                        proc(notification: ^Notification),
    	windowDidExitVersionBrowser:                                         proc(notification: ^Notification),
    }

    WindowLevel ¶

    WindowLevel :: enum Integer {
    	Normal      = 0, 
    	Floating    = 3, 
    	Submenu     = 3, 
    	TornOffMenu = 3, 
    	ModalPanel  = 8, 
    	MainMenu    = 24, 
    	Status      = 25, 
    	PopUpMenu   = 101, 
    	ScreenSaver = 1000, 
    }

    WindowStyleFlag ¶

    WindowStyleFlag :: enum UInteger {
    	Titled                 = 0, 
    	Closable               = 1, 
    	Miniaturizable         = 2, 
    	Resizable              = 3, 
    	TexturedBackground     = 8, 
    	UnifiedTitleAndToolbar = 12, 
    	FullScreen             = 14, 
    	FullSizeContentView    = 15, 
    	UtilityWindow          = 4, 
    	DocModalWindow         = 6, 
    	NonactivatingPanel     = 7, 
    	HUDWindow              = 13, 
    }

    WindowTabbingMode ¶

    WindowTabbingMode :: enum Integer {
    	Automatic  = 0, 
    	Preferred  = 1, 
    	Disallowed = 2, 
    }

    Window_Title_Visibility ¶

    Window_Title_Visibility :: enum UInteger {
    	Visible, 
    	Hidden, 
    }

    Zone ¶

    Zone :: struct {
    	using _: Object,
    }
    Methods Inherited From Object

    id ¶

    id :: ^intrinsics.objc_object
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Related Procedures With Parameters

    Related Procedures With Returns

    kVK ¶

    kVK :: enum int {
    	ANSI_A              = 0x00, 
    	ANSI_S              = 0x01, 
    	ANSI_D              = 0x02, 
    	ANSI_F              = 0x03, 
    	ANSI_H              = 0x04, 
    	ANSI_G              = 0x05, 
    	ANSI_Z              = 0x06, 
    	ANSI_X              = 0x07, 
    	ANSI_C              = 0x08, 
    	ANSI_V              = 0x09, 
    	ANSI_B              = 0x0B, 
    	ANSI_Q              = 0x0C, 
    	ANSI_W              = 0x0D, 
    	ANSI_E              = 0x0E, 
    	ANSI_R              = 0x0F, 
    	ANSI_Y              = 0x10, 
    	ANSI_T              = 0x11, 
    	ANSI_1              = 0x12, 
    	ANSI_2              = 0x13, 
    	ANSI_3              = 0x14, 
    	ANSI_4              = 0x15, 
    	ANSI_6              = 0x16, 
    	ANSI_5              = 0x17, 
    	ANSI_Equal          = 0x18, 
    	ANSI_9              = 0x19, 
    	ANSI_7              = 0x1A, 
    	ANSI_Minus          = 0x1B, 
    	ANSI_8              = 0x1C, 
    	ANSI_0              = 0x1D, 
    	ANSI_RightBracket   = 0x1E, 
    	ANSI_O              = 0x1F, 
    	ANSI_U              = 0x20, 
    	ANSI_LeftBracket    = 0x21, 
    	ANSI_I              = 0x22, 
    	ANSI_P              = 0x23, 
    	ANSI_L              = 0x25, 
    	ANSI_J              = 0x26, 
    	ANSI_Quote          = 0x27, 
    	ANSI_K              = 0x28, 
    	ANSI_Semicolon      = 0x29, 
    	ANSI_Backslash      = 0x2A, 
    	ANSI_Comma          = 0x2B, 
    	ANSI_Slash          = 0x2C, 
    	ANSI_N              = 0x2D, 
    	ANSI_M              = 0x2E, 
    	ANSI_Period         = 0x2F, 
    	ANSI_Grave          = 0x32, 
    	ANSI_KeypadDecimal  = 0x41, 
    	ANSI_KeypadMultiply = 0x43, 
    	ANSI_KeypadPlus     = 0x45, 
    	ANSI_KeypadClear    = 0x47, 
    	ANSI_KeypadDivide   = 0x4B, 
    	ANSI_KeypadEnter    = 0x4C, 
    	ANSI_KeypadMinus    = 0x4E, 
    	ANSI_KeypadEquals   = 0x51, 
    	ANSI_Keypad0        = 0x52, 
    	ANSI_Keypad1        = 0x53, 
    	ANSI_Keypad2        = 0x54, 
    	ANSI_Keypad3        = 0x55, 
    	ANSI_Keypad4        = 0x56, 
    	ANSI_Keypad5        = 0x57, 
    	ANSI_Keypad6        = 0x58, 
    	ANSI_Keypad7        = 0x59, 
    	ANSI_Keypad8        = 0x5B, 
    	ANSI_Keypad9        = 0x5C, 
    	Return              = 0x24, 
    	Tab                 = 0x30, 
    	Space               = 0x31, 
    	Delete              = 0x33, 
    	Escape              = 0x35, 
    	Command             = 0x37, 
    	Shift               = 0x38, 
    	CapsLock            = 0x39, 
    	Option              = 0x3A, 
    	Control             = 0x3B, 
    	RightCommand        = 0x36, 
    	RightShift          = 0x3C, 
    	RightOption         = 0x3D, 
    	RightControl        = 0x3E, 
    	Function            = 0x3F, 
    	F17                 = 0x40, 
    	VolumeUp            = 0x48, 
    	VolumeDown          = 0x49, 
    	Mute                = 0x4A, 
    	F18                 = 0x4F, 
    	F19                 = 0x50, 
    	F20                 = 0x5A, 
    	F5                  = 0x60, 
    	F6                  = 0x61, 
    	F7                  = 0x62, 
    	F3                  = 0x63, 
    	F8                  = 0x64, 
    	F9                  = 0x65, 
    	F11                 = 0x67, 
    	F13                 = 0x69, 
    	F16                 = 0x6A, 
    	F14                 = 0x6B, 
    	F10                 = 0x6D, 
    	F12                 = 0x6F, 
    	F15                 = 0x71, 
    	Help                = 0x72, 
    	Home                = 0x73, 
    	PageUp              = 0x74, 
    	ForwardDelete       = 0x75, 
    	F4                  = 0x76, 
    	End                 = 0x77, 
    	F2                  = 0x78, 
    	PageDown            = 0x79, 
    	F1                  = 0x7A, 
    	LeftArrow           = 0x7B, 
    	RightArrow          = 0x7C, 
    	DownArrow           = 0x7D, 
    	UpArrow             = 0x7E, 
    	JIS_Yen             = 0x5D, 
    	JIS_Underscore      = 0x5E, 
    	JIS_KeypadComma     = 0x5F, 
    	JIS_Eisu            = 0x66, 
    	JIS_Kana            = 0x68, 
    	ISO_Section         = 0x0A, 
    }
     

    Defined in Carbon.framework Events.h

    External examples metal/learn_metal/02-argbuffers-no-sdl

    objc_AssociationPolicy ¶

    objc_AssociationPolicy :: enum uintptr {
    	Assign           = 0, 
    	Retain_Nonatomic = 1, 
    	Copy_Nonatomic   = 3, 
    	Retain           = 01401, 
    	Copy             = 01403, 
    }

    objc_cache ¶

    objc_cache :: struct {
    	mask:     u32,
    	occupied: u32,
    	buckets:  [1]^objc_method,
    }

    objc_class_internals ¶

    objc_class_internals :: struct {
    	isa:           ^intrinsics.objc_class,
    	super_class:   ^intrinsics.objc_class,
    	name:          cstring,
    	version:       i32,
    	info:          i32,
    	instance_size: i32,
    	ivars:         ^objc_ivar_list,
    	methodLists:   ^^objc_method_list,
    	cache:         rawptr,
    	protocols:     rawptr,
    }

    objc_ivar_list ¶

    objc_ivar_list :: struct {}

    objc_method_list ¶

    objc_method_list :: struct {}

    objc_object_internals ¶

    objc_object_internals :: struct {
    	isa: ^objc_class_internals,
    }

    objc_property ¶

    objc_property :: struct {}

    Related Procedures With Parameters

    objc_property_attribute_t ¶

    objc_property_attribute_t :: struct {
    	name:  cstring,
    	value: cstring,
    }

    Related Procedures With Parameters

    objc_protocol_list ¶

    objc_protocol_list :: struct {
    	next:  ^objc_protocol_list,
    	count: i32,
    	list:  [1]^Protocol,
    }

    unichar ¶

    unichar :: distinct u16

    Constants

    ApplicationPresentationOptionsAutoHideDock ¶

    ApplicationPresentationOptionsAutoHideDock :: ApplicationPresentationOptions{.AutoHideDock}

    ApplicationPresentationOptionsAutoHideMenuBar ¶

    ApplicationPresentationOptionsAutoHideMenuBar :: ApplicationPresentationOptions{.AutoHideMenuBar}

    ApplicationPresentationOptionsAutoHideToolbar ¶

    ApplicationPresentationOptionsAutoHideToolbar :: ApplicationPresentationOptions{.AutoHideToolbar}

    ApplicationPresentationOptionsDefault ¶

    ApplicationPresentationOptionsDefault :: ApplicationPresentationOptions{}

    ApplicationPresentationOptionsDisableAppleMenu ¶

    ApplicationPresentationOptionsDisableAppleMenu :: ApplicationPresentationOptions{.DisableAppleMenu}

    ApplicationPresentationOptionsDisableCursorLocationAssistance ¶

    ApplicationPresentationOptionsDisableCursorLocationAssistance :: ApplicationPresentationOptions{.DisableCursorLocationAssistance}

    ApplicationPresentationOptionsDisableForceQuit ¶

    ApplicationPresentationOptionsDisableForceQuit :: ApplicationPresentationOptions{.DisableForceQuit}

    ApplicationPresentationOptionsDisableHideApplication ¶

    ApplicationPresentationOptionsDisableHideApplication :: ApplicationPresentationOptions{.DisableHideApplication}

    ApplicationPresentationOptionsDisableMenuBarTransparency ¶

    ApplicationPresentationOptionsDisableMenuBarTransparency :: ApplicationPresentationOptions{.DisableMenuBarTransparency}

    ApplicationPresentationOptionsDisableProcessSwitching ¶

    ApplicationPresentationOptionsDisableProcessSwitching :: ApplicationPresentationOptions{.DisableProcessSwitching}

    ApplicationPresentationOptionsDisableSessionTermination ¶

    ApplicationPresentationOptionsDisableSessionTermination :: ApplicationPresentationOptions{.DisableSessionTermination}

    ApplicationPresentationOptionsFullScreen ¶

    ApplicationPresentationOptionsFullScreen :: ApplicationPresentationOptions{.FullScreen}

    ApplicationPresentationOptionsHideDock ¶

    ApplicationPresentationOptionsHideDock :: ApplicationPresentationOptions{.HideDock}

    ApplicationPresentationOptionsHideMenuBar ¶

    ApplicationPresentationOptionsHideMenuBar :: ApplicationPresentationOptions{.HideMenuBar}

    EventMaskAny ¶

    EventMaskAny: EventMask : transmute(EventMask)(max(UInteger))
    External examples metal/learn_metal/02-argbuffers-no-sdl

    EventModifierFlagCapsLock ¶

    EventModifierFlagCapsLock :: EventModifierFlags{.CapsLock}

    EventModifierFlagCommand ¶

    EventModifierFlagCommand :: EventModifierFlags{.Command}

    EventModifierFlagControl ¶

    EventModifierFlagControl :: EventModifierFlags{.Control}

    EventModifierFlagDeviceIndependentFlagsMask ¶

    EventModifierFlagDeviceIndependentFlagsMask: UInteger : 0xffff0000

    EventModifierFlagFunction ¶

    EventModifierFlagFunction :: EventModifierFlags{.Function}

    EventModifierFlagHelp ¶

    EventModifierFlagHelp :: EventModifierFlags{.Help}

    EventModifierFlagNumericPad ¶

    EventModifierFlagNumericPad :: EventModifierFlags{.NumericPad}

    EventModifierFlagOption ¶

    EventModifierFlagOption :: EventModifierFlags{.Option}

    EventModifierFlagShift ¶

    EventModifierFlagShift :: EventModifierFlags{.Shift}

    EventPhaseBegan ¶

    EventPhaseBegan :: EventPhase{.Began}

    EventPhaseCancelled ¶

    EventPhaseCancelled :: EventPhase{.Cancelled}

    EventPhaseChanged ¶

    EventPhaseChanged :: EventPhase{.Changed}

    EventPhaseEnded ¶

    EventPhaseEnded :: EventPhase{.Ended}

    EventPhaseMayBegin ¶

    EventPhaseMayBegin :: EventPhase{.MayBegin}

    EventPhaseNone ¶

    EventPhaseNone :: EventPhase{}

    EventPhaseStationary ¶

    EventPhaseStationary :: EventPhase{.Stationary}

    NO ¶

    NO :: false
    External examples metal/learn_metal/02-argbuffers-no-sdl

    NotFound ¶

    NotFound :: IntegerMax

    UIntegerMax ¶

    UIntegerMax: UInteger : max(UInteger)

    WindowCollectionBehaviorAuxiliary ¶

    WindowCollectionBehaviorAuxiliary :: WindowCollectionBehavior{.Auxiliary, .FullScreenNone}

    WindowCollectionBehaviorCanJoinAllApplications ¶

    WindowCollectionBehaviorCanJoinAllApplications :: WindowCollectionBehavior{.CanJoinAllApplications}

    WindowCollectionBehaviorCanJoinAllSpaces ¶

    WindowCollectionBehaviorCanJoinAllSpaces :: WindowCollectionBehavior{.CanJoinAllSpaces}

    WindowCollectionBehaviorDefault ¶

    WindowCollectionBehaviorDefault :: WindowCollectionBehavior{}

    WindowCollectionBehaviorFullScreenAllowsTiling ¶

    WindowCollectionBehaviorFullScreenAllowsTiling :: WindowCollectionBehavior{.FullScreenAllowsTiling}

    WindowCollectionBehaviorFullScreenAuxiliary ¶

    WindowCollectionBehaviorFullScreenAuxiliary :: WindowCollectionBehavior{.FullScreenAuxiliary}

    WindowCollectionBehaviorFullScreenDisallowsTiling ¶

    WindowCollectionBehaviorFullScreenDisallowsTiling :: WindowCollectionBehavior{.FullScreenDisallowsTiling}

    WindowCollectionBehaviorFullScreenNone ¶

    WindowCollectionBehaviorFullScreenNone :: WindowCollectionBehavior{.FullScreenNone}

    WindowCollectionBehaviorFullScreenPrimary ¶

    WindowCollectionBehaviorFullScreenPrimary :: WindowCollectionBehavior{.FullScreenPrimary}

    WindowCollectionBehaviorIgnoresCycle ¶

    WindowCollectionBehaviorIgnoresCycle :: WindowCollectionBehavior{.IgnoresCycle}

    WindowCollectionBehaviorManaged ¶

    WindowCollectionBehaviorManaged :: WindowCollectionBehavior{.Managed}

    WindowCollectionBehaviorMoveToActiveSpace ¶

    WindowCollectionBehaviorMoveToActiveSpace :: WindowCollectionBehavior{.MoveToActiveSpace}

    WindowCollectionBehaviorParticipatesInCycle ¶

    WindowCollectionBehaviorParticipatesInCycle :: WindowCollectionBehavior{.ParticipatesInCycle}

    WindowCollectionBehaviorPrimary ¶

    WindowCollectionBehaviorPrimary :: WindowCollectionBehavior{.Primary, .FullScreenAuxiliary}

    WindowCollectionBehaviorStationary ¶

    WindowCollectionBehaviorStationary :: WindowCollectionBehavior{.Stationary}

    WindowCollectionBehaviorTransient ¶

    WindowCollectionBehaviorTransient :: WindowCollectionBehavior{.Transient}

    WindowStyleMaskBorderless ¶

    WindowStyleMaskBorderless :: WindowStyleMask{}

    WindowStyleMaskClosable ¶

    WindowStyleMaskClosable :: WindowStyleMask{.Closable}

    WindowStyleMaskDocModalWindow ¶

    WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow}

    WindowStyleMaskFullScreen ¶

    WindowStyleMaskFullScreen :: WindowStyleMask{.FullScreen}

    WindowStyleMaskFullSizeContentView ¶

    WindowStyleMaskFullSizeContentView :: WindowStyleMask{.FullSizeContentView}

    WindowStyleMaskHUDWindow ¶

    WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow}

    WindowStyleMaskMiniaturizable ¶

    WindowStyleMaskMiniaturizable :: WindowStyleMask{.Miniaturizable}

    WindowStyleMaskNonactivatingPanel ¶

    WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel}

    WindowStyleMaskResizable ¶

    WindowStyleMaskResizable :: WindowStyleMask{.Resizable}

    WindowStyleMaskTexturedBackground ¶

    WindowStyleMaskTexturedBackground :: WindowStyleMask{.TexturedBackground}

    WindowStyleMaskTitled ¶

    WindowStyleMaskTitled :: WindowStyleMask{.Titled}

    WindowStyleMaskUnifiedTitleAndToolbar ¶

    WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}

    WindowStyleMaskUtilityWindow ¶

    WindowStyleMaskUtilityWindow :: WindowStyleMask{.UtilityWindow}

    Variables

    CocoaErrorDomain ¶

    @(linkage="weak")
    CocoaErrorDomain: ^String

    DebugDescriptionErrorKey ¶

    @(linkage="weak")
    DebugDescriptionErrorKey: ^String

    DefaultRunLoopMode ¶
    C · NSDefaultRunLoopModeSource · NSRunLoop.odin:10

    DefaultRunLoopMode: ^String
    External examples metal/learn_metal/02-argbuffers-no-sdl

    DeviceRGBColorSpace ¶
    C · NSDeviceRGBColorSpaceSource · NSColor.odin:155

    DeviceRGBColorSpace: ^String

    EventTrackingRunLoopMode ¶
    C · NSEventTrackingRunLoopModeSource · NSRunLoop.odin:11

    EventTrackingRunLoopMode: ^String

    FilePathErrorKey ¶

    @(linkage="weak")
    FilePathErrorKey: ^String

    HelpAnchorErrorKey ¶

    @(linkage="weak")
    HelpAnchorErrorKey: ^String

    KeyEventModifierFlagDeviceIndependentFlagsMask ¶

    KeyEventModifierFlagDeviceIndependentFlagsMask: EventModifierFlags = …
     

    Used to retrieve only the device-independent modifier flags, allowing applications to mask off the device-dependent modifier flags, including event coalescing information.

    LocalizedDescriptionKey ¶

    @(linkage="weak")
    LocalizedDescriptionKey: ^String

    LocalizedFailureErrorKey ¶

    @(linkage="weak")
    LocalizedFailureErrorKey: ^String

    LocalizedFailureReasonErrorKey ¶

    @(linkage="weak")
    LocalizedFailureReasonErrorKey: ^String

    LocalizedRecoveryOptionsErrorKey ¶

    @(linkage="weak")
    LocalizedRecoveryOptionsErrorKey: ^String

    LocalizedRecoverySuggestionErrorKey ¶

    @(linkage="weak")
    LocalizedRecoverySuggestionErrorKey: ^String

    MachErrorDomain ¶

    @(linkage="weak")
    MachErrorDomain: ^String

    ModalPanelRunLoopMode ¶
    C · NSModalPanelRunLoopModeSource · NSRunLoop.odin:12

    ModalPanelRunLoopMode: ^String

    OSStatusErrorDomain ¶

    @(linkage="weak")
    OSStatusErrorDomain: ^String

    POSIXErrorDomain ¶

    @(linkage="weak")
    POSIXErrorDomain: ^String

    RecoveryAttempterErrorKey ¶

    @(linkage="weak")
    RecoveryAttempterErrorKey: ^String

    RunLoopCommonModes ¶
    C · NSRunLoopCommonModesSource · NSRunLoop.odin:9

    RunLoopCommonModes: ^String

    StringEncodingErrorKey ¶

    @(linkage="weak")
    StringEncodingErrorKey: ^String

    URLErrorKey ¶

    @(linkage="weak")
    URLErrorKey: ^String

    UnderlyingErrorKey ¶

    @(linkage="weak")
    UnderlyingErrorKey: ^String

    Procedures

    AT ¶

     

    CFString is 'toll-free bridged' with its Cocoa Foundation counterpart, NSString.

    External examples metal/learn_metal/08-compute · metal/learn_metal/09-compute-to-render · metal/learn_metal/01-primitive +7

    AllocateObject ¶
    C · NSAllocateObjectSource · objc.odin:101

    AllocateObject :: proc "c" (
    	aClass:     ^intrinsics.objc_class, 
    	extraBytes: UInteger, 
    	zone:       ^Zone, 
    ) -> ^intrinsics.objc_object ---

    Application_activate ¶

    Application_activate :: proc "c" (self: ^Application) {…}
    application->activate()

    Application_activateIgnoringOtherApps ¶

    Application_activateIgnoringOtherApps :: proc "c" (self: ^Application, ignoreOtherApps: bool) {…}
    application->activateIgnoringOtherApps(ignoreOtherApps)
     

    NOTE: this is technically deprecated but still actively used (Sokol, glfw, SDL, etc.) and has no clear alternative although activate is what Apple tells you to use, that does not work the same way.

    Application_active ¶

    Application_active :: proc "c" (self: ^Application) -> bool {…}
    active := application->active()

    Application_currentEvent ¶

    Application_currentEvent :: proc "c" (self: ^Application) -> ^Event {…}
    currentEvent := application->currentEvent()

    Application_finishLaunching ¶

    Application_finishLaunching :: proc "c" (self: ^Application) {…}
    application->finishLaunching()

    Application_isRunning ¶

    Application_isRunning :: proc "c" (self: ^Application) -> bool {…}
    isRunning := application->isRunning()

    Application_keyWindow ¶

    Application_keyWindow :: proc "c" (self: ^Application) -> ^Window {…}
    keyWindow := application->keyWindow()

    Application_mainMenu ¶

    Application_mainMenu :: proc "c" (self: ^Application) -> ^Menu {…}
    mainMenu := application->mainMenu()

    Application_mainWindow ¶

    Application_mainWindow :: proc "c" (self: ^Application) -> ^Window {…}
    mainWindow := application->mainWindow()

    Application_nextEventMatchingMask ¶

    Application_nextEventMatchingMask :: proc "c" (
    	self:       ^Application, 
    	mask:       EventMask, 
    	expiration: ^Date, 
    	in_mode:    ^String, 
    	dequeue:    bool, 
    ) -> ^Event {…}
    event := application->nextEventMatchingMask(mask, expiration, in_mode, dequeue)

    Application_postEvent ¶

    Application_postEvent :: proc "c" (self: ^Application, event: ^Event, atStart: bool) {…}
    application->postEvent(event, atStart)

    Application_run ¶

    Application_run :: proc "c" (self: ^Application) {…}
    application->run()

    Application_sendAction ¶

    Application_sendAction :: proc "c" (
    	self:   ^Application, 
    	action: ^intrinsics.objc_selector, 
    	to:     ^intrinsics.objc_object, 
    	from:   ^intrinsics.objc_object, 
    ) {…}
    application->sendAction(action, to, from)

    Application_sendEvent ¶

    Application_sendEvent :: proc "c" (self: ^Application, event: ^Event) {…}
    application->sendEvent(event)

    Application_servicesMenu ¶

    Application_servicesMenu :: proc "c" (self: ^Application) -> ^Menu {…}
    servicesMenu := application->servicesMenu()

    Application_setActivationPolicy ¶

    Application_setActivationPolicy :: proc "c" (
    	self:             ^Application, 
    	activationPolicy: ActivationPolicy, 
    ) -> bool {…}
    res := application->setActivationPolicy(activationPolicy)

    Application_setAppleMenu ¶

    Application_setAppleMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}
    application->setAppleMenu(menu)
     

    This property is actually not exposed in AppKit's public API. But there is basically no other way to configure the apple menu without using NIB files. Therefore, an Odin binding for this non-public API was created. Note: SDL also calls this non-public method.

    Application_setDelegate ¶

    Application_setDelegate :: proc "c" (self: ^Application, delegate: ^ApplicationDelegate) {…}
    application->setDelegate(delegate)

    Application_setMainMenu ¶

    Application_setMainMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}
    application->setMainMenu(menu)

    Application_setServicesMenu ¶

    Application_setServicesMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}
    application->setServicesMenu(menu)

    Application_setTitle ¶

    Application_setTitle :: proc "c" (self: ^Application, title: ^String) {…}
    application->setTitle(title)

    Application_setWindowsMenu ¶

    Application_setWindowsMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}
    application->setWindowsMenu(menu)

    Application_sharedApplication ¶ class method

    Application_sharedApplication :: proc "c" () -> ^Application {…}
    application := Application.sharedApplication()

    Application_stop ¶

    Application_stop :: proc "c" (self: ^Application, sender: ^Object) {…}
    application->stop(sender)

    Application_terminate ¶

    Application_terminate :: proc "c" (self: ^Application, sender: ^Object) {…}
    application->terminate(sender)

    Application_updateWindows ¶

    Application_updateWindows :: proc "c" (self: ^Application) {…}
    application->updateWindows()

    Application_windows ¶

    Application_windows :: proc "c" (self: ^Application) -> ^Array {…}
    windows := application->windows()

    Application_windowsMenu ¶

    Application_windowsMenu :: proc "c" (self: ^Application) -> ^Menu {…}
    windowsMenu := application->windowsMenu()

    Array_alloc ¶ class method owned

    Array_alloc :: proc "c" () -> ^Array {…}
    array := Array.alloc()

    Array_count ¶

    Array_count :: proc "c" (self: ^Array) -> UInteger {…}
    count := array->count()

    Array_init ¶

    Array_init :: proc "c" (self: ^Array) -> ^Array {…}
    res := array->init()

    Array_initWithCoder ¶

    Array_initWithCoder :: proc "c" (self: ^Array, coder: ^Coder) -> ^Array {…}
    res := array->initWithCoder(coder)

    Array_initWithObjects ¶

    Array_initWithObjects :: proc "c" (
    	self:    ^Array, 
    	objects: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Array {…}
    res := array->initWithObjects(objects, count)

    Array_object ¶

    Array_object :: proc "c" (self: ^Array, index: UInteger) -> ^Object {…}
    object := array->object(index)

    Array_objectAs ¶

    Array_objectAs :: proc "c" (self: ^Array, index: UInteger, $T: typeid) -> T {…}
    res := array->objectAs(index, T)

    AutoreleasePool_addObject ¶

    AutoreleasePool_addObject :: proc "c" (self: ^AutoreleasePool, obj: ^Object) {…}
    autoreleasePool->addObject(obj)

    AutoreleasePool_alloc ¶ class method owned

    AutoreleasePool_alloc :: proc "c" () -> ^AutoreleasePool {…}
    autoreleasePool := AutoreleasePool.alloc()

    AutoreleasePool_drain ¶

    AutoreleasePool_drain :: proc "c" (self: ^AutoreleasePool) {…}
    autoreleasePool->drain()

    AutoreleasePool_init ¶

    AutoreleasePool_init :: proc "c" (self: ^AutoreleasePool) -> ^AutoreleasePool {…}
    res := autoreleasePool->init()

    AutoreleasePool_showPools ¶

    AutoreleasePool_showPools :: proc "c" (self: ^AutoreleasePool, obj: ^Object) {…}
    autoreleasePool->showPools(obj)

    BitmapImageRep_CGImage ¶

    BitmapImageRep_CGImage :: proc "c" (self: ^BitmapImageRep) -> rawptr {…}
    CGImage := bitmapImageRep->CGImage()

    BitmapImageRep_alloc ¶ class method owned

    BitmapImageRep_alloc :: proc "c" () -> ^BitmapImageRep {…}
    bitmapImageRep := BitmapImageRep.alloc()

    BitmapImageRep_bitmapData ¶

    BitmapImageRep_bitmapData :: proc "c" (self: ^BitmapImageRep) -> rawptr {…}
    bitmapData := bitmapImageRep->bitmapData()

    BitmapImageRep_initWithBitmapDataPlanes_bitmapFormat ¶

    BitmapImageRep_initWithBitmapDataPlanes_bitmapFormat :: proc "c" (
    	self:             ^BitmapImageRep, 
    	bitmapDataPlanes: ^^u8, 
    	pixelsWide:       Integer, 
    	pixelsHigh:       Integer, 
    	bitsPerSample:    Integer, 
    	samplesPerPixel:  Integer, 
    	hasAlpha:         bool, 
    	isPlanar:         bool, 
    	colorSpaceName:   ^String, 
    	bitmapFormat:     bit_set[BitmapFormatFlag; BitmapInteger], 
    	bytesPerRow:      Integer, 
    	bitsPerPixel:     Integer, 
    ) -> ^BitmapImageRep {…}

    BitmapImageRep_initWithBitmapDataPlanes_legacy ¶

    BitmapImageRep_initWithBitmapDataPlanes_legacy :: proc "c" (
    	self:             ^BitmapImageRep, 
    	bitmapDataPlanes: ^^u8, 
    	pixelsWide:       Integer, 
    	pixelsHigh:       Integer, 
    	bitsPerSample:    Integer, 
    	samplesPerPixel:  Integer, 
    	hasAlpha:         bool, 
    	isPlanar:         bool, 
    	colorSpaceName:   ^String, 
    	bytesPerRow:      Integer, 
    	bitsPerPixel:     Integer, 
    ) -> ^BitmapImageRep {…}

    Block_createGlobal ¶ class method

    Block_createGlobal :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (user_data: rawptr), 
    	allocator := context.allocator, 
    ) -> (^Block, runtime.Allocator_Error) #optional_ok {…}
    res0, res1 := Block.createGlobal(user_data, user_proc, allocator)

    Block_createGlobalWithParam ¶ class method

    Block_createGlobalWithParam :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (user_data: rawptr, t: $T), 
    	allocator := context.allocator, 
    ) -> (^Block, runtime.Allocator_Error) #optional_ok {…}
    res0, res1 := Block.createGlobalWithParam(user_data, user_proc, allocator)

    Block_createLocal ¶ class method

    Block_createLocal :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (user_data: rawptr), 
    ) -> ^Block {…}
    block := Block.createLocal(user_data, user_proc)

    Block_createLocalWithParam ¶ class method

    Block_createLocalWithParam :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (user_data: rawptr, t: $T), 
    ) -> ^Block {…}
    block := Block.createLocalWithParam(user_data, user_proc)

    Block_invoke ¶

    Block_invoke :: proc "c" (self: ^Block, args: ..any) -> ^Object {…}
    object := block->invoke(args)

    Bundle_PathForAuxiliaryExecutable ¶

    Bundle_PathForAuxiliaryExecutable :: proc "c" (
    	self:           ^Bundle, 
    	executableName: ^String, 
    ) -> ^String {…}
    str := bundle->PathForAuxiliaryExecutable(executableName)

    Bundle_URLForAuxiliaryExecutable ¶

    Bundle_URLForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^URL {…}
    url := bundle->URLForAuxiliaryExecutable(executableName)

    Bundle_allBundles ¶

    Bundle_allBundles :: proc "c" () -> (all: ^Array) {…}
    all := bundle->allBundles()

    Bundle_allFrameworks ¶

    Bundle_allFrameworks :: proc "c" () -> (all: ^Array) {…}
    all := bundle->allFrameworks()

    Bundle_alloc ¶ class method owned

    Bundle_alloc :: proc "c" () -> ^Bundle {…}
    bundle := Bundle.alloc()

    Bundle_appStoreReceiptPath ¶

    Bundle_appStoreReceiptPath :: proc "c" (self: ^Bundle) -> ^String {…}
    appStoreReceiptPath := bundle->appStoreReceiptPath()

    Bundle_appStoreReceiptURL ¶

    Bundle_appStoreReceiptURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    appStoreReceiptURL := bundle->appStoreReceiptURL()

    Bundle_builtInPlugInsPath ¶

    Bundle_builtInPlugInsPath :: proc "c" (self: ^Bundle) -> ^String {…}
    builtInPlugInsPath := bundle->builtInPlugInsPath()

    Bundle_builtInPlugInsURL ¶

    Bundle_builtInPlugInsURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    builtInPlugInsURL := bundle->builtInPlugInsURL()

    Bundle_bundleIdentifier ¶

    Bundle_bundleIdentifier :: proc "c" (self: ^Bundle) -> ^String {…}
    bundleIdentifier := bundle->bundleIdentifier()

    Bundle_bundlePath ¶

    Bundle_bundlePath :: proc "c" (self: ^Bundle) -> ^String {…}
    bundlePath := bundle->bundlePath()

    Bundle_bundleURL ¶

    Bundle_bundleURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    bundleURL := bundle->bundleURL()

    Bundle_bundleWithPath ¶ class method

    Bundle_bundleWithPath :: proc "c" (path: ^String) -> ^Bundle {…}
    bundle := Bundle.bundleWithPath(path)

    Bundle_bundleWithURL ¶ class method

    Bundle_bundleWithURL :: proc "c" (url: ^URL) -> ^Bundle {…}
    bundle := Bundle.bundleWithURL(url)

    Bundle_executablePath ¶

    Bundle_executablePath :: proc "c" (self: ^Bundle) -> ^String {…}
    executablePath := bundle->executablePath()

    Bundle_executableURL ¶

    Bundle_executableURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    executableURL := bundle->executableURL()

    Bundle_infoDictionary ¶

    Bundle_infoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {…}
    infoDictionary := bundle->infoDictionary()

    Bundle_init ¶

    Bundle_init :: proc "c" (self: ^Bundle) -> ^Bundle {…}
    res := bundle->init()

    Bundle_initWithPath ¶

    Bundle_initWithPath :: proc "c" (self: ^Bundle, path: ^String) -> ^Bundle {…}
    res := bundle->initWithPath(path)

    Bundle_initWithURL ¶

    Bundle_initWithURL :: proc "c" (self: ^Bundle, url: ^URL) -> ^Bundle {…}
    res := bundle->initWithURL(url)

    Bundle_isLoaded ¶

    Bundle_isLoaded :: proc "c" (self: ^Bundle) -> bool {…}
    isLoaded := bundle->isLoaded()

    Bundle_load ¶

    Bundle_load :: proc "c" (self: ^Bundle) -> bool {…}
    load := bundle->load()

    Bundle_loadAndReturnError ¶

    Bundle_loadAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}
    ok, error := bundle->loadAndReturnError()

    Bundle_localizedInfoDictionary ¶

    Bundle_localizedInfoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {…}
    localizedInfoDictionary := bundle->localizedInfoDictionary()

    Bundle_localizedStringForKey ¶

    Bundle_localizedStringForKey :: proc "c" (
    	self:      ^Bundle, 
    	key:       ^String, 
    	value:     ^String = nil, 
    	tableName: ^String = nil, 
    ) -> ^String {…}
    str := bundle->localizedStringForKey(key, value, tableName)

    Bundle_mainBundle ¶ class method

    Bundle_mainBundle :: proc "c" () -> ^Bundle {…}
    bundle := Bundle.mainBundle()

    Bundle_objectForInfoDictionaryKey ¶

    Bundle_objectForInfoDictionaryKey :: proc "c" (self: ^Bundle, key: ^String) -> ^Object {…}
    object := bundle->objectForInfoDictionaryKey(key)

    Bundle_preflightAndReturnError ¶

    Bundle_preflightAndReturnError :: proc "contextless" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}
    ok, error := bundle->preflightAndReturnError()

    Bundle_privateFrameworksPath ¶

    Bundle_privateFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {…}
    privateFrameworksPath := bundle->privateFrameworksPath()

    Bundle_privateFrameworksURL ¶

    Bundle_privateFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    privateFrameworksURL := bundle->privateFrameworksURL()

    Bundle_resourcePath ¶

    Bundle_resourcePath :: proc "c" (self: ^Bundle) -> ^String {…}
    resourcePath := bundle->resourcePath()

    Bundle_resourceURL ¶

    Bundle_resourceURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    resourceURL := bundle->resourceURL()

    Bundle_sharedFrameworksPath ¶

    Bundle_sharedFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {…}
    sharedFrameworksPath := bundle->sharedFrameworksPath()

    Bundle_sharedFrameworksURL ¶

    Bundle_sharedFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    sharedFrameworksURL := bundle->sharedFrameworksURL()

    Bundle_sharedSupportPath ¶

    Bundle_sharedSupportPath :: proc "c" (self: ^Bundle) -> ^String {…}
    sharedSupportPath := bundle->sharedSupportPath()

    Bundle_sharedSupportURL ¶

    Bundle_sharedSupportURL :: proc "c" (self: ^Bundle) -> ^URL {…}
    sharedSupportURL := bundle->sharedSupportURL()

    Bundle_unload ¶

    Bundle_unload :: proc "c" (self: ^Bundle) -> bool {…}
    unload := bundle->unload()

    ClassFromString ¶
    C · NSClassFromStringSource · NSString.odin:62

    ClassFromString :: proc "c" (str: ^String) -> ^intrinsics.objc_class ---

    Color_blackColor ¶ class method

    Color_blackColor :: proc "c" () -> ^Color {…}
    color := Color.blackColor()

    Color_blueColor ¶ class method

    Color_blueColor :: proc "c" () -> ^Color {…}
    color := Color.blueColor()

    Color_colorSpace ¶

    Color_colorSpace :: proc "c" (self: ^Color) -> ^ColorSpace {…}
    colorSpace := color->colorSpace()

    Color_colorSpaceName ¶

    Color_colorSpaceName :: proc "c" (self: ^Color) -> ^String {…}
    colorSpaceName := color->colorSpaceName()

    Color_colorUsingColorSpaceName ¶

    Color_colorUsingColorSpaceName :: proc "c" (
    	self:       ^Color, 
    	colorSpace: ^String, 
    	device:     ^Dictionary = nil, 
    ) -> ^Color {…}
    res := color->colorUsingColorSpaceName(colorSpace, device)

    Color_colorWithCalibratedHue ¶ class method

    Color_colorWithCalibratedHue :: proc "c" (
    	hue, saturation, brightness, 
    	alpha:                       CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithCalibratedHue(hue, saturation, brightness, alpha)

    Color_colorWithCalibratedRed ¶ class method

    Color_colorWithCalibratedRed :: proc "c" (
    	red, green, blue, 
    	alpha:            CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithCalibratedRed(red, green, blue, alpha)

    Color_colorWithCalibratedWhite ¶ class method

    Color_colorWithCalibratedWhite :: proc "c" (white, alpha: CoreFoundation.CGFloat) -> ^Color {…}
    color := Color.colorWithCalibratedWhite(white, alpha)

    Color_colorWithColorSpace ¶ class method

    Color_colorWithColorSpace :: proc "c" (
    	space:      ^ColorSpace, 
    	components: []CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithColorSpace(space, components)

    Color_colorWithDeviceCyan ¶ class method

    Color_colorWithDeviceCyan :: proc "c" (
    	cyan, magenta, yellow, black, 
    	alpha:                        CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithDeviceCyan(cyan, magenta, yellow, black, alpha)

    Color_colorWithDeviceHue ¶ class method

    Color_colorWithDeviceHue :: proc "c" (
    	hue, saturation, brightness, 
    	alpha:                       CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithDeviceHue(hue, saturation, brightness, alpha)

    Color_colorWithDeviceRed ¶ class method

    Color_colorWithDeviceRed :: proc "c" (
    	red, green, blue, 
    	alpha:            CoreFoundation.CGFloat, 
    ) -> ^Color {…}
    color := Color.colorWithDeviceRed(red, green, blue, alpha)

    Color_colorWithDeviceWhite ¶ class method

    Color_colorWithDeviceWhite :: proc "c" (white, alpha: CoreFoundation.CGFloat) -> ^Color {…}
    color := Color.colorWithDeviceWhite(white, alpha)

    Color_colorWithSRGBRed ¶ class method

    Color_colorWithSRGBRed :: proc "c" (red, green, blue, alpha: CoreFoundation.CGFloat) -> ^Color {…}
    color := Color.colorWithSRGBRed(red, green, blue, alpha)

    Color_cyanColor ¶ class method

    Color_cyanColor :: proc "c" () -> ^Color {…}
    color := Color.cyanColor()

    Color_getCMYKA ¶

    Color_getCMYKA :: proc "c" (self: ^Color) -> (cyan, magenta, yellow, black, alpha: CoreFoundation.CGFloat) {…}
    cyan, magenta, yellow, black, alpha := color->getCMYKA()

    Color_getComponents ¶

    Color_getComponents :: proc "c" (self: ^Color, components: [^]CoreFoundation.CGFloat) {…}
    color->getComponents(components)

    Color_getHSBA ¶

    Color_getHSBA :: proc "c" (self: ^Color) -> (hue, saturation, brightness, alpha: CoreFoundation.CGFloat) {…}
    hue, saturation, brightness, alpha := color->getHSBA()

    Color_getRGBA ¶

    Color_getRGBA :: proc "c" (self: ^Color) -> (red, green, blue, alpha: CoreFoundation.CGFloat) {…}
    red, green, blue, alpha := color->getRGBA()

    Color_getWhiteAlpha ¶

    Color_getWhiteAlpha :: proc "c" (self: ^Color) -> (white, alpha: CoreFoundation.CGFloat) {…}
    white, alpha := color->getWhiteAlpha()

    Color_greenColor ¶ class method

    Color_greenColor :: proc "c" () -> ^Color {…}
    color := Color.greenColor()

    Color_magentaColor ¶ class method

    Color_magentaColor :: proc "c" () -> ^Color {…}
    color := Color.magentaColor()

    Color_numberOfComponents ¶

    Color_numberOfComponents :: proc "c" (self: ^Color) -> Integer {…}
    numberOfComponents := color->numberOfComponents()

    Color_orangeColor ¶ class method

    Color_orangeColor :: proc "c" () -> ^Color {…}
    color := Color.orangeColor()

    Color_purpleColor ¶ class method

    Color_purpleColor :: proc "c" () -> ^Color {…}
    color := Color.purpleColor()

    Color_redColor ¶ class method

    Color_redColor :: proc "c" () -> ^Color {…}
    color := Color.redColor()

    Color_whiteColor ¶ class method

    Color_whiteColor :: proc "c" () -> ^Color {…}
    color := Color.whiteColor()

    Color_yellowColor ¶ class method

    Color_yellowColor :: proc "c" () -> ^Color {…}
    color := Color.yellowColor()

    Condition_alloc ¶ class method owned

    Condition_alloc :: proc "c" () -> ^Condition {…}
    condition := Condition.alloc()

    Condition_broadcast ¶

    Condition_broadcast :: proc "c" (self: ^Condition) {…}
    condition->broadcast()

    Condition_init ¶

    Condition_init :: proc "c" (self: ^Condition) -> ^Condition {…}
    res := condition->init()

    Condition_lock ¶

    Condition_lock :: proc "c" (self: ^Condition) {…}
    condition->lock()

    Condition_signal ¶

    Condition_signal :: proc "c" (self: ^Condition) {…}
    condition->signal()

    Condition_unlock ¶

    Condition_unlock :: proc "c" (self: ^Condition) {…}
    condition->unlock()

    Condition_wait ¶

    Condition_wait :: proc "c" (self: ^Condition) {…}
    condition->wait()

    Condition_waitUntilDate ¶

    Condition_waitUntilDate :: proc "c" (self: ^Condition, limit: ^Date) -> bool {…}
    res := condition->waitUntilDate(limit)

    Cursor_IBeamCursor ¶ class method

    Cursor_IBeamCursor :: proc "c" () -> ^Cursor {…}
    cursor := Cursor.IBeamCursor()

    Cursor_alloc ¶ class method owned

    Cursor_alloc :: proc "c" () -> ^Cursor {…}
    cursor := Cursor.alloc()

    Cursor_arrowCursor ¶ class method

    Cursor_arrowCursor :: proc "c" () -> ^Cursor {…}
    cursor := Cursor.arrowCursor()

    Cursor_currentCursor ¶ class method

    Cursor_currentCursor :: proc "c" () -> ^Cursor {…}
    cursor := Cursor.currentCursor()

    Cursor_hide ¶ class method

    Cursor_hide :: proc() {…}
    Cursor.hide()

    Cursor_initWithImage ¶

    Cursor_initWithImage :: proc "c" (
    	self:    ^Cursor, 
    	image:   ^Image, 
    	hotSpot: CoreFoundation.CGPoint, 
    ) -> ^Cursor {…}
    res := cursor->initWithImage(image, hotSpot)

    Cursor_pointingHandCursor ¶ class method

    Cursor_pointingHandCursor :: proc "c" () -> ^Cursor {…}
    cursor := Cursor.pointingHandCursor()

    Cursor_set ¶

    Cursor_set :: proc(self: ^Cursor) {…}
    cursor->set()

    Cursor_setHiddenUntilMouseMoves ¶ class method

    Cursor_setHiddenUntilMouseMoves :: proc(flag: bool) {…}
    Cursor.setHiddenUntilMouseMoves(flag)

    Cursor_unhide ¶ class method

    Cursor_unhide :: proc() {…}
    Cursor.unhide()

    Data_alloc ¶ class method owned

    Data_alloc :: proc "c" () -> ^Data {…}
    data := Data.alloc()

    Data_init ¶

    Data_init :: proc "c" (self: ^Data) -> ^Data {…}
    res := data->init()

    Data_initWithBytes ¶

    Data_initWithBytes :: proc "c" (self: ^Data, bytes: []u8) -> ^Data {…}
    res := data->initWithBytes(bytes)

    Data_initWithBytesNoCopy ¶

    Data_initWithBytesNoCopy :: proc "c" (self: ^Data, bytes: []u8, freeWhenDone: bool) -> ^Data {…}
    res := data->initWithBytesNoCopy(bytes, freeWhenDone)

    Data_length ¶

    Data_length :: proc "c" (self: ^Data) -> UInteger {…}
    length := data->length()

    Data_mutableBytes ¶

    Data_mutableBytes :: proc "c" (self: ^Data) -> rawptr {…}
    mutableBytes := data->mutableBytes()

    Date_alloc ¶ class method owned

    Date_alloc :: proc "c" () -> ^Date {…}
    date := Date.alloc()

    Date_dateWithTimeIntervalSinceNow ¶

    Date_dateWithTimeIntervalSinceNow :: proc "c" (secs: TimeInterval) -> ^Date {…}
    dateWithTimeIntervalSinceNow := date->dateWithTimeIntervalSinceNow()

    Date_distantFuture ¶ class method

    Date_distantFuture :: proc "c" () -> ^Date {…}
    date := Date.distantFuture()

    Date_distantPast ¶ class method

    Date_distantPast :: proc "c" () -> ^Date {…}
    date := Date.distantPast()

    Date_init ¶

    Date_init :: proc "c" (self: ^Date) -> ^Date {…}
    res := date->init()

    Date_timeIntervalSince1970 ¶

    Date_timeIntervalSince1970 :: proc "c" (self: ^Date) -> f64 {…}
    timeIntervalSince1970 := date->timeIntervalSince1970()

    DeallocateObject ¶
    C · NSDeallocateObjectSource · objc.odin:102

    DeallocateObject :: proc "c" (object: ^intrinsics.objc_object) ---

    Dictionary_alloc ¶ class method owned

    Dictionary_alloc :: proc "c" () -> ^Dictionary {…}
    dictionary := Dictionary.alloc()

    Dictionary_count ¶

    Dictionary_count :: proc "c" (self: ^Dictionary) -> UInteger {…}
    count := dictionary->count()

    Dictionary_dictionary ¶ class method

    Dictionary_dictionary :: proc "c" () -> ^Dictionary {…}
    dictionary := Dictionary.dictionary()

    Dictionary_dictionaryWithObject ¶ class method

    Dictionary_dictionaryWithObject :: proc "c" (object: ^Object, forKey: ^Object) -> ^Dictionary {…}
    dictionary := Dictionary.dictionaryWithObject(object, forKey)

    Dictionary_dictionaryWithObjects ¶ class method

    Dictionary_dictionaryWithObjects :: proc "c" (
    	objects: [^]^Object, 
    	forKeys: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Dictionary {…}
    dictionary := Dictionary.dictionaryWithObjects(objects, forKeys, count)

    Dictionary_init ¶

    Dictionary_init :: proc "c" (self: ^Dictionary) -> ^Dictionary {…}
    res := dictionary->init()

    Dictionary_initWithObjects ¶

    Dictionary_initWithObjects :: proc "c" (
    	self:    ^Dictionary, 
    	objects: [^]^Object, 
    	forKeys: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Dictionary {…}
    res := dictionary->initWithObjects(objects, forKeys, count)

    Dictionary_keyEnumerator ¶

    Dictionary_keyEnumerator :: proc "c" (
    	self:    ^Dictionary, 
    	$KeyType: typeid, 
    ) -> (enumerator: ^Enumerator(KeyType)) {…}
    enumerator := dictionary->keyEnumerator(KeyType)

    Dictionary_objectForKey ¶

    Dictionary_objectForKey :: proc "c" (self: ^Dictionary, key: ^Object) -> ^Object {…}
    object := dictionary->objectForKey(key)

    Enumerator_allObjects ¶

    Enumerator_allObjects :: proc "c" (self: ^$E/Enumerator($T)) -> (all: ^Array) {…}

    Enumerator_iterator ¶

    Enumerator_iterator :: proc "contextless" (self: ^$E/Enumerator($T)) -> (obj: T, ok: bool) {…}

    Enumerator_nextObject ¶

    Enumerator_nextObject :: proc "c" (self: ^$E/Enumerator($T)) -> T {…}

    Error_alloc ¶ class method owned

    Error_alloc :: proc "c" () -> ^Error {…}
    error := Error.alloc()

    Error_code ¶

    Error_code :: proc "c" (self: ^Error) -> Integer {…}
    code := error->code()

    Error_domain ¶

    Error_domain :: proc "c" (self: ^Error) -> ^String {…}
    domain := error->domain()

    Error_errorWithDomain ¶ class method

    Error_errorWithDomain :: proc "c" (
    	domain:   ^String, 
    	code:     Integer, 
    	userInfo: ^Dictionary, 
    ) -> ^Error {…}
    error := Error.errorWithDomain(domain, code, userInfo)

    Error_init ¶

    Error_init :: proc "c" (self: ^Error) -> ^Error {…}
    res := error->init()

    Error_initWithDomain ¶

    Error_initWithDomain :: proc "c" (
    	self:     ^Error, 
    	domain:   ^String, 
    	code:     Integer, 
    	userInfo: ^Dictionary, 
    ) -> ^Error {…}
    res := error->initWithDomain(domain, code, userInfo)

    Error_localizedDescription ¶

    Error_localizedDescription :: proc "c" (self: ^Error) -> ^String {…}
    localizedDescription := error->localizedDescription()

    Error_localizedFailureReason ¶

    Error_localizedFailureReason :: proc "c" (self: ^Error) -> ^String {…}
    localizedFailureReason := error->localizedFailureReason()

    Error_localizedRecoveryOptions ¶

    Error_localizedRecoveryOptions :: proc "c" (self: ^Error) -> (options: ^Array) {…}
    options := error->localizedRecoveryOptions()

    Error_localizedRecoverySuggestion ¶

    Error_localizedRecoverySuggestion :: proc "c" (self: ^Error) -> ^String {…}
    localizedRecoverySuggestion := error->localizedRecoverySuggestion()

    Error_userInfo ¶

    Error_userInfo :: proc "c" (self: ^Error) -> ^Dictionary {…}
    userInfo := error->userInfo()

    Event_absolute ¶

    Event_absolute :: proc "c" (self: ^Event) -> (x, y, z: Integer) {…}
    x, y, z := event->absolute()

    Event_absoluteX ¶

    Event_absoluteX :: proc "c" (self: ^Event) -> Integer {…}
    absoluteX := event->absoluteX()

    Event_absoluteY ¶

    Event_absoluteY :: proc "c" (self: ^Event) -> Integer {…}
    absoluteY := event->absoluteY()

    Event_absoluteZ ¶

    Event_absoluteZ :: proc "c" (self: ^Event) -> Integer {…}
    absoluteZ := event->absoluteZ()

    Event_buttonMask ¶

    Event_buttonMask :: proc "c" (self: ^Event) -> UInteger {…}
    buttonMask := event->buttonMask()

    Event_buttonNumber ¶

    Event_buttonNumber :: proc "c" (self: ^Event) -> Integer {…}
    buttonNumber := event->buttonNumber()
     

    for NSOtherMouse events, but will return valid constants for NSLeftMouse and NSRightMouse

    Event_capabilityMask ¶

    Event_capabilityMask :: proc "c" (self: ^Event) -> UInteger {…}
    capabilityMask := event->capabilityMask()

    Event_characters ¶

    Event_characters :: proc "c" (self: ^Event) -> ^String {…}
    characters := event->characters()

    Event_charactersIgnoringModifiers ¶

    Event_charactersIgnoringModifiers :: proc "c" (self: ^Event) -> ^String {…}
    charactersIgnoringModifiers := event->charactersIgnoringModifiers()

    Event_clickCount ¶

    Event_clickCount :: proc "c" (self: ^Event) -> Integer {…}
    clickCount := event->clickCount()

    Event_data1 ¶

    Event_data1 :: proc "c" (self: ^Event) -> Integer {…}
    data1 := event->data1()

    Event_data2 ¶

    Event_data2 :: proc "c" (self: ^Event) -> Integer {…}
    data2 := event->data2()

    Event_delta ¶

    Event_delta :: proc "c" (self: ^Event) -> (x, y, z: CoreFoundation.CGFloat) {…}
    x, y, z := event->delta()

    Event_deltaX ¶

    Event_deltaX :: proc "c" (self: ^Event) -> CoreFoundation.CGFloat {…}
    deltaX := event->deltaX()

    Event_deltaY ¶

    Event_deltaY :: proc "c" (self: ^Event) -> CoreFoundation.CGFloat {…}
    deltaY := event->deltaY()

    Event_deltaZ ¶

    Event_deltaZ :: proc "c" (self: ^Event) -> CoreFoundation.CGFloat {…}
    deltaZ := event->deltaZ()

    Event_eventNumber ¶

    Event_eventNumber :: proc "c" (self: ^Event) -> Integer {…}
    eventNumber := event->eventNumber()
     

    these messages are valid for all mouse down/up/drag and enter/exit events

    Event_hasPreciseScrollingDeltas ¶

    Event_hasPreciseScrollingDeltas :: proc "c" (self: ^Event) -> bool {…}
    hasPreciseScrollingDeltas := event->hasPreciseScrollingDeltas()

    Event_isARepeat ¶

    Event_isARepeat :: proc "c" (self: ^Event) -> bool {…}
    isARepeat := event->isARepeat()

    Event_isDirectionInvertedFromDevice ¶

    Event_isDirectionInvertedFromDevice :: proc "c" (self: ^Event) -> bool {…}
    isDirectionInvertedFromDevice := event->isDirectionInvertedFromDevice()

    Event_isEnteringProximity ¶

    Event_isEnteringProximity :: proc "c" (self: ^Event) -> bool {…}
    isEnteringProximity := event->isEnteringProximity()

    Event_isSwipeTrackingFromScrollEventsEnabled ¶

    Event_isSwipeTrackingFromScrollEventsEnabled :: proc "c" (self: ^Event) -> bool {…}
    isSwipeTrackingFromScrollEventsEnabled := event->isSwipeTrackingFromScrollEventsEnabled()

    Event_keyCode ¶

    Event_keyCode :: proc "c" (self: ^Event) -> u16 {…}
    keyCode := event->keyCode()

    Event_locationInWindow ¶

    Event_locationInWindow :: proc "c" (self: ^Event) -> CoreFoundation.CGPoint {…}
    locationInWindow := event->locationInWindow()
     

    -locationInWindow is valid for all mouse-related events

    Event_modifierFlags ¶

    Event_modifierFlags :: proc "c" (self: ^Event) -> EventModifierFlags {…}
    modifierFlags := event->modifierFlags()

    Event_momentumPhase ¶

    Event_momentumPhase :: proc "c" (self: ^Event) -> EventPhase {…}
    momentumPhase := event->momentumPhase()

    Event_mouseLocation ¶ class method

    Event_mouseLocation :: proc "c" () -> CoreFoundation.CGPoint {…}
    cgPoint := Event.mouseLocation()

    Event_otherEventWithType ¶ class method

    Event_otherEventWithType :: proc "c" (
    	type:          EventType, 
    	location:      CoreFoundation.CGPoint, 
    	flags:         EventModifierFlags, 
    	time:          TimeInterval, 
    	window_number: Integer, 
    	ctx:           ^intrinsics.objc_object, 
    	subtype:       i16, 
    	data1:         Integer, 
    	data2:         Integer, 
    ) -> ^Event {…}
    event := Event.otherEventWithType(
    	type,
    	location,
    	flags,
    	time,
    	window_number,
    	ctx,
    	subtype,
    	data1,
    	data2,
    )

    Event_phase ¶

    Event_phase :: proc "c" (self: ^Event) -> EventPhase {…}
    phase := event->phase()

    Event_pointingDeviceID ¶

    Event_pointingDeviceID :: proc "c" (self: ^Event) -> UInteger {…}
    pointingDeviceID := event->pointingDeviceID()

    Event_pointingDeviceSerialNumber ¶

    Event_pointingDeviceSerialNumber :: proc "c" (self: ^Event) -> UInteger {…}
    pointingDeviceSerialNumber := event->pointingDeviceSerialNumber()

    Event_pointingDeviceType ¶

    Event_pointingDeviceType :: proc "c" (self: ^Event) -> PointingDeviceType {…}
    pointingDeviceType := event->pointingDeviceType()

    Event_pressure ¶

    Event_pressure :: proc "c" (self: ^Event) -> f32 {…}
    pressure := event->pressure()
     

    -pressure is valid for all mouse down/up/drag events, and is also valid for NSTabletPoint events on 10.4 or later

    Event_scrollingDelta ¶

    Event_scrollingDelta :: proc "c" (self: ^Event) -> (x, y: CoreFoundation.CGFloat) {…}
    x, y := event->scrollingDelta()

    Event_scrollingDeltaX ¶

    Event_scrollingDeltaX :: proc "c" (self: ^Event) -> CoreFoundation.CGFloat {…}
    scrollingDeltaX := event->scrollingDeltaX()

    Event_scrollingDeltaY ¶

    Event_scrollingDeltaY :: proc "c" (self: ^Event) -> CoreFoundation.CGFloat {…}
    scrollingDeltaY := event->scrollingDeltaY()

    Event_subtype ¶

    Event_subtype :: proc "c" (self: ^Event) -> i16 {…}
    subtype := event->subtype()

    Event_systemTabletID ¶

    Event_systemTabletID :: proc "c" (self: ^Event) -> UInteger {…}
    systemTabletID := event->systemTabletID()

    Event_tabletID ¶

    Event_tabletID :: proc "c" (self: ^Event) -> UInteger {…}
    tabletID := event->tabletID()

    Event_tangentialPressure ¶

    Event_tangentialPressure :: proc "c" (self: ^Event) -> f32 {…}
    tangentialPressure := event->tangentialPressure()

    Event_timestamp ¶

    Event_timestamp :: proc "c" (self: ^Event) -> TimeInterval {…}
    timestamp := event->timestamp()

    Event_type ¶

    Event_type :: proc "c" (self: ^Event) -> EventType {…}
    type := event->type()

    Event_uniqueID ¶

    Event_uniqueID :: proc "c" (self: ^Event) -> u64 {…}
    uniqueID := event->uniqueID()

    Event_vendorDefined ¶

    Event_vendorDefined :: proc "c" (self: ^Event) -> ^intrinsics.objc_object {…}
    vendorDefined := event->vendorDefined()

    Event_vendorID ¶

    Event_vendorID :: proc "c" (self: ^Event) -> UInteger {…}
    vendorID := event->vendorID()

    Event_vendorPointingDeviceType ¶

    Event_vendorPointingDeviceType :: proc "c" (self: ^Event) -> UInteger {…}
    vendorPointingDeviceType := event->vendorPointingDeviceType()

    Event_window ¶

    Event_window :: proc "c" (self: ^Event) -> ^Window {…}
    window := event->window()

    Event_windowNumber ¶

    Event_windowNumber :: proc "c" (self: ^Event) -> UInteger {…}
    windowNumber := event->windowNumber()

    FastEnumeration_alloc ¶ class method owned

    FastEnumeration_alloc :: proc "c" () -> ^FastEnumeration {…}
    fastEnumeration := FastEnumeration.alloc()

    FastEnumeration_countByEnumerating ¶

    FastEnumeration_countByEnumerating :: proc "c" (
    	self:   ^FastEnumeration, 
    	state:  ^FastEnumerationState, 
    	buffer: [^]^Object, 
    	len:    UInteger, 
    ) -> UInteger {…}
    uInteger := fastEnumeration->countByEnumerating(state, buffer, len)

    FastEnumeration_init ¶

    FastEnumeration_init :: proc "c" (self: ^FastEnumeration) -> ^FastEnumeration {…}
    res := fastEnumeration->init()

    Image_addRepresentation ¶

    Image_addRepresentation :: proc(self: ^Image, rep: ^ImageRep) {…}
    image->addRepresentation(rep)

    Image_alloc ¶ class method owned

    Image_alloc :: proc "c" () -> ^Image {…}
    image := Image.alloc()

    Image_initWithSize ¶

    Image_initWithSize :: proc "c" (self: ^Image, size: CoreFoundation.CGSize) -> ^Image {…}
    res := image->initWithSize(size)

    Layer_addSublayer ¶

    Layer_addSublayer :: proc "c" (self: ^Layer, layer: ^Layer) {…}
    layer->addSublayer(layer)

    Layer_contents ¶

    Layer_contents :: proc "c" (self: ^Layer) -> rawptr {…}
    contents := layer->contents()

    Layer_contentsScale ¶

    Layer_contentsScale :: proc "c" (self: ^Layer) -> CoreFoundation.CGFloat {…}
    contentsScale := layer->contentsScale()

    Layer_frame ¶

    Layer_frame :: proc "c" (self: ^Layer) -> CoreFoundation.CGRect {…}
    frame := layer->frame()

    Layer_position ¶

    Layer_position :: proc "c" (self: ^Layer) -> CoreFoundation.CGPoint {…}
    position := layer->position()

    Layer_setContents ¶

    Layer_setContents :: proc "c" (self: ^Layer, contents: rawptr) {…}
    layer->setContents(contents)

    Layer_setContentsScale ¶

    Layer_setContentsScale :: proc "c" (self: ^Layer, scale: CoreFoundation.CGFloat) {…}
    layer->setContentsScale(scale)

    Layer_setPosition ¶

    Layer_setPosition :: proc "c" (self: ^Layer, position: CoreFoundation.CGPoint) {…}
    layer->setPosition(position)

    Locking_lock ¶

    Locking_lock :: proc "c" (self: ^Locking($T)) {…}

    Locking_unlock ¶

    Locking_unlock :: proc "c" (self: ^Locking($T)) {…}

    MakeConstantString ¶

    MakeConstantString :: proc "c" (#const c: cstring) -> ^String {…}
     

    CFString is 'toll-free bridged' with its Cocoa Foundation counterpart, NSString.

    External examples metal/learn_metal/02-argbuffers-no-sdl

    MaxX ¶

    MaxX :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}

    MaxY ¶

    MaxY :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}
    MenuDelegate_confinementRectForMenu :: proc "c" (
    	self:   ^MenuDelegate, 
    	menu:   ^Menu, 
    	screen: ^Screen, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := menuDelegate->confinementRectForMenu(menu, screen)
    MenuDelegate_menuDidClose :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}
    menuDelegate->menuDidClose(menu)
    MenuDelegate_menuHasKeyEquivalent :: proc "c" (
    	self:   ^MenuDelegate, 
    	menu:   ^Menu, 
    	event:  ^Event, 
    	target: ^^intrinsics.objc_object, 
    	action: ^^intrinsics.objc_selector, 
    ) -> bool {…}
    res := menuDelegate->menuHasKeyEquivalent(menu, event, target, action)
    MenuDelegate_menuNeedsUpdate :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}
    menuDelegate->menuNeedsUpdate(menu)
    MenuDelegate_menuWillOpen :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}
    menuDelegate->menuWillOpen(menu)
    MenuDelegate_menu_updateItem_atIndex_shouldCancel :: proc "c" (
    	self:         ^MenuDelegate, 
    	menu:         ^Menu, 
    	item:         ^MenuItem, 
    	index:        Integer, 
    	shouldCancel: bool, 
    ) -> bool {…}
    res := menuDelegate->menu_updateItem_atIndex_shouldCancel(menu, item, index, shouldCancel)
    MenuDelegate_menu_willHighlightItem :: proc "c" (
    	self: ^MenuDelegate, 
    	menu: ^Menu, 
    	item: ^MenuItem, 
    ) {…}
    menuDelegate->menu_willHighlightItem(menu, item)
    MenuDelegate_numberOfItemsInMenu :: proc "c" (self: ^MenuDelegate, menu: ^Menu) -> Integer {…}
    integer := menuDelegate->numberOfItemsInMenu(menu)
    MenuItem_accessInstanceVariablesDirectly :: proc "c" () -> bool {…}
    res := MenuItem.accessInstanceVariablesDirectly()
    MenuItem_action :: proc "c" (self: ^MenuItem) -> ^intrinsics.objc_selector {…}
    action := menuItem->action()
    MenuItem_alloc :: proc "c" () -> ^MenuItem {…}
    menuItem := MenuItem.alloc()
    MenuItem_allocWithZone :: proc "c" (zone: ^Zone) -> ^MenuItem {…}
    menuItem := MenuItem.allocWithZone(zone)
    MenuItem_allowsAutomaticKeyEquivalentLocalization :: proc "c" (self: ^MenuItem) -> bool {…}
    allowsAutomaticKeyEquivalentLocalization := menuItem->allowsAutomaticKeyEquivalentLocalization()
    MenuItem_allowsAutomaticKeyEquivalentMirroring :: proc "c" (self: ^MenuItem) -> bool {…}
    allowsAutomaticKeyEquivalentMirroring := menuItem->allowsAutomaticKeyEquivalentMirroring()
    MenuItem_allowsKeyEquivalentWhenHidden :: proc "c" (self: ^MenuItem) -> bool {…}
    allowsKeyEquivalentWhenHidden := menuItem->allowsKeyEquivalentWhenHidden()
    MenuItem_automaticallyNotifiesObserversForKey :: proc "c" (key: ^String) -> bool {…}
    res := MenuItem.automaticallyNotifiesObserversForKey(key)
    MenuItem_cancelPreviousPerformRequestsWithTarget_ :: proc "c" (aTarget: ^intrinsics.objc_object) {…}
    MenuItem.cancelPreviousPerformRequestsWithTarget_(aTarget)
    MenuItem_cancelPreviousPerformRequestsWithTarget_selector_object :: proc "c" (
    	aTarget:    ^intrinsics.objc_object, 
    	aSelector:  ^intrinsics.objc_selector, 
    	anArgument: ^intrinsics.objc_object, 
    ) {…}
    MenuItem.cancelPreviousPerformRequestsWithTarget_selector_object(aTarget, aSelector, anArgument)
    MenuItem_class :: proc "c" () -> ^intrinsics.objc_class {…}
    res := MenuItem.class()
    MenuItem_classFallbacksForKeyedArchiver :: proc "c" () -> ^Array {…}
    array := MenuItem.classFallbacksForKeyedArchiver()
    MenuItem_classForKeyedUnarchiver :: proc "c" () -> ^intrinsics.objc_class {…}
    res := MenuItem.classForKeyedUnarchiver()
    MenuItem_conformsToProtocol :: proc "c" (protocol: ^Protocol) -> bool {…}
    res := MenuItem.conformsToProtocol(protocol)
    MenuItem_copyWithZone :: proc "c" (zone: ^Zone) -> ^intrinsics.objc_object {…}
    res := MenuItem.copyWithZone(zone)
    MenuItem_debugDescription :: proc "c" () -> ^String {…}
    str := MenuItem.debugDescription()
    MenuItem_defaultPlaceholderForMarker :: proc "c" (
    	marker:  ^intrinsics.objc_object, 
    	binding: ^String, 
    ) -> ^intrinsics.objc_object {…}
    res := MenuItem.defaultPlaceholderForMarker(marker, binding)
    MenuItem_description :: proc "c" () -> ^String {…}
    str := MenuItem.description()
    MenuItem_exposeBinding :: proc "c" (binding: ^String) {…}
    MenuItem.exposeBinding(binding)
    MenuItem_hasSubmenu :: proc "c" (self: ^MenuItem) -> bool {…}
    hasSubmenu := menuItem->hasSubmenu()
    MenuItem_hash :: proc "c" () -> UInteger {…}
    uInteger := MenuItem.hash()
    MenuItem_indentationLevel :: proc "c" (self: ^MenuItem) -> Integer {…}
    indentationLevel := menuItem->indentationLevel()
    MenuItem_init :: proc "c" (self: ^MenuItem) -> ^MenuItem {…}
    res := menuItem->init()
    MenuItem_initWithCoder :: proc "c" (self: ^MenuItem, coder: ^Coder) -> ^MenuItem {…}
    res := menuItem->initWithCoder(coder)
    MenuItem_initWithTitle :: proc "c" (
    	self:     ^MenuItem, 
    	string:   ^String, 
    	selector: ^intrinsics.objc_selector, 
    	charCode: ^String, 
    ) -> ^MenuItem {…}
    res := menuItem->initWithTitle(string, selector, charCode)
    MenuItem_initialize :: proc "c" () {…}
    MenuItem.initialize()
    MenuItem_instanceMethodForSelector :: proc "c" (aSelector: ^intrinsics.objc_selector) -> IMP {…}
    imp := MenuItem.instanceMethodForSelector(aSelector)
    MenuItem_instancesRespondToSelector :: proc "c" (aSelector: ^intrinsics.objc_selector) -> bool {…}
    res := MenuItem.instancesRespondToSelector(aSelector)
    MenuItem_isAlternate :: proc "c" (self: ^MenuItem) -> bool {…}
    isAlternate := menuItem->isAlternate()
    MenuItem_isEnabled :: proc "c" (self: ^MenuItem) -> bool {…}
    isEnabled := menuItem->isEnabled()
     

    MenuItem_image :: #force_inline proc "c" (self: ^MenuItem) -> ^Image {

    return msgSend(^Image, self, "image")
    

    } MenuItem_setImage :: #force_inline proc "c" (self: ^MenuItem, image: ^Image) {

    msgSend(nil, self, "setImage:", image)
    

    } MenuItem_state :: #force_inline proc "c" (self: ^MenuItem) -> ControlStateValue {

    return msgSend(ControlStateValue, self, "state")
    

    } MenuItem_setState :: #force_inline proc "c" (self: ^MenuItem, state: ControlStateValue) {

    msgSend(nil, self, "setState:", state)
    

    } MenuItem_onStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image {

    return msgSend(^Image, self, "onStateImage")
    

    } MenuItem_setOnStateImage :: #force_inline proc "c" (self: ^MenuItem, onStateImage: ^Image) {

    msgSend(nil, self, "setOnStateImage:", onStateImage)
    

    } MenuItem_offStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image {

    return msgSend(^Image, self, "offStateImage")
    

    } MenuItem_setOffStateImage :: #force_inline proc "c" (self: ^MenuItem, offStateImage: ^Image) {

    msgSend(nil, self, "setOffStateImage:", offStateImage)
    

    } MenuItem_mixedStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image {

    return msgSend(^Image, self, "mixedStateImage")
    

    } MenuItem_setMixedStateImage :: #force_inline proc "c" (self: ^MenuItem, mixedStateImage: ^Image) {

    msgSend(nil, self, "setMixedStateImage:", mixedStateImage)
    

    }

    MenuItem_isHidden :: proc "c" (self: ^MenuItem) -> bool {…}
    isHidden := menuItem->isHidden()
    MenuItem_isHiddenOrHasHiddenAncestor :: proc "c" (self: ^MenuItem) -> bool {…}
    isHiddenOrHasHiddenAncestor := menuItem->isHiddenOrHasHiddenAncestor()
    MenuItem_isHighlighted :: proc "c" (self: ^MenuItem) -> bool {…}
    isHighlighted := menuItem->isHighlighted()
    MenuItem_isSectionHeader :: proc "c" (self: ^MenuItem) -> bool {…}
    isSectionHeader := menuItem->isSectionHeader()
    MenuItem_isSeparatorItem :: proc "c" (self: ^MenuItem) -> bool {…}
    isSeparatorItem := menuItem->isSeparatorItem()
    MenuItem_isSubclassOfClass :: proc "c" (aClass: ^intrinsics.objc_class) -> bool {…}
    res := MenuItem.isSubclassOfClass(aClass)
     

    MenuItem_instanceMethodSignatureForSelector :: #force_inline proc "c" (aSelector: SEL) -> ^MethodSignature {

    return msgSend(^MethodSignature, MenuItem, "instanceMethodSignatureForSelector:", aSelector)
    

    }

    MenuItem_keyEquivalent :: proc "c" (self: ^MenuItem) -> ^String {…}
    keyEquivalent := menuItem->keyEquivalent()
    MenuItem_keyEquivalentModifierMask :: proc "c" (self: ^MenuItem) -> EventModifierFlags {…}
    keyEquivalentModifierMask := menuItem->keyEquivalentModifierMask()
    MenuItem_keyPathsForValuesAffectingValueForKey :: proc "c" (key: ^String) -> ^Set {…}
    set := MenuItem.keyPathsForValuesAffectingValueForKey(key)
    MenuItem_load :: proc "c" () {…}
    MenuItem.load()
    MenuItem_menu :: proc "c" (self: ^MenuItem) -> ^Menu {…}
    menu := menuItem->menu()
    MenuItem_mnemonic :: proc "c" (self: ^MenuItem) -> ^String {…}
    mnemonic := menuItem->mnemonic()
    MenuItem_mnemonicLocation :: proc "c" (self: ^MenuItem) -> UInteger {…}
    mnemonicLocation := menuItem->mnemonicLocation()
    MenuItem_mutableCopyWithZone :: proc "c" (zone: ^Zone) -> ^intrinsics.objc_object {…}
    res := MenuItem.mutableCopyWithZone(zone)
    MenuItem_new :: proc "c" () -> ^MenuItem {…}
    menuItem := MenuItem.new()
    MenuItem_parentItem :: proc "c" (self: ^MenuItem) -> ^MenuItem {…}
    parentItem := menuItem->parentItem()
    MenuItem_poseAsClass :: proc "c" (aClass: ^intrinsics.objc_class) {…}
    MenuItem.poseAsClass(aClass)
    MenuItem_registerActionCallback :: proc "c" (
    	name:     cstring, 
    	callback: MenuItemCallback, 
    ) -> ^intrinsics.objc_selector {…}
    res := MenuItem.registerActionCallback(name, callback)
    MenuItem_representedObject :: proc "c" (self: ^MenuItem) -> ^intrinsics.objc_object {…}
    representedObject := menuItem->representedObject()
    MenuItem_resolveClassMethod :: proc "c" (sel: ^intrinsics.objc_selector) -> bool {…}
    res := MenuItem.resolveClassMethod(sel)
    MenuItem_resolveInstanceMethod :: proc "c" (sel: ^intrinsics.objc_selector) -> bool {…}
    res := MenuItem.resolveInstanceMethod(sel)
    MenuItem_sectionHeaderWithTitle :: proc "c" (title: ^String) -> ^MenuItem {…}
    menuItem := MenuItem.sectionHeaderWithTitle(title)
    MenuItem_separatorItem :: proc "c" () -> ^MenuItem {…}
    menuItem := MenuItem.separatorItem()
    MenuItem_setAction :: proc "c" (self: ^MenuItem, action: ^intrinsics.objc_selector) {…}
    menuItem->setAction(action)
    MenuItem_setAllowsAutomaticKeyEquivalentLocalization :: proc "c" (
    	self:                                     ^MenuItem, 
    	allowsAutomaticKeyEquivalentLocalization: bool, 
    ) {…}
    menuItem->setAllowsAutomaticKeyEquivalentLocalization(allowsAutomaticKeyEquivalentLocalization)
    MenuItem_setAllowsAutomaticKeyEquivalentMirroring :: proc "c" (
    	self:                                  ^MenuItem, 
    	allowsAutomaticKeyEquivalentMirroring: bool, 
    ) {…}
    menuItem->setAllowsAutomaticKeyEquivalentMirroring(allowsAutomaticKeyEquivalentMirroring)
    MenuItem_setAllowsKeyEquivalentWhenHidden :: proc "c" (
    	self:                          ^MenuItem, 
    	allowsKeyEquivalentWhenHidden: bool, 
    ) {…}
    menuItem->setAllowsKeyEquivalentWhenHidden(allowsKeyEquivalentWhenHidden)
    MenuItem_setAlternate :: proc "c" (self: ^MenuItem, alternate: bool) {…}
    menuItem->setAlternate(alternate)
    MenuItem_setDefaultPlaceholder :: proc "c" (
    	placeholder: ^intrinsics.objc_object, 
    	marker:      ^intrinsics.objc_object, 
    	binding:     ^String, 
    ) {…}
    MenuItem.setDefaultPlaceholder(placeholder, marker, binding)
    MenuItem_setEnabled :: proc "c" (self: ^MenuItem, enabled: bool) {…}
    menuItem->setEnabled(enabled)
    MenuItem_setHidden :: proc "c" (self: ^MenuItem, hidden: bool) {…}
    menuItem->setHidden(hidden)
    MenuItem_setIndentationLevel :: proc "c" (self: ^MenuItem, indentationLevel: Integer) {…}
    menuItem->setIndentationLevel(indentationLevel)
    MenuItem_setKeyEquivalent :: proc "c" (self: ^MenuItem, keyEquivalent: ^String) {…}
    menuItem->setKeyEquivalent(keyEquivalent)
    MenuItem_setKeyEquivalentModifierMask :: proc "c" (
    	self:                      ^MenuItem, 
    	keyEquivalentModifierMask: EventModifierFlags, 
    ) {…}
    menuItem->setKeyEquivalentModifierMask(keyEquivalentModifierMask)
    MenuItem_setKeys :: proc "c" (keys: ^Array, dependentKey: ^String) {…}
    MenuItem.setKeys(keys, dependentKey)
    MenuItem_setMenu :: proc "c" (self: ^MenuItem, menu: ^Menu) {…}
    menuItem->setMenu(menu)
    MenuItem_setMnemonicLocation :: proc "c" (self: ^MenuItem, location: UInteger) {…}
    menuItem->setMnemonicLocation(location)
     

    MenuItem_badge :: #force_inline proc "c" (self: ^MenuItem) -> ^MenuItemBadge {

    return msgSend(^MenuItemBadge, self, "badge")
    

    } MenuItem_setBadge :: #force_inline proc "c" (self: ^MenuItem, badge: ^MenuItemBadge) {

    msgSend(nil, self, "setBadge:", badge)
    

    }

    MenuItem_setRepresentedObject :: proc "c" (
    	self:              ^MenuItem, 
    	representedObject: ^intrinsics.objc_object, 
    ) {…}
    menuItem->setRepresentedObject(representedObject)
    MenuItem_setSubmenu :: proc "c" (self: ^MenuItem, submenu: ^Menu) {…}
    menuItem->setSubmenu(submenu)
    MenuItem_setSubtitle :: proc "c" (self: ^MenuItem, subtitle: ^String) {…}
    menuItem->setSubtitle(subtitle)
    MenuItem_setTag :: proc "c" (self: ^MenuItem, tag: Integer) {…}
    menuItem->setTag(tag)
    MenuItem_setTarget :: proc "c" (self: ^MenuItem, target: ^intrinsics.objc_object) {…}
    menuItem->setTarget(target)
    MenuItem_setTitle :: proc "c" (self: ^MenuItem, title: ^String) {…}
    menuItem->setTitle(title)
    MenuItem_setTitleWithMnemonic :: proc "c" (self: ^MenuItem, stringWithAmpersand: ^String) {…}
    menuItem->setTitleWithMnemonic(stringWithAmpersand)
    MenuItem_setToolTip :: proc "c" (self: ^MenuItem, toolTip: ^String) {…}
    menuItem->setToolTip(toolTip)
    MenuItem_setUsesUserKeyEquivalents :: proc "c" (usesUserKeyEquivalents: bool) {…}
    MenuItem.setUsesUserKeyEquivalents(usesUserKeyEquivalents)
    MenuItem_setVersion :: proc "c" (aVersion: Integer) {…}
    MenuItem.setVersion(aVersion)
    MenuItem_setView :: proc "c" (self: ^MenuItem, view: ^View) {…}
    menuItem->setView(view)
    MenuItem_submenu :: proc "c" (self: ^MenuItem) -> ^Menu {…}
    submenu := menuItem->submenu()
    MenuItem_subtitle :: proc "c" (self: ^MenuItem) -> ^String {…}
    subtitle := menuItem->subtitle()
     

    MenuItem_attributedTitle :: #force_inline proc "c" (self: ^MenuItem) -> ^AttributedString {

    return msgSend(^AttributedString, self, "attributedTitle")
    

    } MenuItem_setAttributedTitle :: #force_inline proc "c" (self: ^MenuItem, attributedTitle: ^AttributedString) {

    msgSend(nil, self, "setAttributedTitle:", attributedTitle)
    

    }

    MenuItem_superclass :: proc "c" () -> ^intrinsics.objc_class {…}
    res := MenuItem.superclass()
    MenuItem_tag :: proc "c" (self: ^MenuItem) -> Integer {…}
    tag := menuItem->tag()
    MenuItem_target :: proc "c" (self: ^MenuItem) -> ^intrinsics.objc_object {…}
    target := menuItem->target()
    MenuItem_title :: proc "c" (self: ^MenuItem) -> ^String {…}
    title := menuItem->title()
    MenuItem_toolTip :: proc "c" (self: ^MenuItem) -> ^String {…}
    toolTip := menuItem->toolTip()
    MenuItem_useStoredAccessor :: proc "c" () -> bool {…}
    res := MenuItem.useStoredAccessor()
    MenuItem_userKeyEquivalent :: proc "c" (self: ^MenuItem) -> ^String {…}
    userKeyEquivalent := menuItem->userKeyEquivalent()
    MenuItem_usesUserKeyEquivalents :: proc "c" () -> bool {…}
    res := MenuItem.usesUserKeyEquivalents()
    MenuItem_version :: proc "c" () -> Integer {…}
    integer := MenuItem.version()
    MenuItem_view :: proc "c" (self: ^MenuItem) -> ^View {…}
    view := menuItem->view()
    Menu_accessInstanceVariablesDirectly :: proc "c" () -> bool {…}
    res := Menu.accessInstanceVariablesDirectly()
    Menu_addItem :: proc "c" (self: ^Menu, newItem: ^MenuItem) {…}
    menu->addItem(newItem)
    Menu_addItemWithTitle :: proc "c" (
    	self:     ^Menu, 
    	string:   ^String, 
    	selector: ^intrinsics.objc_selector, 
    	charCode: ^String, 
    ) -> ^MenuItem {…}
    menuItem := menu->addItemWithTitle(string, selector, charCode)
    Menu_alloc :: proc "c" () -> ^Menu {…}
    menu := Menu.alloc()
    Menu_allocWithZone :: proc "c" (zone: ^Zone) -> ^Menu {…}
    menu := Menu.allocWithZone(zone)
    Menu_allowsContextMenuPlugIns :: proc "c" (self: ^Menu) -> bool {…}
    allowsContextMenuPlugIns := menu->allowsContextMenuPlugIns()
     

    Menu_font :: #force_inline proc "c" (self: ^Menu) -> ^Font {

    return msgSend(^Font, self, "font")
    

    } Menu_setFont :: #force_inline proc "c" (self: ^Menu, font: ^Font) {

    msgSend(nil, self, "setFont:", font)
    

    }

    Menu_attachedMenu :: proc "c" (self: ^Menu) -> ^Menu {…}
    attachedMenu := menu->attachedMenu()
    Menu_autoenablesItems :: proc "c" (self: ^Menu) -> bool {…}
    autoenablesItems := menu->autoenablesItems()
    Menu_automaticallyNotifiesObserversForKey :: proc "c" (key: ^String) -> bool {…}
    res := Menu.automaticallyNotifiesObserversForKey(key)
    Menu_cancelPreviousPerformRequestsWithTarget_ :: proc "c" (aTarget: ^intrinsics.objc_object) {…}
    Menu.cancelPreviousPerformRequestsWithTarget_(aTarget)
    Menu_cancelPreviousPerformRequestsWithTarget_selector_object :: proc "c" (
    	aTarget:    ^intrinsics.objc_object, 
    	aSelector:  ^intrinsics.objc_selector, 
    	anArgument: ^intrinsics.objc_object, 
    ) {…}
    Menu.cancelPreviousPerformRequestsWithTarget_selector_object(aTarget, aSelector, anArgument)
    Menu_cancelTracking :: proc "c" (self: ^Menu) {…}
    menu->cancelTracking()
    Menu_cancelTrackingWithoutAnimation :: proc "c" (self: ^Menu) {…}
    menu->cancelTrackingWithoutAnimation()
    Menu_class :: proc "c" () -> ^intrinsics.objc_class {…}
    res := Menu.class()
    Menu_classFallbacksForKeyedArchiver :: proc "c" () -> ^Array {…}
    array := Menu.classFallbacksForKeyedArchiver()
    Menu_classForKeyedUnarchiver :: proc "c" () -> ^intrinsics.objc_class {…}
    res := Menu.classForKeyedUnarchiver()
    Menu_conformsToProtocol :: proc "c" (protocol: ^Protocol) -> bool {…}
    res := Menu.conformsToProtocol(protocol)
    Menu_contextMenuRepresentation :: proc "c" (self: ^Menu) -> ^intrinsics.objc_object {…}
    contextMenuRepresentation := menu->contextMenuRepresentation()
    Menu_copyWithZone :: proc "c" (zone: ^Zone) -> ^intrinsics.objc_object {…}
    res := Menu.copyWithZone(zone)
    Menu_debugDescription :: proc "c" () -> ^String {…}
    str := Menu.debugDescription()
    Menu_defaultPlaceholderForMarker :: proc "c" (
    	marker:  ^intrinsics.objc_object, 
    	binding: ^String, 
    ) -> ^intrinsics.objc_object {…}
    res := Menu.defaultPlaceholderForMarker(marker, binding)
    Menu_delegate :: proc "c" (self: ^Menu) -> ^MenuDelegate {…}
    delegate := menu->delegate()
    Menu_description :: proc "c" () -> ^String {…}
    str := Menu.description()
    Menu_exposeBinding :: proc "c" (binding: ^String) {…}
    Menu.exposeBinding(binding)
    Menu_hash :: proc "c" () -> UInteger {…}
    uInteger := Menu.hash()
    Menu_helpRequested :: proc "c" (self: ^Menu, eventPtr: ^Event) {…}
    menu->helpRequested(eventPtr)
    Menu_highlightedItem :: proc "c" (self: ^Menu) -> ^MenuItem {…}
    highlightedItem := menu->highlightedItem()
    Menu_indexOfItem :: proc "c" (self: ^Menu, item: ^MenuItem) -> Integer {…}
    integer := menu->indexOfItem(item)
    Menu_indexOfItemWithRepresentedObject :: proc "c" (
    	self:   ^Menu, 
    	object: ^intrinsics.objc_object, 
    ) -> Integer {…}
    integer := menu->indexOfItemWithRepresentedObject(object)
    Menu_indexOfItemWithSubmenu :: proc "c" (self: ^Menu, submenu: ^Menu) -> Integer {…}
    integer := menu->indexOfItemWithSubmenu(submenu)
    Menu_indexOfItemWithTag :: proc "c" (self: ^Menu, tag: Integer) -> Integer {…}
    integer := menu->indexOfItemWithTag(tag)
    Menu_indexOfItemWithTarget :: proc "c" (
    	self:           ^Menu, 
    	target:         ^intrinsics.objc_object, 
    	actionSelector: ^intrinsics.objc_selector, 
    ) -> Integer {…}
    integer := menu->indexOfItemWithTarget(target, actionSelector)
    Menu_indexOfItemWithTitle :: proc "c" (self: ^Menu, title: ^String) -> Integer {…}
    integer := menu->indexOfItemWithTitle(title)
    Menu_init :: proc "c" (self: ^Menu) -> ^Menu {…}
    res := menu->init()
    Menu_initWithCoder :: proc "c" (self: ^Menu, coder: ^Coder) -> ^Menu {…}
    res := menu->initWithCoder(coder)
    Menu_initWithTitle :: proc "c" (self: ^Menu, title: ^String) -> ^Menu {…}
    res := menu->initWithTitle(title)
    Menu_initialize :: proc "c" () {…}
    Menu.initialize()
    Menu_insertItem :: proc "c" (self: ^Menu, newItem: ^MenuItem, index: Integer) {…}
    menu->insertItem(newItem, index)
    Menu_insertItemWithTitle :: proc "c" (
    	self:     ^Menu, 
    	string:   ^String, 
    	selector: ^intrinsics.objc_selector, 
    	charCode: ^String, 
    	index:    Integer, 
    ) -> ^MenuItem {…}
    menuItem := menu->insertItemWithTitle(string, selector, charCode, index)
    Menu_instanceMethodForSelector :: proc "c" (aSelector: ^intrinsics.objc_selector) -> IMP {…}
    imp := Menu.instanceMethodForSelector(aSelector)
    Menu_instancesRespondToSelector :: proc "c" (aSelector: ^intrinsics.objc_selector) -> bool {…}
    res := Menu.instancesRespondToSelector(aSelector)
    Menu_isAttached :: proc "c" (self: ^Menu) -> bool {…}
    isAttached := menu->isAttached()
    Menu_isSubclassOfClass :: proc "c" (aClass: ^intrinsics.objc_class) -> bool {…}
    res := Menu.isSubclassOfClass(aClass)
     

    Menu_instanceMethodSignatureForSelector :: #force_inline proc "c" (aSelector: SEL) -> ^MethodSignature {

    return msgSend(^MethodSignature, Menu, "instanceMethodSignatureForSelector:", aSelector)
    

    }

    Menu_isTornOff :: proc "c" (self: ^Menu) -> bool {…}
    isTornOff := menu->isTornOff()
    Menu_itemArray :: proc "c" (self: ^Menu) -> ^Array {…}
    itemArray := menu->itemArray()
    Menu_itemAtIndex :: proc "c" (self: ^Menu, index: Integer) -> ^MenuItem {…}
    menuItem := menu->itemAtIndex(index)
    Menu_itemChanged :: proc "c" (self: ^Menu, item: ^MenuItem) {…}
    menu->itemChanged(item)
    Menu_itemWithTag :: proc "c" (self: ^Menu, tag: Integer) -> ^MenuItem {…}
    menuItem := menu->itemWithTag(tag)
    Menu_itemWithTitle :: proc "c" (self: ^Menu, title: ^String) -> ^MenuItem {…}
    menuItem := menu->itemWithTitle(title)
    Menu_keyPathsForValuesAffectingValueForKey :: proc "c" (key: ^String) -> ^Set {…}
    set := Menu.keyPathsForValuesAffectingValueForKey(key)
    Menu_load :: proc "c" () {…}
    Menu.load()
    Menu_locationForSubmenu :: proc "c" (self: ^Menu, submenu: ^Menu) -> CoreFoundation.CGPoint {…}
    cgPoint := menu->locationForSubmenu(submenu)
    Menu_menuBarHeight :: proc "c" (self: ^Menu) -> CoreFoundation.CGFloat {…}
    menuBarHeight := menu->menuBarHeight()
    Menu_menuBarVisible :: proc "c" () -> bool {…}
    res := Menu.menuBarVisible()
    Menu_menuChangedMessagesEnabled :: proc "c" (self: ^Menu) -> bool {…}
    menuChangedMessagesEnabled := menu->menuChangedMessagesEnabled()
    Menu_menuRepresentation :: proc "c" (self: ^Menu) -> ^intrinsics.objc_object {…}
    menuRepresentation := menu->menuRepresentation()
    Menu_menuZone :: proc "c" () -> ^Zone {…}
    zone := Menu.menuZone()
    Menu_minimumWidth :: proc "c" (self: ^Menu) -> CoreFoundation.CGFloat {…}
    minimumWidth := menu->minimumWidth()
    Menu_mutableCopyWithZone :: proc "c" (zone: ^Zone) -> ^intrinsics.objc_object {…}
    res := Menu.mutableCopyWithZone(zone)
    Menu_new :: proc "c" () -> ^Menu {…}
    menu := Menu.new()
    Menu_numberOfItems :: proc "c" (self: ^Menu) -> Integer {…}
    numberOfItems := menu->numberOfItems()
    Menu_paletteMenuWithColors_titles_selectionHandler :: proc "c" (
    	colors:            ^Array, 
    	itemTitles:        ^Array, 
    	onSelectionChange: proc "c" (_arg_0: ^Menu), 
    ) -> ^Menu {…}
    menu := Menu.paletteMenuWithColors_titles_selectionHandler(colors, itemTitles, onSelectionChange)
    Menu_performActionForItemAtIndex :: proc "c" (self: ^Menu, index: Integer) {…}
    menu->performActionForItemAtIndex(index)
    Menu_performKeyEquivalent :: proc "c" (self: ^Menu, event: ^Event) -> bool {…}
    res := menu->performKeyEquivalent(event)
    Menu_popUpContextMenu_withEvent_forView :: proc "c" (menu: ^Menu, event: ^Event, view: ^View) {…}
    Menu.popUpContextMenu_withEvent_forView(menu, event, view)
    Menu_popUpMenuPositioningItem :: proc "c" (
    	self:     ^Menu, 
    	item:     ^MenuItem, 
    	location: CoreFoundation.CGPoint, 
    	view:     ^View, 
    ) -> bool {…}
    res := menu->popUpMenuPositioningItem(item, location, view)
     

    Menu_popUpContextMenu_withEvent_forView_withFont :: #force_inline proc "c" (menu: ^Menu, event: ^Event, view: ^View, font: ^Font) {

    msgSend(nil, Menu, "popUpContextMenu:withEvent:forView:withFont:", menu, event, view, font)
    

    }

    Menu_poseAsClass :: proc "c" (aClass: ^intrinsics.objc_class) {…}
    Menu.poseAsClass(aClass)
    Menu_presentationStyle :: proc "c" (self: ^Menu) -> MenuPresentationStyle {…}
    presentationStyle := menu->presentationStyle()
     

    Menu_paletteMenuWithColors_titles_templateImage_selectionHandler :: #force_inline proc "c" (colors: ^Array, itemTitles: ^Array, image: ^Image, onSelectionChange: proc "c" (_arg_0: ^Menu)) -> ^Menu {

    return msgSend(^Menu, Menu, "paletteMenuWithColors:titles:templateImage:selectionHandler:", colors, itemTitles, image, onSelectionChange)
    

    }

    Menu_propertiesToUpdate :: proc "c" (self: ^Menu) -> MenuProperties {…}
    propertiesToUpdate := menu->propertiesToUpdate()
    Menu_removeAllItems :: proc "c" (self: ^Menu) {…}
    menu->removeAllItems()
    Menu_removeItem :: proc "c" (self: ^Menu, item: ^MenuItem) {…}
    menu->removeItem(item)
    Menu_removeItemAtIndex :: proc "c" (self: ^Menu, index: Integer) {…}
    menu->removeItemAtIndex(index)
    Menu_resolveClassMethod :: proc "c" (sel: ^intrinsics.objc_selector) -> bool {…}
    res := Menu.resolveClassMethod(sel)
    Menu_resolveInstanceMethod :: proc "c" (sel: ^intrinsics.objc_selector) -> bool {…}
    res := Menu.resolveInstanceMethod(sel)
    Menu_selectedItems :: proc "c" (self: ^Menu) -> ^Array {…}
    selectedItems := menu->selectedItems()
    Menu_selectionMode :: proc "c" (self: ^Menu) -> MenuSelectionMode {…}
    selectionMode := menu->selectionMode()
    Menu_setAllowsContextMenuPlugIns :: proc "c" (self: ^Menu, allowsContextMenuPlugIns: bool) {…}
    menu->setAllowsContextMenuPlugIns(allowsContextMenuPlugIns)
    Menu_setAutoenablesItems :: proc "c" (self: ^Menu, autoenablesItems: bool) {…}
    menu->setAutoenablesItems(autoenablesItems)
    Menu_setContextMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^intrinsics.objc_object) {…}
    menu->setContextMenuRepresentation(menuRep)
    Menu_setDefaultPlaceholder :: proc "c" (
    	placeholder: ^intrinsics.objc_object, 
    	marker:      ^intrinsics.objc_object, 
    	binding:     ^String, 
    ) {…}
    Menu.setDefaultPlaceholder(placeholder, marker, binding)
    Menu_setDelegate :: proc "c" (self: ^Menu, delegate: ^MenuDelegate) {…}
    menu->setDelegate(delegate)
    Menu_setItemArray :: proc "c" (self: ^Menu, itemArray: ^Array) {…}
    menu->setItemArray(itemArray)
    Menu_setKeys :: proc "c" (keys: ^Array, dependentKey: ^String) {…}
    Menu.setKeys(keys, dependentKey)
    Menu_setMenuBarVisible :: proc "c" (visible: bool) {…}
    Menu.setMenuBarVisible(visible)
    Menu_setMenuChangedMessagesEnabled :: proc "c" (self: ^Menu, menuChangedMessagesEnabled: bool) {…}
    menu->setMenuChangedMessagesEnabled(menuChangedMessagesEnabled)
    Menu_setMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^intrinsics.objc_object) {…}
    menu->setMenuRepresentation(menuRep)
    Menu_setMenuZone :: proc "c" (zone: ^Zone) {…}
    Menu.setMenuZone(zone)
    Menu_setMinimumWidth :: proc "c" (self: ^Menu, minimumWidth: CoreFoundation.CGFloat) {…}
    menu->setMinimumWidth(minimumWidth)
    Menu_setPresentationStyle :: proc "c" (self: ^Menu, presentationStyle: MenuPresentationStyle) {…}
    menu->setPresentationStyle(presentationStyle)
    Menu_setSelectedItems :: proc "c" (self: ^Menu, selectedItems: ^Array) {…}
    menu->setSelectedItems(selectedItems)
    Menu_setSelectionMode :: proc "c" (self: ^Menu, selectionMode: MenuSelectionMode) {…}
    menu->setSelectionMode(selectionMode)
    Menu_setShowsStateColumn :: proc "c" (self: ^Menu, showsStateColumn: bool) {…}
    menu->setShowsStateColumn(showsStateColumn)
    Menu_setSubmenu :: proc "c" (self: ^Menu, menu: ^Menu, item: ^MenuItem) {…}
    menu->setSubmenu(menu, item)
    Menu_setSupermenu :: proc "c" (self: ^Menu, supermenu: ^Menu) {…}
    menu->setSupermenu(supermenu)
    Menu_setTearOffMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^intrinsics.objc_object) {…}
    menu->setTearOffMenuRepresentation(menuRep)
    Menu_setTitle :: proc "c" (self: ^Menu, title: ^String) {…}
    menu->setTitle(title)
    Menu_setUserInterfaceLayoutDirection :: proc "c" (
    	self:                         ^Menu, 
    	userInterfaceLayoutDirection: UserInterfaceLayoutDirection, 
    ) {…}
    menu->setUserInterfaceLayoutDirection(userInterfaceLayoutDirection)
    Menu_setVersion :: proc "c" (aVersion: Integer) {…}
    Menu.setVersion(aVersion)
    Menu_showsStateColumn :: proc "c" (self: ^Menu) -> bool {…}
    showsStateColumn := menu->showsStateColumn()
    Menu_size :: proc "c" (self: ^Menu) -> CoreFoundation.CGSize {…}
    size := menu->size()
    Menu_sizeToFit :: proc "c" (self: ^Menu) {…}
    menu->sizeToFit()
    Menu_submenuAction :: proc "c" (self: ^Menu, sender: ^intrinsics.objc_object) {…}
    menu->submenuAction(sender)
    Menu_superclass :: proc "c" () -> ^intrinsics.objc_class {…}
    res := Menu.superclass()
    Menu_supermenu :: proc "c" (self: ^Menu) -> ^Menu {…}
    supermenu := menu->supermenu()
    Menu_tearOffMenuRepresentation :: proc "c" (self: ^Menu) -> ^intrinsics.objc_object {…}
    tearOffMenuRepresentation := menu->tearOffMenuRepresentation()
    Menu_title :: proc "c" (self: ^Menu) -> ^String {…}
    title := menu->title()
    Menu_update :: proc "c" (self: ^Menu) {…}
    menu->update()
    Menu_useStoredAccessor :: proc "c" () -> bool {…}
    res := Menu.useStoredAccessor()
    Menu_userInterfaceLayoutDirection :: proc "c" (self: ^Menu) -> UserInterfaceLayoutDirection {…}
    userInterfaceLayoutDirection := menu->userInterfaceLayoutDirection()
    Menu_version :: proc "c" () -> Integer {…}
    integer := Menu.version()

    MidX ¶

    MidX :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}

    MidY ¶

    MidY :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}

    MinX ¶

    MinX :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}

    MinY ¶

    MinY :: proc(aRect: CoreFoundation.CGRect) -> CoreFoundation.CGFloat {…}

    MutableArray_alloc ¶ class method owned

    MutableArray_alloc :: proc "c" () -> ^MutableArray {…}
    mutableArray := MutableArray.alloc()

    MutableArray_count ¶

    MutableArray_count :: proc "c" (self: ^MutableArray) -> UInteger {…}
    count := mutableArray->count()

    MutableArray_exchangeObjectAtIndex ¶

    MutableArray_exchangeObjectAtIndex :: proc "c" (self: ^MutableArray, idx1, idx2: UInteger) {…}
    mutableArray->exchangeObjectAtIndex(idx1, idx2)

    MutableArray_init ¶

    MutableArray_init :: proc "c" (self: ^MutableArray) -> ^MutableArray {…}
    res := mutableArray->init()

    MutableArray_initWithCoder ¶

    MutableArray_initWithCoder :: proc "c" (self: ^MutableArray, coder: ^Coder) -> ^MutableArray {…}
    res := mutableArray->initWithCoder(coder)

    MutableArray_initWithObjects ¶

    MutableArray_initWithObjects :: proc "c" (
    	self:    ^MutableArray, 
    	objects: [^]^Object, 
    	count:   UInteger, 
    ) -> ^MutableArray {…}
    res := mutableArray->initWithObjects(objects, count)

    MutableArray_object ¶

    MutableArray_object :: proc "c" (self: ^MutableArray, index: UInteger) -> ^Object {…}
    object := mutableArray->object(index)

    MutableArray_objectAs ¶

    MutableArray_objectAs :: proc "c" (self: ^MutableArray, index: UInteger, $T: typeid) -> T {…}
    res := mutableArray->objectAs(index, T)

    NSWindow_setFrameAutosaveName ¶

    NSWindow_setFrameAutosaveName :: proc "c" (self: ^Window, name: ^String) {…}
    window->setFrameAutosaveName(name)

    NotificationCenter_addObserver ¶

    NotificationCenter_addObserver :: proc "c" (
    	self:     ^NotificationCenter, 
    	observer: ^Object, 
    	selector: ^intrinsics.objc_selector, 
    	name:     ^String, 
    	object:   ^Object, 
    ) {…}
    notificationCenter->addObserver(observer, selector, name, object)

    NotificationCenter_addObserverForName_new ¶

    NotificationCenter_addObserverForName_new :: proc "c" (
    	self:   ^NotificationCenter, 
    	name:   ^String, 
    	pObj:   ^Object, 
    	pQueue: rawptr, 
    	block:  ^runtime.Objc_Block, 
    ) -> ^Object {…}

    NotificationCenter_addObserverForName_old ¶

    NotificationCenter_addObserverForName_old :: proc "c" (
    	self:   ^NotificationCenter, 
    	name:   ^String, 
    	pObj:   ^Object, 
    	pQueue: rawptr, 
    	block:  ^Block, 
    ) -> ^Object {…}

    NotificationCenter_alloc ¶ class method owned

    NotificationCenter_alloc :: proc "c" () -> ^NotificationCenter {…}
    notificationCenter := NotificationCenter.alloc()

    NotificationCenter_defaultCenter ¶ class method

    NotificationCenter_defaultCenter :: proc "c" () -> ^NotificationCenter {…}
    notificationCenter := NotificationCenter.defaultCenter()

    NotificationCenter_init ¶

    NotificationCenter_init :: proc "c" (self: ^NotificationCenter) -> ^NotificationCenter {…}
    res := notificationCenter->init()

    NotificationCenter_removeObserver ¶

    NotificationCenter_removeObserver :: proc "c" (self: ^NotificationCenter, pObserver: ^Object) {…}
    notificationCenter->removeObserver(pObserver)

    Notification_alloc ¶ class method owned

    Notification_alloc :: proc "c" () -> ^Notification {…}
    notification := Notification.alloc()

    Notification_init ¶

    Notification_init :: proc "c" (self: ^Notification) -> ^Notification {…}
    res := notification->init()

    Notification_name ¶

    Notification_name :: proc "c" (self: ^Notification) -> ^String {…}
    name := notification->name()

    Notification_object ¶

    Notification_object :: proc "c" (self: ^Notification) -> ^Object {…}
    object := notification->object()

    Notification_userInfo ¶

    Notification_userInfo :: proc "c" (self: ^Notification) -> ^Dictionary {…}
    userInfo := notification->userInfo()

    Number_alloc ¶ class method owned

    Number_alloc :: proc "c" () -> ^Number {…}
    number := Number.alloc()

    Number_boolValue ¶

    Number_boolValue :: proc "c" (self: ^Number) -> bool {…}
    boolValue := number->boolValue()

    Number_compare ¶

    Number_compare :: proc "c" (self, other: ^Number) -> ComparisonResult {…}
    comparisonResult := number->compare(other)

    Number_descriptionWithLocale ¶

    Number_descriptionWithLocale :: proc "c" (self: ^Number, locale: ^Object) -> ^String {…}
    str := number->descriptionWithLocale(locale)

    Number_f32Value ¶

    Number_f32Value :: proc "c" (self: ^Number) -> f32 {…}
    f32Value := number->f32Value()

    Number_f64Value ¶

    Number_f64Value :: proc "c" (self: ^Number) -> f64 {…}
    f64Value := number->f64Value()

    Number_i16Value ¶

    Number_i16Value :: proc "c" (self: ^Number) -> i16 {…}
    i16Value := number->i16Value()

    Number_i32Value ¶

    Number_i32Value :: proc "c" (self: ^Number) -> i32 {…}
    i32Value := number->i32Value()

    Number_i64Value ¶

    Number_i64Value :: proc "c" (self: ^Number) -> i64 {…}
    i64Value := number->i64Value()

    Number_i8Value ¶

    Number_i8Value :: proc "c" (self: ^Number) -> i8 {…}
    i8Value := number->i8Value()

    Number_init ¶

    Number_init :: proc "c" (self: ^Number) -> ^Number {…}
    res := number->init()

    Number_initWithBool ¶

    Number_initWithBool :: proc "c" (self: ^Number, value: bool) -> ^Number {…}
    res := number->initWithBool(value)

    Number_initWithF32 ¶

    Number_initWithF32 :: proc "c" (self: ^Number, value: f32) -> ^Number {…}
    res := number->initWithF32(value)

    Number_initWithF64 ¶

    Number_initWithF64 :: proc "c" (self: ^Number, value: f64) -> ^Number {…}
    res := number->initWithF64(value)

    Number_initWithI16 ¶

    Number_initWithI16 :: proc "c" (self: ^Number, value: i16) -> ^Number {…}
    res := number->initWithI16(value)

    Number_initWithI32 ¶

    Number_initWithI32 :: proc "c" (self: ^Number, value: i32) -> ^Number {…}
    res := number->initWithI32(value)

    Number_initWithI64 ¶

    Number_initWithI64 :: proc "c" (self: ^Number, value: i64) -> ^Number {…}
    res := number->initWithI64(value)

    Number_initWithI8 ¶

    Number_initWithI8 :: proc "c" (self: ^Number, value: i8) -> ^Number {…}
    res := number->initWithI8(value)

    Number_initWithInt ¶

    Number_initWithInt :: proc "c" (self: ^Number, value: int) -> ^Number {…}
    res := number->initWithInt(value)

    Number_initWithU16 ¶

    Number_initWithU16 :: proc "c" (self: ^Number, value: u16) -> ^Number {…}
    res := number->initWithU16(value)

    Number_initWithU32 ¶

    Number_initWithU32 :: proc "c" (self: ^Number, value: u32) -> ^Number {…}
    res := number->initWithU32(value)

    Number_initWithU64 ¶

    Number_initWithU64 :: proc "c" (self: ^Number, value: u64) -> ^Number {…}
    res := number->initWithU64(value)

    Number_initWithU8 ¶

    Number_initWithU8 :: proc "c" (self: ^Number, value: u8) -> ^Number {…}
    res := number->initWithU8(value)

    Number_initWithUint ¶

    Number_initWithUint :: proc "c" (self: ^Number, value: uint) -> ^Number {…}
    res := number->initWithUint(value)

    Number_intValue ¶

    Number_intValue :: proc "c" (self: ^Number) -> int {…}
    intValue := number->intValue()

    Number_integerValue ¶

    Number_integerValue :: proc "c" (self: ^Number) -> Integer {…}
    integerValue := number->integerValue()

    Number_isEqualToNumber ¶

    Number_isEqualToNumber :: proc "c" (self, other: ^Number) -> bool {…}
    res := number->isEqualToNumber(other)

    Number_numberWithBool ¶ class method

    Number_numberWithBool :: proc "c" (value: bool) -> ^Number {…}
    number := Number.numberWithBool(value)

    Number_numberWithF32 ¶ class method

    Number_numberWithF32 :: proc "c" (value: f32) -> ^Number {…}
    number := Number.numberWithF32(value)

    Number_numberWithF64 ¶ class method

    Number_numberWithF64 :: proc "c" (value: f64) -> ^Number {…}
    number := Number.numberWithF64(value)

    Number_numberWithI16 ¶ class method

    Number_numberWithI16 :: proc "c" (value: i16) -> ^Number {…}
    number := Number.numberWithI16(value)

    Number_numberWithI32 ¶ class method

    Number_numberWithI32 :: proc "c" (value: i32) -> ^Number {…}
    number := Number.numberWithI32(value)

    Number_numberWithI64 ¶ class method

    Number_numberWithI64 :: proc "c" (value: i64) -> ^Number {…}
    number := Number.numberWithI64(value)

    Number_numberWithI8 ¶ class method

    Number_numberWithI8 :: proc "c" (value: i8) -> ^Number {…}
    number := Number.numberWithI8(value)

    Number_numberWithInt ¶ class method

    Number_numberWithInt :: proc "c" (value: int) -> ^Number {…}
    number := Number.numberWithInt(value)

    Number_numberWithU16 ¶ class method

    Number_numberWithU16 :: proc "c" (value: u16) -> ^Number {…}
    number := Number.numberWithU16(value)

    Number_numberWithU32 ¶ class method

    Number_numberWithU32 :: proc "c" (value: u32) -> ^Number {…}
    number := Number.numberWithU32(value)

    Number_numberWithU64 ¶ class method

    Number_numberWithU64 :: proc "c" (value: u64) -> ^Number {…}
    number := Number.numberWithU64(value)

    Number_numberWithU8 ¶ class method

    Number_numberWithU8 :: proc "c" (value: u8) -> ^Number {…}
    number := Number.numberWithU8(value)

    Number_numberWithUint ¶ class method

    Number_numberWithUint :: proc "c" (value: uint) -> ^Number {…}
    number := Number.numberWithUint(value)

    Number_stringValue ¶

    Number_stringValue :: proc "c" (self: ^Number) -> ^String {…}
    stringValue := number->stringValue()

    Number_u16Value ¶

    Number_u16Value :: proc "c" (self: ^Number) -> u16 {…}
    u16Value := number->u16Value()

    Number_u32Value ¶

    Number_u32Value :: proc "c" (self: ^Number) -> u32 {…}
    u32Value := number->u32Value()

    Number_u64Value ¶

    Number_u64Value :: proc "c" (self: ^Number) -> u64 {…}
    u64Value := number->u64Value()

    Number_u8Value ¶

    Number_u8Value :: proc "c" (self: ^Number) -> u8 {…}
    u8Value := number->u8Value()

    Number_uintValue ¶

    Number_uintValue :: proc "c" (self: ^Number) -> uint {…}
    uintValue := number->uintValue()

    Number_uintegerValue ¶

    Number_uintegerValue :: proc "c" (self: ^Number) -> UInteger {…}
    uintegerValue := number->uintegerValue()

    OpenPanel_URLs ¶

    OpenPanel_URLs :: proc "c" (self: ^OpenPanel) -> ^Array {…}
    URLs := openPanel->URLs()

    OpenPanel_openPanel ¶ class method

    OpenPanel_openPanel :: proc "c" () -> ^OpenPanel {…}
    openPanel := OpenPanel.openPanel()

    OpenPanel_setAllowedFileTypes ¶

    OpenPanel_setAllowedFileTypes :: proc "c" (self: ^OpenPanel, types: ^Array) {…}
    openPanel->setAllowedFileTypes(types)

    OpenPanel_setAllowsMultipleSelection ¶

    OpenPanel_setAllowsMultipleSelection :: proc "c" (self: ^OpenPanel, setting: bool) {…}
    openPanel->setAllowsMultipleSelection(setting)

    OpenPanel_setCanChooseDirectories ¶

    OpenPanel_setCanChooseDirectories :: proc "c" (self: ^OpenPanel, setting: bool) {…}
    openPanel->setCanChooseDirectories(setting)

    OpenPanel_setCanChooseFiles ¶

    OpenPanel_setCanChooseFiles :: proc "c" (self: ^OpenPanel, setting: bool) {…}
    openPanel->setCanChooseFiles(setting)

    OpenPanel_setResolvesAliases ¶

    OpenPanel_setResolvesAliases :: proc "c" (self: ^OpenPanel, setting: bool) {…}
    openPanel->setResolvesAliases(setting)

    ProcessInfo_activeProcessorCount ¶

    ProcessInfo_activeProcessorCount :: proc "c" (self: ^ProcessInfo) -> UInteger {…}
    activeProcessorCount := processInfo->activeProcessorCount()

    ProcessInfo_arguments ¶

    ProcessInfo_arguments :: proc "c" (self: ^ProcessInfo) -> ^Array {…}
    arguments := processInfo->arguments()

    ProcessInfo_automaticTerminationSupportEnabled ¶

    ProcessInfo_automaticTerminationSupportEnabled :: proc "c" (self: ^ProcessInfo) -> bool {…}
    automaticTerminationSupportEnabled := processInfo->automaticTerminationSupportEnabled()

    ProcessInfo_beginActivityWithOptions ¶

    ProcessInfo_beginActivityWithOptions :: proc "c" (
    	self:    ^ProcessInfo, 
    	options: bit_set[ActivityOptionsBits; u64], 
    	reason:  ^String, 
    ) -> ^ObjectProtocol {…}
    objectProtocol := processInfo->beginActivityWithOptions(options, reason)

    ProcessInfo_disableAutomaticTermination ¶

    ProcessInfo_disableAutomaticTermination :: proc "c" (self: ^ProcessInfo, reason: ^String) {…}
    processInfo->disableAutomaticTermination(reason)

    ProcessInfo_disableSuddenTermination ¶

    ProcessInfo_disableSuddenTermination :: proc "c" (self: ^ProcessInfo) {…}
    processInfo->disableSuddenTermination()

    ProcessInfo_enableAutomaticTermination ¶

    ProcessInfo_enableAutomaticTermination :: proc "c" (self: ^ProcessInfo, reason: ^String) {…}
    processInfo->enableAutomaticTermination(reason)

    ProcessInfo_enableSuddenTermination ¶

    ProcessInfo_enableSuddenTermination :: proc "c" (self: ^ProcessInfo) {…}
    processInfo->enableSuddenTermination()

    ProcessInfo_endActivity ¶

    ProcessInfo_endActivity :: proc "c" (self: ^ProcessInfo, activity: ^ObjectProtocol) {…}
    processInfo->endActivity(activity)

    ProcessInfo_environment ¶

    ProcessInfo_environment :: proc "c" (self: ^ProcessInfo) -> ^Dictionary {…}
    environment := processInfo->environment()

    ProcessInfo_fullUserName ¶

    ProcessInfo_fullUserName :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    fullUserName := processInfo->fullUserName()

    ProcessInfo_globallyUniqueString ¶

    ProcessInfo_globallyUniqueString :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    globallyUniqueString := processInfo->globallyUniqueString()

    ProcessInfo_hostName ¶

    ProcessInfo_hostName :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    hostName := processInfo->hostName()

    ProcessInfo_isLowPowerModeEnabled ¶

    ProcessInfo_isLowPowerModeEnabled :: proc "c" (self: ^ProcessInfo) -> bool {…}
    isLowPowerModeEnabled := processInfo->isLowPowerModeEnabled()

    ProcessInfo_isMacCatalystApp ¶

    ProcessInfo_isMacCatalystApp :: proc "c" (self: ^ProcessInfo) -> bool {…}
    isMacCatalystApp := processInfo->isMacCatalystApp()

    ProcessInfo_isOperatingSystemAtLeastVersion ¶

    ProcessInfo_isOperatingSystemAtLeastVersion :: proc "c" (
    	self:    ^ProcessInfo, 
    	version: OperatingSystemVersion, 
    ) -> bool {…}
    res := processInfo->isOperatingSystemAtLeastVersion(version)

    ProcessInfo_isiOSAppOnMac ¶

    ProcessInfo_isiOSAppOnMac :: proc "c" (self: ^ProcessInfo) -> bool {…}
    isiOSAppOnMac := processInfo->isiOSAppOnMac()

    ProcessInfo_operatingSystemVersion ¶

    ProcessInfo_operatingSystemVersion :: proc "c" (self: ^ProcessInfo) -> OperatingSystemVersion {…}
    operatingSystemVersion := processInfo->operatingSystemVersion()

    ProcessInfo_operatingSystemVersionString ¶

    ProcessInfo_operatingSystemVersionString :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    operatingSystemVersionString := processInfo->operatingSystemVersionString()

    ProcessInfo_performActivityWithOptions ¶

    ProcessInfo_performActivityWithOptions :: proc "c" (
    	self:    ^ProcessInfo, 
    	options: bit_set[ActivityOptionsBits; u64], 
    	reason:  ^String, 
    	block:   proc "c" (), 
    ) {…}
    processInfo->performActivityWithOptions(options, reason, block)

    ProcessInfo_performExpiringActivityWithReason ¶

    ProcessInfo_performExpiringActivityWithReason :: proc "c" (
    	self:   ^ProcessInfo, 
    	reason: ^String, 
    	block:  proc "c" (expired: bool), 
    ) {…}
    processInfo->performExpiringActivityWithReason(reason, block)

    ProcessInfo_physicalMemory ¶

    ProcessInfo_physicalMemory :: proc "c" (self: ^ProcessInfo) -> u64 {…}
    physicalMemory := processInfo->physicalMemory()

    ProcessInfo_processIdentifier ¶

    ProcessInfo_processIdentifier :: proc "c" (self: ^ProcessInfo) -> i32 {…}
    processIdentifier := processInfo->processIdentifier()

    ProcessInfo_processInfo ¶ class method

    ProcessInfo_processInfo :: proc "c" () -> ^ProcessInfo {…}
    processInfo := ProcessInfo.processInfo()

    ProcessInfo_processName ¶

    ProcessInfo_processName :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    processName := processInfo->processName()

    ProcessInfo_processorCount ¶

    ProcessInfo_processorCount :: proc "c" (self: ^ProcessInfo) -> UInteger {…}
    processorCount := processInfo->processorCount()

    ProcessInfo_setAutomaticTerminationSupportEnabled ¶

    ProcessInfo_setAutomaticTerminationSupportEnabled :: proc "c" (
    	self:                               ^ProcessInfo, 
    	automaticTerminationSupportEnabled: bool, 
    ) {…}
    processInfo->setAutomaticTerminationSupportEnabled(automaticTerminationSupportEnabled)

    ProcessInfo_systemUptime ¶

    ProcessInfo_systemUptime :: proc "c" (self: ^ProcessInfo) -> TimeInterval {…}
    systemUptime := processInfo->systemUptime()

    ProcessInfo_thermalState ¶

    ProcessInfo_thermalState :: proc "c" (self: ^ProcessInfo) -> ProcessInfoThermalState {…}
    thermalState := processInfo->thermalState()

    ProcessInfo_userName ¶

    ProcessInfo_userName :: proc "c" (self: ^ProcessInfo) -> ^String {…}
    userName := processInfo->userName()

    Range_Equal ¶

    Range_Equal :: proc "c" (a, b: Range) -> bool {…}

    Range_LocationInRange ¶

    Range_LocationInRange :: proc "c" (self: Range, loc: UInteger) -> bool {…}

    Range_Make ¶

    Range_Make :: proc "c" (loc, len: UInteger) -> Range {…}
    External examples metal/learn_metal/02-argbuffers · metal/learn_metal/02-argbuffers-no-sdl · metal/learn_metal/03-animation +6

    Range_Max ¶

    Range_Max :: proc "c" (self: Range) -> UInteger {…}

    RunLoop_addTimerForMode ¶

    RunLoop_addTimerForMode :: proc(self: ^RunLoop, timer: ^Timer, forMode: ^String) {…}
    runLoop->addTimerForMode(timer, forMode)

    RunLoop_mainRunLoop ¶ class method

    RunLoop_mainRunLoop :: proc() -> ^RunLoop {…}
    runLoop := RunLoop.mainRunLoop()

    RunningApplication_currentApplication ¶ class method

    RunningApplication_currentApplication :: proc "c" () -> ^RunningApplication {…}
    runningApplication := RunningApplication.currentApplication()

    RunningApplication_finishedLaunching ¶

    RunningApplication_finishedLaunching :: proc "c" (self: ^RunningApplication) -> bool {…}
    finishedLaunching := runningApplication->finishedLaunching()

    RunningApplication_localizedName ¶

    RunningApplication_localizedName :: proc "c" (self: ^RunningApplication) -> ^String {…}
    localizedName := runningApplication->localizedName()

    SavePanel_URL ¶

    SavePanel_URL :: proc "c" (self: ^SavePanel) -> ^URL {…}
    URL := savePanel->URL()

    SavePanel_runModal ¶

    SavePanel_runModal :: proc "c" (self: ^SavePanel) -> ModalResponse {…}
    runModal := savePanel->runModal()

    SavePanel_savePanel ¶ class method

    SavePanel_savePanel :: proc "c" () -> ^SavePanel {…}
    savePanel := SavePanel.savePanel()

    Screen_backingScaleFactor ¶

    Screen_backingScaleFactor :: proc "c" (self: ^Screen) -> CoreFoundation.CGFloat {…}
    backingScaleFactor := screen->backingScaleFactor()

    Screen_colorSpace ¶

    Screen_colorSpace :: proc "c" (self: ^Screen) -> ^ColorSpace {…}
    colorSpace := screen->colorSpace()

    Screen_deepestScreen ¶ class method

    Screen_deepestScreen :: proc "c" () -> ^Screen {…}
    screen := Screen.deepestScreen()

    Screen_depth ¶

    Screen_depth :: proc "c" (self: ^Screen) -> Depth {…}
    depth := screen->depth()

    Screen_frame ¶

    Screen_frame :: proc "c" (self: ^Screen) -> CoreFoundation.CGRect {…}
    frame := screen->frame()

    Screen_mainScreen ¶ class method

    Screen_mainScreen :: proc "c" () -> ^Screen {…}
    screen := Screen.mainScreen()

    Screen_screens ¶ class method

    Screen_screens :: proc "c" () -> ^Array {…}
    array := Screen.screens()

    Screen_screensHaveSeparateSpaces ¶ class method

    Screen_screensHaveSeparateSpaces :: proc "c" () -> bool {…}
    res := Screen.screensHaveSeparateSpaces()

    Screen_visibleFrame ¶

    Screen_visibleFrame :: proc "c" (self: ^Screen) -> CoreFoundation.CGRect {…}
    visibleFrame := screen->visibleFrame()

    SelectorFromString ¶
    C · NSSelectorFromStringSource · NSString.odin:64

    SelectorFromString :: proc "c" (str: ^String) -> ^intrinsics.objc_selector ---

    Set_alloc ¶ class method owned

    Set_alloc :: proc "c" () -> ^Set {…}
    set := Set.alloc()

    Set_init ¶

    Set_init :: proc "c" (self: ^Set) -> ^Set {…}
    res := set->init()

    Set_initWithCoder ¶

    Set_initWithCoder :: proc "c" (self: ^Set, coder: ^Coder) -> ^Set {…}
    res := set->initWithCoder(coder)

    Set_initWithObjects ¶

    Set_initWithObjects :: proc "c" (self: ^Set, objects: [^]^Object, count: UInteger) -> ^Set {…}
    res := set->initWithObjects(objects, count)

    StringFromClass ¶
    C · NSStringFromClassSource · NSString.odin:61

    StringFromClass :: proc "c" (cls: ^intrinsics.objc_class) -> ^String ---

    StringFromSelector ¶
    C · NSStringFromSelectorSource · NSString.odin:63

    StringFromSelector :: proc "c" (selector: ^intrinsics.objc_selector) -> ^String ---

    String_UTF8String ¶

    String_UTF8String :: proc "c" (self: ^String) -> cstring {…}
    UTF8String := str->UTF8String()

    String_alloc ¶ class method owned

    String_alloc :: proc "c" () -> ^String {…}
    str := String.alloc()

    String_characterAtIndex ¶

    String_characterAtIndex :: proc "c" (self: ^String, index: UInteger) -> unichar {…}
    unichar := str->characterAtIndex(index)

    String_cstringUsingEncoding ¶

    String_cstringUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> cstring {…}
    res := str->cstringUsingEncoding(encoding)

    String_init ¶

    String_init :: proc "c" (self: ^String) -> ^String {…}
    res := str->init()

    String_initWithBytesNoCopy ¶

    String_initWithBytesNoCopy :: proc "c" (
    	self:         ^String, 
    	pBytes:       rawptr, 
    	length:       UInteger, 
    	encoding:     StringEncoding, 
    	freeWhenDone: bool, 
    ) -> ^String {…}
    res := str->initWithBytesNoCopy(pBytes, length, encoding, freeWhenDone)

    String_initWithCString ¶

    String_initWithCString :: proc "c" (
    	self:     ^String, 
    	pString:  cstring, 
    	encoding: StringEncoding, 
    ) -> ^String {…}
    res := str->initWithCString(pString, encoding)

    String_initWithOdinString ¶

    String_initWithOdinString :: proc "c" (self: ^String, str: string) -> ^String {…}
    res := str->initWithOdinString(str)

    String_initWithString ¶

    String_initWithString :: proc "c" (self: ^String, other: ^String) -> ^String {…}
    res := str->initWithString(other)

    String_isEqualToString ¶

    String_isEqualToString :: proc "c" (self: ^String, other: ^String) -> bool {…}
    res := str->isEqualToString(other)

    String_length ¶

    String_length :: proc "c" (self: ^String) -> UInteger {…}
    length := str->length()

    String_lengthOfBytesUsingEncoding ¶

    String_lengthOfBytesUsingEncoding :: proc "c" (
    	self:     ^String, 
    	encoding: StringEncoding, 
    ) -> UInteger {…}
    uInteger := str->lengthOfBytesUsingEncoding(encoding)

    String_maximumLengthOfBytesUsingEncoding ¶

    String_maximumLengthOfBytesUsingEncoding :: proc "c" (
    	self:     ^String, 
    	encoding: StringEncoding, 
    ) -> UInteger {…}
    uInteger := str->maximumLengthOfBytesUsingEncoding(encoding)

    String_odinString ¶

    String_odinString :: proc "c" (self: ^String) -> string {…}
    odinString := str->odinString()

    String_rangeOfString ¶

    String_rangeOfString :: proc "c" (
    	self, other: ^String, 
    	options:     StringCompareOptions, 
    ) -> Range {…}
    range := str->rangeOfString(other, options)

    String_stringByAppendingString ¶

    String_stringByAppendingString :: proc "c" (self: ^String, other: ^String) -> ^String {…}
    res := str->stringByAppendingString(other)

    Timer_scheduledTimerWithTimeIntervalRepeatsBlock ¶ class method

    Timer_scheduledTimerWithTimeIntervalRepeatsBlock :: proc(
    	interval: TimeInterval, 
    	repeats:  bool, 
    	block:    ^Block, 
    ) -> ^Timer {…}
    timer := Timer.scheduledTimerWithTimeIntervalRepeatsBlock(interval, repeats, block)

    Timer_scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat ¶ class method

    Timer_scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat :: proc(
    	interval:  TimeInterval, 
    	aTarget:   ^intrinsics.objc_object, 
    	aSelector: ^intrinsics.objc_selector, 
    	userInfo:  ^intrinsics.objc_object, 
    	repeats:   bool, 
    ) -> ^Timer {…}
    timer := Timer.scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat(
    	interval,
    	aTarget,
    	aSelector,
    	userInfo,
    	repeats,
    )

    Toolbar_alloc ¶ class method owned

    Toolbar_alloc :: proc "c" () -> ^Toolbar {…}
    toolbar := Toolbar.alloc()

    Toolbar_init ¶

    Toolbar_init :: proc "c" (self: ^Toolbar) -> ^Toolbar {…}
    res := toolbar->init()

    URLRequest_alloc ¶ class method owned

    URLRequest_alloc :: proc "c" () -> ^URLRequest {…}
    urlRequest := URLRequest.alloc()

    URLRequest_init ¶

    URLRequest_init :: proc "c" (self: ^URLRequest) -> ^URLRequest {…}
    res := urlRequest->init()

    URLRequest_requestWithURL ¶ class method

    URLRequest_requestWithURL :: proc "c" (url: ^URL) -> ^URLRequest {…}
    urlRequest := URLRequest.requestWithURL(url)

    URLRequest_url ¶

    URLRequest_url :: proc "c" (self: ^URLRequest) -> ^URL {…}
    url := urlRequest->url()

    URLResponse_alloc ¶ class method owned

    URLResponse_alloc :: proc "c" () -> ^URLResponse {…}
    urlResponse := URLResponse.alloc()

    URLResponse_init ¶

    URLResponse_init :: proc "c" (self: ^URLResponse) -> ^URLResponse {…}
    res := urlResponse->init()

    URLResponse_initWithURL ¶

    URLResponse_initWithURL :: proc "c" (
    	self:      ^URLResponse, 
    	url:       ^URL, 
    	mime_type: ^String, 
    	length:    int, 
    	encoding:  ^String, 
    ) -> ^URLResponse {…}
    res := urlResponse->initWithURL(url, mime_type, length, encoding)

    URL_alloc ¶ class method owned

    URL_alloc :: proc "c" () -> ^URL {…}
    url := URL.alloc()

    URL_fileSystemRepresentation ¶

    URL_fileSystemRepresentation :: proc "c" (self: ^URL) -> cstring {…}
    fileSystemRepresentation := url->fileSystemRepresentation()

    URL_init ¶

    URL_init :: proc "c" (self: ^URL) -> ^URL {…}
    res := url->init()

    URL_initFileURLWithPath ¶

    URL_initFileURLWithPath :: proc "c" (self: ^URL, path: ^String) -> ^URL {…}
    res := url->initFileURLWithPath(path)

    URL_initWithString ¶

    URL_initWithString :: proc "c" (self: ^URL, value: ^String) -> ^URL {…}
    res := url->initWithString(value)

    URL_relativePath ¶

    URL_relativePath :: proc "c" (self: ^URL) -> ^String {…}
    relativePath := url->relativePath()

    UserDefaults_setBoolForKey ¶

    UserDefaults_setBoolForKey :: proc "c" (self: ^UserDefaults, value: bool, name: ^String) {…}
    userDefaults->setBoolForKey(value, name)

    UserDefaults_standardUserDefaults ¶ class method

    UserDefaults_standardUserDefaults :: proc "c" () -> ^UserDefaults {…}
    userDefaults := UserDefaults.standardUserDefaults()

    Value_alloc ¶ class method owned

    Value_alloc :: proc "c" () -> ^Value {…}
    value := Value.alloc()

    Value_getValue ¶

    Value_getValue :: proc "c" (self: ^Value, value: rawptr, size: UInteger) {…}
    value->getValue(value, size)

    Value_init ¶

    Value_init :: proc "c" (self: ^Value) -> ^Value {…}
    res := value->init()

    Value_initWithBytes ¶

    Value_initWithBytes :: proc "c" (self: ^Value, value: rawptr, type: cstring) -> ^Value {…}
    res := value->initWithBytes(value, type)

    Value_initWithCoder ¶

    Value_initWithCoder :: proc "c" (self: ^Value, coder: ^Coder) -> ^Value {…}
    res := value->initWithCoder(coder)

    Value_isEqualToValue ¶

    Value_isEqualToValue :: proc "c" (self, other: ^Value) -> bool {…}
    res := value->isEqualToValue(other)

    Value_objCType ¶

    Value_objCType :: proc "c" (self: ^Value) -> cstring {…}
    objCType := value->objCType()

    Value_pointerValue ¶

    Value_pointerValue :: proc "c" (self: ^Value) -> rawptr {…}
    pointerValue := value->pointerValue()

    Value_valueWithBytes ¶ class method

    Value_valueWithBytes :: proc "c" (value: rawptr, type: cstring) -> ^Value {…}
    res := Value.valueWithBytes(value, type)

    Value_valueWithPointer ¶ class method

    Value_valueWithPointer :: proc "c" (pointer: rawptr) -> ^Value {…}
    value := Value.valueWithPointer(pointer)

    View_addSubview ¶

    View_addSubview :: proc "c" (self: ^View, view: ^View) {…}
    view->addSubview(view)

    View_alloc ¶ class method owned

    View_alloc :: proc "c" () -> ^View {…}
    view := View.alloc()

    View_bounds ¶

    View_bounds :: proc "c" (self: ^View) -> CoreFoundation.CGRect {…}
    bounds := view->bounds()

    View_convertPointFromView ¶

    View_convertPointFromView :: proc "c" (
    	self:  ^View, 
    	point: CoreFoundation.CGPoint, 
    	view:  ^View, 
    ) -> CoreFoundation.CGPoint {…}
    cgPoint := view->convertPointFromView(point, view)

    View_initWithFrame ¶

    View_initWithFrame :: proc "c" (self: ^View, frame: CoreFoundation.CGRect) -> ^View {…}
    res := view->initWithFrame(frame)

    View_isFlipped ¶

    View_isFlipped :: proc "c" (self: ^View) -> bool {…}
    isFlipped := view->isFlipped()

    View_layer ¶

    View_layer :: proc "c" (self: ^View) -> ^Layer {…}
    layer := view->layer()

    View_setIsFlipped ¶

    View_setIsFlipped :: proc "c" (self: ^View, flipped: bool) {…}
    view->setIsFlipped(flipped)

    View_setLayer ¶

    View_setLayer :: proc "c" (self: ^View, layer: ^Layer) {…}
    view->setLayer(layer)

    View_setWantsLayer ¶

    View_setWantsLayer :: proc "c" (self: ^View, wantsLayer: bool) {…}
    view->setWantsLayer(wantsLayer)

    View_wantsLayer ¶

    View_wantsLayer :: proc "c" (self: ^View) -> bool {…}
    wantsLayer := view->wantsLayer()

    Window_alloc ¶ class method owned

    Window_alloc :: proc "c" () -> ^Window {…}
    window := Window.alloc()

    Window_backgroundColor ¶

    Window_backgroundColor :: proc "c" (self: ^Window) -> ^Color {…}
    backgroundColor := window->backgroundColor()

    Window_backingScaleFactor ¶

    Window_backingScaleFactor :: proc "c" (self: ^Window) -> CoreFoundation.CGFloat {…}
    backingScaleFactor := window->backingScaleFactor()

    Window_center ¶

    Window_center :: proc "c" (self: ^Window) {…}
    window->center()

    Window_close ¶

    Window_close :: proc "c" (self: ^Window) {…}
    window->close()

    Window_collectionBehavior ¶

    Window_collectionBehavior :: proc "c" (self: ^Window) -> WindowCollectionBehavior {…}
    collectionBehavior := window->collectionBehavior()

    Window_contentLayoutRect ¶

    Window_contentLayoutRect :: proc "c" (self: ^Window) -> CoreFoundation.CGRect {…}
    contentLayoutRect := window->contentLayoutRect()

    Window_contentRectForFrameRectInstance ¶

    Window_contentRectForFrameRectInstance :: proc "c" (
    	self:      ^Window, 
    	frameRect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->contentRectForFrameRect(frameRect)

    Window_contentRectForFrameRectType ¶ class method

    Window_contentRectForFrameRectType :: proc "c" (
    	frameRect: CoreFoundation.CGRect, 
    	styleMask: WindowStyleMask, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := Window.contentRectForFrameRect(frameRect, styleMask)

    Window_contentView ¶

    Window_contentView :: proc "c" (self: ^Window) -> ^View {…}
    contentView := window->contentView()

    Window_convertPointFromBacking ¶

    Window_convertPointFromBacking :: proc "c" (
    	self:  ^Window, 
    	point: CoreFoundation.CGPoint, 
    ) -> CoreFoundation.CGPoint {…}
    cgPoint := window->convertPointFromBacking(point)

    Window_convertPointFromScreen ¶

    Window_convertPointFromScreen :: proc "c" (
    	self:  ^Window, 
    	point: CoreFoundation.CGPoint, 
    ) -> CoreFoundation.CGPoint {…}
    cgPoint := window->convertPointFromScreen(point)

    Window_convertPointToBacking ¶

    Window_convertPointToBacking :: proc "c" (
    	self:  ^Window, 
    	point: CoreFoundation.CGPoint, 
    ) -> CoreFoundation.CGPoint {…}
    cgPoint := window->convertPointToBacking(point)

    Window_convertPointToScreen ¶

    Window_convertPointToScreen :: proc "c" (
    	self:  ^Window, 
    	point: CoreFoundation.CGPoint, 
    ) -> CoreFoundation.CGPoint {…}
    cgPoint := window->convertPointToScreen(point)

    Window_convertRectFromBacking ¶

    Window_convertRectFromBacking :: proc "c" (
    	self: ^Window, 
    	rect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->convertRectFromBacking(rect)

    Window_convertRectFromScreen ¶

    Window_convertRectFromScreen :: proc "c" (
    	self: ^Window, 
    	rect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->convertRectFromScreen(rect)

    Window_convertRectToBacking ¶

    Window_convertRectToBacking :: proc "c" (
    	self: ^Window, 
    	rect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->convertRectToBacking(rect)

    Window_convertRectToScreen ¶

    Window_convertRectToScreen :: proc "c" (
    	self: ^Window, 
    	rect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->convertRectToScreen(rect)

    Window_delegate ¶

    Window_delegate :: proc "c" (self: ^Window) -> ^WindowDelegate {…}
    delegate := window->delegate()

    Window_frame ¶

    Window_frame :: proc "c" (self: ^Window) -> CoreFoundation.CGRect {…}
    frame := window->frame()

    Window_frameRectForContentRectInstance ¶

    Window_frameRectForContentRectInstance :: proc "c" (
    	self:        ^Window, 
    	contentRect: CoreFoundation.CGRect, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := window->frameRectForContentRect(contentRect)

    Window_frameRectForContentRectType ¶ class method

    Window_frameRectForContentRectType :: proc "c" (
    	contentRect: CoreFoundation.CGRect, 
    	styleMask:   WindowStyleMask, 
    ) -> CoreFoundation.CGRect {…}
    cgRect := Window.frameRectForContentRect(contentRect, styleMask)

    Window_hasCloseBox ¶

    Window_hasCloseBox :: proc "c" (self: ^Window) -> bool {…}
    hasCloseBox := window->hasCloseBox()

    Window_hasTitleBar ¶

    Window_hasTitleBar :: proc "c" (self: ^Window) -> bool {…}
    hasTitleBar := window->hasTitleBar()

    Window_initWithContentRect ¶

    Window_initWithContentRect :: proc(
    	self:        ^Window, 
    	contentRect: CoreFoundation.CGRect, 
    	styleMask:   WindowStyleMask, 
    	backing:     BackingStoreType, 
    	doDefer:     bool, 
    ) -> ^Window {…}
    res := window->initWithContentRect(contentRect, styleMask, backing, doDefer)

    Window_isFloatingPanel ¶

    Window_isFloatingPanel :: proc "c" (self: ^Window) -> bool {…}
    isFloatingPanel := window->isFloatingPanel()

    Window_isMiniaturizable ¶

    Window_isMiniaturizable :: proc "c" (self: ^Window) -> bool {…}
    isMiniaturizable := window->isMiniaturizable()

    Window_isModalPanel ¶

    Window_isModalPanel :: proc "c" (self: ^Window) -> bool {…}
    isModalPanel := window->isModalPanel()

    Window_isResizable ¶

    Window_isResizable :: proc "c" (self: ^Window) -> bool {…}
    isResizable := window->isResizable()

    Window_isZoomable ¶

    Window_isZoomable :: proc "c" (self: ^Window) -> bool {…}
    isZoomable := window->isZoomable()

    Window_keyWindow ¶

    Window_keyWindow :: proc "c" (self: ^Window) -> bool {…}
    keyWindow := window->keyWindow()

    Window_mainWindow ¶

    Window_mainWindow :: proc "c" (self: ^Window) -> bool {…}
    mainWindow := window->mainWindow()

    Window_makeFirstResponder ¶

    Window_makeFirstResponder :: proc "c" (self: ^Window, responder: ^Responder) -> bool {…}
    res := window->makeFirstResponder(responder)

    Window_makeKeyAndOrderFront ¶

    Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^Object) {…}
    window->makeKeyAndOrderFront(key)

    Window_minFrameWidthWithTitle ¶ class method

    Window_minFrameWidthWithTitle :: proc "c" (
    	title:     ^String, 
    	styleMask: WindowStyleMask, 
    ) -> CoreFoundation.CGFloat {…}
    cgFloat := Window.minFrameWidthWithTitle(title, styleMask)

    Window_opaque ¶

    Window_opaque :: proc "c" (self: ^Window) -> bool {…}
    opaque := window->opaque()

    Window_orderFront ¶

    Window_orderFront :: proc "c" (self: ^Window, sender: ^intrinsics.objc_object) {…}
    window->orderFront(sender)

    Window_orderOut ¶

    Window_orderOut :: proc "c" (self: ^Window, sender: ^intrinsics.objc_object) {…}
    window->orderOut(sender)

    Window_orderedIndex ¶

    Window_orderedIndex :: proc "c" (self: ^Window) -> Integer {…}
    orderedIndex := window->orderedIndex()

    Window_parentWindow ¶

    Window_parentWindow :: proc "c" (self: ^Window) -> ^Window {…}
    parentWindow := window->parentWindow()

    Window_performClose ¶

    Window_performClose :: proc "c" (self: ^Window, sender: ^intrinsics.objc_object) {…}
    window->performClose(sender)

    Window_performWindowDragWithEvent ¶

    Window_performWindowDragWithEvent :: proc "c" (self: ^Window, event: ^Event) {…}
    window->performWindowDragWithEvent(event)

    Window_performZoom ¶

    Window_performZoom :: proc "c" (self: ^Window) {…}
    window->performZoom()

    Window_screen ¶

    Window_screen :: proc "c" (self: ^Window) -> ^Screen {…}
    screen := window->screen()

    Window_setAcceptsMouseMovedEvents ¶

    Window_setAcceptsMouseMovedEvents :: proc "c" (self: ^Window, ok: bool) {…}
    window->setAcceptsMouseMovedEvents(ok)

    Window_setBackgroundColor ¶

    Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^Color) {…}
    window->setBackgroundColor(color)

    Window_setCollectionBehavior ¶

    Window_setCollectionBehavior :: proc "c" (self: ^Window, behavior: WindowCollectionBehavior) {…}
    window->setCollectionBehavior(behavior)

    Window_setContentView ¶

    Window_setContentView :: proc "c" (self: ^Window, content_view: ^View) {…}
    window->setContentView(content_view)

    Window_setDelegate ¶

    Window_setDelegate :: proc "c" (self: ^Window, delegate: ^WindowDelegate) {…}
    window->setDelegate(delegate)

    Window_setFrame ¶

    Window_setFrame :: proc "c" (self: ^Window, frame: CoreFoundation.CGRect, display: bool) {…}
    window->setFrame(frame, display)

    Window_setFrameOrigin ¶

    Window_setFrameOrigin :: proc "c" (self: ^Window, origin: CoreFoundation.CGPoint) {…}
    window->setFrameOrigin(origin)

    Window_setIsMiniaturized ¶

    Window_setIsMiniaturized :: proc "c" (self: ^Window, ok: bool) {…}
    window->setIsMiniaturized(ok)

    Window_setIsVisible ¶

    Window_setIsVisible :: proc "c" (self: ^Window, ok: bool) {…}
    window->setIsVisible(ok)

    Window_setIsZoomed ¶

    Window_setIsZoomed :: proc "c" (self: ^Window, ok: bool) {…}
    window->setIsZoomed(ok)

    Window_setLevel ¶

    Window_setLevel :: proc "c" (self: ^Window, level: WindowLevel) {…}
    window->setLevel(level)

    Window_setMinSize ¶

    Window_setMinSize :: proc "c" (self: ^Window, size: CoreFoundation.CGSize) {…}
    window->setMinSize(size)

    Window_setMovable ¶

    Window_setMovable :: proc "c" (self: ^Window, ok: bool) {…}
    window->setMovable(ok)

    Window_setMovableByWindowBackground ¶

    Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: bool) {…}
    window->setMovableByWindowBackground(ok)

    Window_setOpaque ¶

    Window_setOpaque :: proc "c" (self: ^Window, ok: bool) {…}
    window->setOpaque(ok)

    Window_setReleasedWhenClosed ¶

    Window_setReleasedWhenClosed :: proc "c" (self: ^Window, flag: bool) {…}
    window->setReleasedWhenClosed(flag)

    Window_setRestorable ¶

    Window_setRestorable :: proc "c" (self: ^Window, flag: bool) {…}
    window->setRestorable(flag)

    Window_setStyleMask ¶

    Window_setStyleMask :: proc "c" (self: ^Window, style_mask: WindowStyleMask) {…}
    window->setStyleMask(style_mask)

    Window_setTabbingMode ¶

    Window_setTabbingMode :: proc "c" (self: ^Window, mode: WindowTabbingMode) {…}
    window->setTabbingMode(mode)

    Window_setTitle ¶

    Window_setTitle :: proc "c" (self: ^Window, title: ^String) {…}
    window->setTitle(title)

    Window_setTitleVisibility ¶

    Window_setTitleVisibility :: proc "c" (self: ^Window, visibility: Window_Title_Visibility) {…}
    window->setTitleVisibility(visibility)

    Window_setTitlebarAppearsTransparent ¶

    Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: bool) {…}
    window->setTitlebarAppearsTransparent(ok)

    Window_setToolbar ¶

    Window_setToolbar :: proc "c" (self: ^Window, toolbar: ^Toolbar) {…}
    window->setToolbar(toolbar)

    Window_setWantsLayer ¶

    Window_setWantsLayer :: proc "c" (self: ^Window, ok: bool) {…}
    window->setWantsLayer(ok)

    Window_toggleFullScreen ¶

    Window_toggleFullScreen :: proc "c" (self: ^Window, sender: ^intrinsics.objc_object) {…}
    window->toggleFullScreen(sender)

    alloc ¶

    alloc :: proc "c" ($T: typeid) -> ^T {…}

    alloc_user_object ¶

    @(require_results)
    alloc_user_object :: proc "contextless" (
    	cls:      ^intrinsics.objc_class, 
    	_context: runtime.Maybe($T=Context) = nil, 
    ) -> ^intrinsics.objc_object {…}

    application_delegate_register_and_alloc ¶

    application_delegate_register_and_alloc :: proc(
    	template:         ApplicationDelegateTemplate, 
    	class_name:       string, 
    	delegate_context: runtime.Maybe($T=Context), 
    ) -> ^ApplicationDelegate {…}

    autorelease ¶

    autorelease :: proc "c" (self: ^Object) {…}
    object->autorelease()

    bridgingCast ¶

    bridgingCast :: proc "c" ($T: typeid, obj: ^Object) {…}

    class ¶

    class :: proc "c" (self: ^Object) -> ^intrinsics.objc_class {…}
    class := object->class()

    class_addIvar ¶

    class_addIvar :: proc "c" (
    	cls:       ^intrinsics.objc_class, 
    	name:      cstring, 
    	size:      uint, 
    	alignment: u8, 
    	types:     cstring, 
    ) -> bool ---

    class_addMethod ¶

    class_addMethod :: proc "c" (
    	cls:   ^intrinsics.objc_class, 
    	name:  ^intrinsics.objc_selector, 
    	imp:   IMP, 
    	types: cstring, 
    ) -> bool ---
    External examples metal/learn_metal/02-argbuffers-no-sdl

    class_addProperty ¶

    class_addProperty :: proc "c" (
    	cls:            ^intrinsics.objc_class, 
    	name:           cstring, 
    	attributes:     [^]objc_property_attribute_t, 
    	attributeCount: uint, 
    ) -> bool ---

    class_addProtocol ¶

    class_addProtocol :: proc "c" (cls: ^intrinsics.objc_class, protocol: ^Protocol) -> bool ---

    class_conformsToProtocol ¶

    class_conformsToProtocol :: proc "c" (
    	cls:      ^intrinsics.objc_class, 
    	protocol: ^Protocol, 
    ) -> bool ---

    class_copyIvarList ¶

    class_copyIvarList :: proc "c" (cls: ^intrinsics.objc_class, outCount: ^uint) -> [^]^objc_ivar ---

    class_copyMethodList ¶

    class_copyMethodList :: proc "c" (
    	cls:      ^intrinsics.objc_class, 
    	outCount: ^uint, 
    ) -> [^]^objc_method ---

    class_copyPropertyList ¶

    class_copyPropertyList :: proc "c" (
    	cls:      ^intrinsics.objc_class, 
    	outCount: ^uint, 
    ) -> [^]^objc_property ---

    class_copyProtocolList ¶

    class_copyProtocolList :: proc "c" (
    	cls:      ^intrinsics.objc_class, 
    	outCount: ^uint, 
    ) -> [^]^Protocol ---

    class_createInstance ¶

    class_createInstance :: proc "c" (
    	cls:        ^intrinsics.objc_class, 
    	extraBytes: uint, 
    ) -> ^intrinsics.objc_object ---
    External examples metal/learn_metal/02-argbuffers-no-sdl

    class_getClassMethod ¶

    class_getClassMethod :: proc "c" (
    	cls:  ^intrinsics.objc_class, 
    	name: ^intrinsics.objc_selector, 
    ) -> ^objc_method ---

    class_getClassVariable ¶

    class_getClassVariable :: proc "c" (cls: ^intrinsics.objc_class, name: cstring) -> ^objc_ivar ---

    class_getInstanceMethod ¶

    class_getInstanceMethod :: proc "c" (
    	cls:  ^intrinsics.objc_class, 
    	name: ^intrinsics.objc_selector, 
    ) -> ^objc_method ---

    class_getInstanceSize ¶

    class_getInstanceSize :: proc "c" (cls: ^intrinsics.objc_class) -> uint ---

    class_getInstanceVariable ¶

    class_getInstanceVariable :: proc "c" (
    	cls:  ^intrinsics.objc_class, 
    	name: cstring, 
    ) -> ^objc_ivar ---

    class_getMethodImplementation ¶

    class_getMethodImplementation :: proc "c" (
    	cls:  ^intrinsics.objc_class, 
    	name: ^intrinsics.objc_selector, 
    ) -> IMP ---

    class_getName ¶

    class_getName :: proc "c" (cls: ^intrinsics.objc_class) -> cstring ---

    class_getProperty ¶

    class_getProperty :: proc "c" (cls: ^intrinsics.objc_class, name: cstring) -> ^objc_property ---

    class_getSuperclass ¶

    class_getSuperclass :: proc "c" (cls: ^intrinsics.objc_class) -> ^intrinsics.objc_class ---

    class_getVersion ¶

    class_getVersion :: proc "c" (cls: ^intrinsics.objc_class) -> i32 ---

    class_get_metaclass ¶

    @(require_results)
    class_get_metaclass :: proc "contextless" (cls: ^intrinsics.objc_class) -> ^intrinsics.objc_class {…}

    class_get_vtable_info ¶

    @(require_results)
    class_get_vtable_info :: proc "contextless" (cls: ^intrinsics.objc_class) -> ^Class_VTable_Info {…}

    class_isMetaClass ¶

    class_isMetaClass :: proc "c" (cls: ^intrinsics.objc_class) -> bool ---

    class_replaceMethod ¶

    class_replaceMethod :: proc "c" (
    	cls:   ^intrinsics.objc_class, 
    	name:  ^intrinsics.objc_selector, 
    	imp:   IMP, 
    	types: cstring, 
    ) -> IMP ---

    class_replaceProperty ¶

    class_replaceProperty :: proc "c" (
    	cls:            ^intrinsics.objc_class, 
    	name:           cstring, 
    	attributes:     [^]objc_property_attribute_t, 
    	attributeCount: uint, 
    ) ---

    class_respondsToSelector ¶

    class_respondsToSelector :: proc "c" (
    	cls: ^intrinsics.objc_class, 
    	sel: ^intrinsics.objc_selector, 
    ) -> bool ---

    class_setVersion ¶

    class_setVersion :: proc "c" (cls: ^intrinsics.objc_class, version: i32) ---

    copy ¶

    copy :: proc "c" (self: ^Copying($T)) -> ^T {…}
    copy := object->copy()

    debugDescription ¶

    debugDescription :: proc "c" (self: ^Object) -> ^String {…}
    debugDescription := object->debugDescription()

    description ¶

    description :: proc "c" (self: ^Object) -> ^String {…}
    description := object->description()

    hash ¶

    hash :: proc "c" (self: ^Object) -> UInteger {…}
    hash := object->hash()

    init ¶

    init :: proc "c" (self: ^$T) -> ^T {…}
    res := object->init()

    isEqual ¶

    isEqual :: proc "c" (self, pObject: ^Object) -> bool {…}
    res := object->isEqual(pObject)

    ivar_getName ¶

    ivar_getName :: proc "c" (v: ^objc_ivar) -> cstring ---

    ivar_getOffset ¶

    ivar_getOffset :: proc "c" (v: ^objc_ivar) -> c.ptrdiff_t ---

    ivar_getTypeEncoding ¶

    ivar_getTypeEncoding :: proc "c" (v: ^objc_ivar) -> cstring ---

    make_subclasser ¶

    @(require_results)
    make_subclasser :: proc(
    	vtable: ^$T, 
    	impl:   proc(cls: ^intrinsics.objc_class, vt: ^$T), 
    ) -> Object_VTable_Info {…}

    methodSignatureForSelector ¶

    methodSignatureForSelector :: proc "c" (
    	obj:      ^Object, 
    	selector: ^intrinsics.objc_selector, 
    ) -> rawptr {…}

    method_copyArgumentType ¶

    method_copyArgumentType :: proc "c" (m: ^objc_method, index: uint) -> cstring ---

    method_getArgumentType ¶

    method_getArgumentType :: proc "c" (m: ^objc_method, index: uint, dst: cstring, dst_len: uint) ---

    method_getImplementation ¶

    method_getImplementation :: proc "c" (m: ^objc_method) -> IMP ---

    method_getNumberOfArguments ¶

    method_getNumberOfArguments :: proc "c" (m: ^objc_method) -> uint ---

    method_getReturnType ¶

    method_getReturnType :: proc "c" (m: ^objc_method, dst: cstring, dst_len: uint) ---

    method_setImplementation ¶

    method_setImplementation :: proc "c" (m: ^objc_method, imp: IMP) ---

    msgSendSafeCheck ¶

    msgSendSafeCheck :: proc "c" (obj: ^Object, selector: ^intrinsics.objc_selector) -> bool {…}

    new ¶

    new :: proc "c" ($T: typeid) -> ^T {…}

    objc_allocateClassPair ¶

    objc_allocateClassPair :: proc "c" (
    	superclass: ^intrinsics.objc_class, 
    	name:       cstring, 
    	extraBytes: uint, 
    ) -> ^intrinsics.objc_class ---
    External examples metal/learn_metal/02-argbuffers-no-sdl

    objc_constructInstance ¶

    objc_constructInstance :: proc "c" (
    	cls:   ^intrinsics.objc_class, 
    	bytes: rawptr, 
    ) -> ^intrinsics.objc_object ---

    objc_copyClassList ¶

    objc_copyClassList :: proc "c" (outCount: ^uint) -> [^]^intrinsics.objc_class ---

    objc_copyProtocolList ¶

    objc_copyProtocolList :: proc "c" (outCount: ^uint) -> [^]^Protocol ---

    objc_destructInstance ¶

    objc_destructInstance :: proc "c" (obj: ^intrinsics.objc_object) -> rawptr ---

    objc_disposeClassPair ¶

    objc_disposeClassPair :: proc "c" (cls: ^intrinsics.objc_class) ---

    objc_duplicateClass ¶

    objc_duplicateClass :: proc "c" (
    	original:   ^intrinsics.objc_class, 
    	name:       cstring, 
    	extraBytes: uint, 
    ) -> ^intrinsics.objc_class ---

    objc_getAssociatedObject ¶

    objc_getAssociatedObject :: proc "c" (
    	object: ^intrinsics.objc_object, 
    	key:    rawptr, 
    ) -> ^intrinsics.objc_object ---

    objc_getClassList ¶

    objc_getClassList :: proc "c" (buffer: [^]^intrinsics.objc_class, bufferCount: int) -> int ---

    objc_getMetaClass ¶

    objc_getMetaClass :: proc "c" (name: cstring) -> ^intrinsics.objc_object ---

    objc_getProtocol ¶

    objc_getProtocol :: proc "c" (name: cstring) -> ^Protocol ---

    objc_getRequiredClass ¶

    objc_getRequiredClass :: proc "c" (name: cstring) -> ^intrinsics.objc_class ---

    objc_lookUpClass ¶

    objc_lookUpClass :: proc "c" (name: cstring) -> ^intrinsics.objc_class ---

    objc_registerClassPair ¶

    objc_registerClassPair :: proc "c" (cls: ^intrinsics.objc_class) ---
    External examples metal/learn_metal/02-argbuffers-no-sdl

    objc_removeAssociatedObjects ¶

    objc_removeAssociatedObjects :: proc "c" (object: ^intrinsics.objc_object) ---

    objc_setAssociatedObject ¶

    objc_setAssociatedObject :: proc "c" (
    	object: ^intrinsics.objc_object, 
    	key:    rawptr, 
    	value:  ^intrinsics.objc_object, 
    	policy: objc_AssociationPolicy, 
    ) ---

    object_copy ¶

    object_copy :: proc "c" (obj: ^intrinsics.objc_object, size: uint) -> ^intrinsics.objc_object ---

    object_dispose ¶

    object_dispose :: proc "c" (obj: ^intrinsics.objc_object) -> ^intrinsics.objc_object ---

    object_getClass ¶

    object_getClass :: proc "c" (obj: ^intrinsics.objc_object) -> ^intrinsics.objc_class ---

    object_getClassName ¶

    object_getClassName :: proc "c" (obj: ^intrinsics.objc_object) -> cstring ---

    object_getIndexedIvars ¶

    object_getIndexedIvars :: proc "c" (obj: ^intrinsics.objc_object) -> rawptr ---

    object_getInstanceVariable ¶

    object_getInstanceVariable :: proc "c" (
    	obj:      ^intrinsics.objc_object, 
    	name:     cstring, 
    	outValue: rawptr, 
    ) -> ^objc_ivar ---

    object_getIvar ¶

    object_getIvar :: proc "c" (
    	obj:  ^intrinsics.objc_object, 
    	ivar: ^objc_ivar, 
    ) -> ^intrinsics.objc_object ---

    object_get_vtable_info ¶

    @(require_results)
    object_get_vtable_info :: proc "contextless" (obj: ^intrinsics.objc_object) -> ^Class_VTable_Info {…}

    object_setClass ¶

    object_setClass :: proc "c" (
    	obj: ^intrinsics.objc_object, 
    	cls: ^intrinsics.objc_class, 
    ) -> ^intrinsics.objc_class ---

    object_setInstanceVariable ¶

    object_setInstanceVariable :: proc "c" (
    	obj:   ^intrinsics.objc_object, 
    	name:  cstring, 
    	value: rawptr, 
    ) -> ^objc_ivar ---

    object_setIvar ¶

    object_setIvar :: proc "c" (
    	obj:   ^intrinsics.objc_object, 
    	ivar:  ^objc_ivar, 
    	value: ^intrinsics.objc_object, 
    ) ---

    performSelectorOnMainThread ¶

    performSelectorOnMainThread :: proc "c" (
    	self:      ^Object, 
    	aSelector: ^intrinsics.objc_selector, 
    	arg:       ^intrinsics.objc_object, 
    	wait:      bool, 
    ) {…}
    object->performSelectorOnMainThread(aSelector, arg, wait)

    property_copyAttributeList ¶

    property_copyAttributeList :: proc "c" (
    	property: ^objc_property, 
    	outCount: ^uint, 
    ) -> [^]objc_property_attribute_t ---

    property_copyAttributeValue ¶

    property_copyAttributeValue :: proc "c" (
    	property:      ^objc_property, 
    	attributeName: cstring, 
    ) -> cstring ---

    property_getAttributes ¶

    property_getAttributes :: proc "c" (property: ^objc_property) -> cstring ---

    property_getName ¶

    property_getName :: proc "c" (property: ^objc_property) -> cstring ---

    protocol_conformsToProtocol ¶

    protocol_conformsToProtocol :: proc "c" (proto: ^Protocol, other: ^Protocol) -> bool ---

    protocol_getName ¶

    protocol_getName :: proc "c" (proto: ^Protocol) -> cstring ---

    protocol_isEqual ¶

    protocol_isEqual :: proc "c" (proto: ^Protocol, other: ^Protocol) -> bool ---

    register_subclass ¶

    @(require_results)
    register_subclass :: proc(
    	class_name:           cstring, 
    	superclass:           ^intrinsics.objc_class, 
    	superclass_overrides: runtime.Maybe($T=Object_VTable_Info) = nil, 
    	protocol:             runtime.Maybe($T=Object_VTable_Info) = nil, 
    	_context:             runtime.Maybe($T=Context) = nil, 
    ) -> ^intrinsics.objc_class {…}

    release ¶

    release :: proc "c" (self: ^Object) {…}
    object->release()

    respondsToSelector ¶

    respondsToSelector :: proc "c" (obj: ^Object, selector: ^intrinsics.objc_selector) -> bool {…}

    retain ¶

    retain :: proc "c" (self: ^Object) {…}
    object->retain()

    retainCount ¶

    retainCount :: proc "c" (self: ^Object) -> UInteger {…}
    retainCount := object->retainCount()

    scoped_autoreleasepool ¶

    @(deferred_out=AutoreleasePool_drain)
    scoped_autoreleasepool :: proc "c" () -> ^AutoreleasePool {…}
    External examples metal/learn_metal/02-argbuffers-no-sdl · metal/minimal_sdl2

    sel_getName ¶

    sel_getName :: proc "c" (sel: ^intrinsics.objc_selector) -> cstring ---

    sel_isEqual ¶

    sel_isEqual :: proc "c" (lhs, rhs: ^intrinsics.objc_selector) -> bool ---

    sel_registerName ¶

    sel_registerName :: proc "c" (name: cstring) -> ^intrinsics.objc_selector ---

    tilt ¶

    tilt :: proc "c" (self: ^Event) -> CoreFoundation.CGPoint {…}
    tilt := event->tilt()

    window_delegate_register_and_alloc ¶

    window_delegate_register_and_alloc :: proc(
    	template:         WindowDelegateTemplate, 
    	class_name:       string, 
    	delegate_context: runtime.Maybe($T=Context), 
    ) -> ^WindowDelegate {…}
    External examples metal/learn_metal/02-argbuffers-no-sdl

    Procedure Groups

    BitmapImageRep_initWithBitmapDataPlanes ¶ overloaded

    BitmapImageRep_initWithBitmapDataPlanes :: proc{
    	BitmapImageRep_initWithBitmapDataPlanes_legacy,
    	BitmapImageRep_initWithBitmapDataPlanes_bitmapFormat,
    }
    
    res := bitmapImageRep->initWithBitmapDataPlanes(
    	bitmapDataPlanes,
    	pixelsWide,
    	pixelsHigh,
    	bitsPerSample,
    	samplesPerPixel,
    	hasAlpha,
    	isPlanar,
    	colorSpaceName,
    	bytesPerRow,
    	bitsPerPixel,
    )
    res := bitmapImageRep->initWithBitmapDataPlanes(
    	bitmapDataPlanes,
    	pixelsWide,
    	pixelsHigh,
    	bitsPerSample,
    	samplesPerPixel,
    	hasAlpha,
    	isPlanar,
    	colorSpaceName,
    	bitmapFormat,
    	bytesPerRow,
    	bitsPerPixel,
    )
    MenuDelegate_menu :: proc{
    	MenuDelegate_menu_updateItem_atIndex_shouldCancel,
    	MenuDelegate_menu_willHighlightItem,
    }
    
    res := menuDelegate->menu(menu, item, index, shouldCancel)
    menuDelegate->menu(menu, item)
    Menu_paletteMenuWithColors :: proc{
    	Menu_paletteMenuWithColors_titles_selectionHandler,
    }
    
    res := menu->paletteMenuWithColors(itemTitles, onSelectionChange)

    NotificationCenter_addObserverForName ¶ overloaded

    NotificationCenter_addObserverForName :: proc{
    	NotificationCenter_addObserverForName_old,
    	NotificationCenter_addObserverForName_new,
    }
    
    object := notificationCenter->addObserverForName(name, pObj, pQueue, block)
    object := notificationCenter->addObserverForName(name, pObj, pQueue, block)

    Number_number ¶ class method overloaded

    Number_number :: proc{
    	Number_numberWithI8,
    	Number_numberWithU8,
    	Number_numberWithI16,
    	Number_numberWithU16,
    	Number_numberWithI32,
    	Number_numberWithU32,
    	Number_numberWithInt,
    	Number_numberWithUint,
    	Number_numberWithU64,
    	Number_numberWithI64,
    	Number_numberWithF32,
    	Number_numberWithF64,
    	Number_numberWithBool,
    }
    
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)
    number := Number.number(value)

    Source Files

    Generation Information

    Generated with odin version dev-2026-10 (vendor "odin") Windows_amd64 @ 2026-10-10 00:25:51.511820200 +0000 UTC