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
/

    Index

    Types (106)
    Constants (50)
    Procedures (459)
    Procedure Groups (1)

    Types

    ActivationPolicy ¶

    ActivationPolicy :: enum UInteger {
    	Regular    = 0, 
    	Accessory  = 1, 
    	Prohibited = 2, 
    }
    Related Procedures With Parameters

    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: ^.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,
    }
    Related Procedures With Parameters

    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),
    }

    AutoreleasePool ¶

    AutoreleasePool :: struct {
    	using _: Object,
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    BOOL ¶

    BOOL :: bool
     

    TODO(bill): should this be distinct?

    BackingStoreType ¶

    BackingStoreType :: enum UInteger {
    	Retained    = 0, 
    	Nonretained = 1, 
    	Buffered    = 2, 
    }
    Related Procedures With Parameters

    Block ¶

    Block :: struct {
    	using _: Object,
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    Color ¶

    Color :: struct {
    	using _: Object,
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    ComparisonResult ¶

    ComparisonResult :: enum Integer {
    	OrderedAscending  = -1, 
    	OrderedSame       = 0, 
    	OrderedDescending = 1, 
    }
    Related Procedures With Returns

    Condition ¶

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

    Copying ¶

    Copying :: struct($Value: typeid) {}

    Data ¶

    Data :: struct {
    	using _: Copying($T=Data),
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    Date ¶

    Date :: struct {
    	using _: Copying($T=Date),
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    Depth ¶

    Depth :: enum UInteger {
    	onehundredtwentyeightBitRGB = 544, 
    	sixtyfourBitRGB             = 528, 
    	twentyfourBitRGB            = 520, 
    }
    Related Procedures With Returns

    Dictionary ¶

    Dictionary :: struct {
    	using _: Copying($T=Dictionary),
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    Enumerator ¶

    Enumerator :: struct($Value: typeid) {}

    ErrorDomain ¶

    ErrorDomain :: ^String

    ErrorUserInfoKey ¶

    ErrorUserInfoKey :: ^String

    EventMask ¶

    EventMask :: distinct bit_set[EventType; UInteger]
    Related Procedures With Parameters
    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, 
    }
    Related Procedures With Returns

    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,
    }
    Related Procedures With Parameters

    IMP ¶

    IMP :: proc "c" (object: ^.objc_object, sel: ^.objc_selector, .. args: ..any) -> ^.objc_object
    Related Procedures With Parameters
    Related Procedures With Returns

    KeyEquivalentModifierFlag ¶

    KeyEquivalentModifierFlag :: enum UInteger {
    	CapsLock   = 16, // Set if Caps Lock key is pressed.
    	Shift      = 17, // Set if Shift key is pressed.
    	Control    = 18, // Set if Control key is pressed.
    	Option     = 19, // Set if Option or Alternate key is pressed.
    	Command    = 20, // Set if Command key is pressed.
    	NumericPad = 21, // Set if any key in the numeric keypad is pressed.
    	Help       = 22, // Set if the Help key is pressed.
    	Function   = 23, // Set if any function key is pressed.
    }

    KeyEquivalentModifierMask ¶

    KeyEquivalentModifierMask :: distinct bit_set[KeyEquivalentModifierFlag; UInteger]
    Related Procedures With Parameters
    Related Procedures With Returns

    Locking ¶

    Locking :: struct($Value: typeid) {}
    Related Procedures With Parameters
    Menu :: struct {
    	using _: Object,
    }
    MenuItemCallback :: proc "c" (unused: rawptr, name: ^.objc_selector, sender: ^Object)
    Related Procedures With Parameters

    ModalResponse ¶

    ModalResponse :: enum UInteger {
    	Cancel = 0, 
    	OK     = 1, 
    }
    Related Procedures With Returns

    Notification ¶

    Notification :: struct {
    	using _: Object,
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    NotificationCenter ¶

    NotificationCenter :: struct {
    	using _: Object,
    }
    Bound Objective-C Methods
    Methods Inherited From Object

    NotificationName ¶

    NotificationName :: ^String

    Number ¶

    Number :: struct {
    	using _: Copying($T=Number),
    	using _: Value,
    }
    Bound Objective-C Methods
    Methods Inherited From Value
    Methods Inherited From Object

    OperatingSystemVersion ¶

    OperatingSystemVersion :: struct #packed {
    	majorVersion: Integer,
    	minorVersion: Integer,
    	patchVersion: Integer,
    }

    Point ¶

    Point :: struct {
    	x: Float,
    	y: Float,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    PointingDeviceType ¶

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

    pointer types for NSTabletProximity events or mouse events with subtype NSTabletProximityEventSubtype

    Related Procedures With Returns

    Protocol ¶

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

    Range ¶

    Range :: struct {
    	location: UInteger,
    	length:   UInteger,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    Rect ¶

    Rect :: struct {
    	using origin: Point,
    	using size: Size,
    }
    Related Procedures With Parameters
    Related Procedures With Returns
    Procedures Through `using` From Point

    RunLoopMode ¶

    RunLoopMode :: ^String

    RunningApplication ¶

    RunningApplication :: struct {
    	using _: Object,
    }

    Set ¶

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

    Size ¶

    Size :: struct {
    	width:  Float,
    	height: Float,
    }

    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]
    Related Procedures With Parameters

    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             = 10, 
    	UTF16BigEndian    = 2415919360, 
    	UTF16LittleEndian = 2483028224, 
    	UTF32             = 2348810496, 
    	UTF32BigEndian    = 2550137088, 
    	UTF32LittleEndian = 2617245952, 
    }
    Related Procedures With Parameters

    TimeInterval ¶

    TimeInterval :: distinct f64
    Related Procedures With Parameters
    Related Procedures With Returns

    URL ¶

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

    UserDefaults ¶

    UserDefaults :: struct {
    	using _: Object,
    }

    Value ¶

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

    WindowDelegateTemplate ¶

    WindowDelegateTemplate :: struct {
    	// Managing Sheets
    	windowWillPositionSheetUsingRect:                                    proc(window: ^Window, sheet: ^Window, rect: Rect) -> Rect,
    	windowWillBeginSheet:                                                proc(notification: ^Notification),
    	windowDidEndSheet:                                                   proc(notification: ^Notification),
    	// Sizing Windows
    	windowWillResizeToSize:                                              proc(sender: ^Window, frameSize: Size) -> Size,
    	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: Rect) -> Rect,
    	windowShouldZoomToFrame:                                             proc(window: ^Window, newFrame: Rect) -> bool,
    	// Managing Full-Screen Presentation
    	windowWillUseFullScreenContentSize:                                  proc(window: ^Window, proposedSize: Size) -> Size,
    	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: ^.objc_object) -> ^.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: Point, 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: Size, maxAllowedFrameSize: Size) -> Size,
    	windowWillEnterVersionBrowser:                                       proc(notification: ^Notification),
    	windowDidEnterVersionBrowser:                                        proc(notification: ^Notification),
    	windowWillExitVersionBrowser:                                        proc(notification: ^Notification),
    	windowDidExitVersionBrowser:                                         proc(notification: ^Notification),
    }
    Related Procedures With Parameters

    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, 
    }

    kVK ¶

    kVK :: enum int {
    	ANSI_A              = 0, 
    	ANSI_S              = 1, 
    	ANSI_D              = 2, 
    	ANSI_F              = 3, 
    	ANSI_H              = 4, 
    	ANSI_G              = 5, 
    	ANSI_Z              = 6, 
    	ANSI_X              = 7, 
    	ANSI_C              = 8, 
    	ANSI_V              = 9, 
    	ANSI_B              = 11, 
    	ANSI_Q              = 12, 
    	ANSI_W              = 13, 
    	ANSI_E              = 14, 
    	ANSI_R              = 15, 
    	ANSI_Y              = 16, 
    	ANSI_T              = 17, 
    	ANSI_1              = 18, 
    	ANSI_2              = 19, 
    	ANSI_3              = 20, 
    	ANSI_4              = 21, 
    	ANSI_6              = 22, 
    	ANSI_5              = 23, 
    	ANSI_Equal          = 24, 
    	ANSI_9              = 25, 
    	ANSI_7              = 26, 
    	ANSI_Minus          = 27, 
    	ANSI_8              = 28, 
    	ANSI_0              = 29, 
    	ANSI_RightBracket   = 30, 
    	ANSI_O              = 31, 
    	ANSI_U              = 32, 
    	ANSI_LeftBracket    = 33, 
    	ANSI_I              = 34, 
    	ANSI_P              = 35, 
    	ANSI_L              = 37, 
    	ANSI_J              = 38, 
    	ANSI_Quote          = 39, 
    	ANSI_K              = 40, 
    	ANSI_Semicolon      = 41, 
    	ANSI_Backslash      = 42, 
    	ANSI_Comma          = 43, 
    	ANSI_Slash          = 44, 
    	ANSI_N              = 45, 
    	ANSI_M              = 46, 
    	ANSI_Period         = 47, 
    	ANSI_Grave          = 50, 
    	ANSI_KeypadDecimal  = 65, 
    	ANSI_KeypadMultiply = 67, 
    	ANSI_KeypadPlus     = 69, 
    	ANSI_KeypadClear    = 71, 
    	ANSI_KeypadDivide   = 75, 
    	ANSI_KeypadEnter    = 76, 
    	ANSI_KeypadMinus    = 78, 
    	ANSI_KeypadEquals   = 81, 
    	ANSI_Keypad0        = 82, 
    	ANSI_Keypad1        = 83, 
    	ANSI_Keypad2        = 84, 
    	ANSI_Keypad3        = 85, 
    	ANSI_Keypad4        = 86, 
    	ANSI_Keypad5        = 87, 
    	ANSI_Keypad6        = 88, 
    	ANSI_Keypad7        = 89, 
    	ANSI_Keypad8        = 91, 
    	ANSI_Keypad9        = 92, 
    	Return              = 36, 
    	Tab                 = 48, 
    	Space               = 49, 
    	Delete              = 51, 
    	Escape              = 53, 
    	Command             = 55, 
    	Shift               = 56, 
    	CapsLock            = 57, 
    	Option              = 58, 
    	Control             = 59, 
    	RightCommand        = 54, 
    	RightShift          = 60, 
    	RightOption         = 61, 
    	RightControl        = 62, 
    	Function            = 63, 
    	F17                 = 64, 
    	VolumeUp            = 72, 
    	VolumeDown          = 73, 
    	Mute                = 74, 
    	F18                 = 79, 
    	F19                 = 80, 
    	F20                 = 90, 
    	F5                  = 96, 
    	F6                  = 97, 
    	F7                  = 98, 
    	F3                  = 99, 
    	F8                  = 100, 
    	F9                  = 101, 
    	F11                 = 103, 
    	F13                 = 105, 
    	F16                 = 106, 
    	F14                 = 107, 
    	F10                 = 109, 
    	F12                 = 111, 
    	F15                 = 113, 
    	Help                = 114, 
    	Home                = 115, 
    	PageUp              = 116, 
    	ForwardDelete       = 117, 
    	F4                  = 118, 
    	End                 = 119, 
    	F2                  = 120, 
    	PageDown            = 121, 
    	F1                  = 122, 
    	LeftArrow           = 123, 
    	RightArrow          = 124, 
    	DownArrow           = 125, 
    	UpArrow             = 126, 
    	JIS_Yen             = 93, 
    	JIS_Underscore      = 94, 
    	JIS_KeypadComma     = 95, 
    	JIS_Eisu            = 102, 
    	JIS_Kana            = 104, 
    	ISO_Section         = 10, 
    }
     

    Defined in Carbon.framework Events.h

    objc_AssociationPolicy ¶

    objc_AssociationPolicy :: enum uintptr {
    	Assign           = 0, 
    	Retain_Nonatomic = 1, 
    	Copy_Nonatomic   = 3, 
    	Retain           = 1401, 
    	Copy             = 1403, 
    }
    Related Procedures With Parameters

    objc_cache ¶

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

    objc_class_internals ¶

    objc_class_internals :: struct {
    	isa:           ^.objc_class,
    	super_class:   ^.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
    Related Procedures With Returns

    objc_property_attribute_t ¶

    objc_property_attribute_t :: struct {
    	name:  cstring,
    	value: cstring,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    objc_protocol_list ¶

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

    unichar ¶

    unichar :: distinct u16
    Related Procedures With Returns

    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))

    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}

    IntegerMax ¶

    IntegerMax: Integer : max(Integer)

    Integermin ¶

    Integermin: Integer : min(Integer)

    NO ¶

    NO :: false

    NotFound ¶

    NotFound :: IntegerMax

    UIntegerMax ¶

    UIntegerMax: UInteger : max(UInteger)

    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}

    YES ¶

    YES :: true

    Variables

    CocoaErrorDomain ¶

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

    DebugDescriptionErrorKey ¶

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

    DefaultRunLoopMode ¶

    DefaultRunLoopMode: ^String

    EventTrackingRunLoopMode ¶

    EventTrackingRunLoopMode: ^String

    FilePathErrorKey ¶

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

    HelpAnchorErrorKey ¶

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

    KeyEventModifierFlagDeviceIndependentFlagsMask ¶

    KeyEventModifierFlagDeviceIndependentFlagsMask: KeyEquivalentModifierMask = …
     

    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 ¶

    ModalPanelRunLoopMode: ^String

    OSStatusErrorDomain ¶

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

    POSIXErrorDomain ¶

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

    RecoveryAttempterErrorKey ¶

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

    RunLoopCommonModes ¶

    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.

    AllocateObject ¶

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

    Application_activate ¶

    Application_activate :: proc "c" (
    	self: ^Application, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->activate()
    

    Application_activateIgnoringOtherApps ¶

    Application_activateIgnoringOtherApps :: proc "c" (
    	self:            ^Application, 
    	ignoreOtherApps: bool, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->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_currentEvent ¶

    Application_currentEvent :: proc "c" (
    	self: ^Application, 
    ) -> ^Event {…}
    Objective-C Method Information
    Syntax Usage
    res := self->currentEvent()
    

    Application_finishLaunching ¶

    Application_finishLaunching :: proc "c" (
    	self: ^Application, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->finishLaunching()
    

    Application_isRunning ¶

    Application_isRunning :: proc "c" (
    	self: ^Application, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->isRunning()
    

    Application_nextEventMatchingMask ¶

    Application_nextEventMatchingMask :: proc "c" (
    	self:       ^Application, 
    	mask:       EventMask, 
    	expiration: ^Date, 
    	in_mode:    ^String, 
    	dequeue:    bool, 
    ) -> ^Event {…}
    Objective-C Method Information
    Syntax Usage
    res := self->nextEventMatchingMask(
    	mask,
    	expiration,
    	in_mode,
    	dequeue,
    )
    

    Application_run ¶

    Application_run :: proc "c" (
    	self: ^Application, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->run()
    

    Application_sendEvent ¶

    Application_sendEvent :: proc "c" (
    	self:  ^Application, 
    	event: ^Event, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->sendEvent(event)
    

    Application_setActivationPolicy ¶

    Application_setActivationPolicy :: proc "c" (
    	self:             ^Application, 
    	activationPolicy: ActivationPolicy, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->setActivationPolicy(activationPolicy)
    

    Application_setDelegate ¶

    Application_setDelegate :: proc "c" (
    	self:     ^Application, 
    	delegate: ^ApplicationDelegate, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setDelegate(delegate)
    

    Application_setMainMenu ¶

    Application_setMainMenu :: proc "c" (
    	self: ^Application, 
    	menu: ^Menu, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setMainMenu(menu)
    

    Application_setTitle ¶

    Application_setTitle :: proc "c" (
    	self:  ^Application, 
    	title: ^String, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setTitle(title)
    

    Application_sharedApplication ¶

    Application_sharedApplication :: proc "c" () -> ^Application {…}
    Objective-C Method Information
    • Class: Application
    • Name: sharedApplication
    • Kind: Class Method
    Syntax Usage
    res := Application.sharedApplication()
    

    Application_terminate ¶

    Application_terminate :: proc "c" (
    	self:   ^Application, 
    	sender: ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->terminate(sender)
    

    Application_updateWindows ¶

    Application_updateWindows :: proc "c" (
    	self: ^Application, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->updateWindows()
    

    Application_windows ¶

    Application_windows :: proc "c" (
    	self: ^Application, 
    ) -> ^Array {…}
    Objective-C Method Information
    Syntax Usage
    res := self->windows()
    

    Array_alloc ¶

    Array_alloc :: proc "c" () -> ^Array {…}
    Objective-C Method Information
    • Class: Array
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Array.alloc()
    

    Array_count ¶

    Array_count :: proc "c" (
    	self: ^Array, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Array
    • Name: count
    Syntax Usage
    res := self->count()
    

    Array_init ¶

    Array_init :: proc "c" (
    	self: ^Array, 
    ) -> ^Array {…}
    Objective-C Method Information
    • Class: Array
    • Name: init
    Syntax Usage
    res := self->init()
    

    Array_initWithCoder ¶

    Array_initWithCoder :: proc "c" (
    	self:  ^Array, 
    	coder: ^Coder, 
    ) -> ^Array {…}
    Objective-C Method Information
    • Class: Array
    • Name: initWithCoder
    Syntax Usage
    res := self->initWithCoder(coder)
    

    Array_initWithObjects ¶

    Array_initWithObjects :: proc "c" (
    	self:    ^Array, 
    	objects: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Array {…}
    Objective-C Method Information
    • Class: Array
    • Name: initWithObjects
    Syntax Usage
    res := self->initWithObjects(
    	objects,
    	count,
    )
    

    Array_object ¶

    Array_object :: proc "c" (
    	self:  ^Array, 
    	index: UInteger, 
    ) -> ^Object {…}
    Objective-C Method Information
    • Class: Array
    • Name: object
    Syntax Usage
    res := self->object(index)
    

    Array_objectAs ¶

    Array_objectAs :: proc "c" (
    	self:  ^Array, 
    	index: UInteger, 
    	$T:     typeid, 
    ) -> typeid {…}
    Objective-C Method Information
    • Class: Array
    • Name: objectAs
    Syntax Usage
    res := self->objectAs(
    	index,
    	T,
    )
    

    AutoreleasePool_addObject ¶

    AutoreleasePool_addObject :: proc "c" (
    	self: ^AutoreleasePool, 
    	obj:  ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->addObject(obj)
    

    AutoreleasePool_alloc ¶

    AutoreleasePool_alloc :: proc "c" () -> ^AutoreleasePool {…}
    Objective-C Method Information
    Syntax Usage
    res := AutoreleasePool.alloc()
    

    AutoreleasePool_drain ¶

    AutoreleasePool_drain :: proc "c" (
    	self: ^AutoreleasePool, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->drain()
    

    AutoreleasePool_init ¶

    AutoreleasePool_init :: proc "c" (
    	self: ^AutoreleasePool, 
    ) -> ^AutoreleasePool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    AutoreleasePool_showPools ¶

    AutoreleasePool_showPools :: proc "c" (
    	self: ^AutoreleasePool, 
    	obj:  ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->showPools(obj)
    

    Block_createGlobal ¶

    Block_createGlobal :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (
    	user_data: rawptr, 
    ), 
    	allocator := context.allocator, 
    ) -> (^Block, runtime.Allocator_Error) #optional_ok {…}
    Objective-C Method Information
    • Class: Block
    • Name: createGlobal
    • Kind: Class Method
    Syntax Usage
    res0, res1 := Block.createGlobal(
    	user_data,
    	user_proc,
    	allocator,
    )
    

    Block_createGlobalWithParam ¶

    Block_createGlobalWithParam :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (
    	user_data: rawptr, 
    	t:         $T, 
    ), 
    	allocator := context.allocator, 
    ) -> (^Block, runtime.Allocator_Error) #optional_ok {…}
    Objective-C Method Information
    • Class: Block
    • Name: createGlobalWithParam
    • Kind: Class Method
    Syntax Usage
    res0, res1 := Block.createGlobalWithParam(
    	user_data,
    	user_proc,
    	allocator,
    )
    

    Block_createLocal ¶

    Block_createLocal :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (
    	user_data: rawptr, 
    ), 
    ) -> ^Block {…}
    Objective-C Method Information
    • Class: Block
    • Name: createLocal
    • Kind: Class Method
    Syntax Usage
    res := Block.createLocal(
    	user_data,
    	user_proc,
    )
    

    Block_createLocalWithParam ¶

    Block_createLocalWithParam :: proc(
    	user_data: rawptr, 
    	user_proc: proc "c" (
    	user_data: rawptr, 
    	t:         $T, 
    ), 
    ) -> ^Block {…}
    Objective-C Method Information
    • Class: Block
    • Name: createLocalWithParam
    • Kind: Class Method
    Syntax Usage
    res := Block.createLocalWithParam(
    	user_data,
    	user_proc,
    )
    

    Bundle_PathForAuxiliaryExecutable ¶

    Bundle_PathForAuxiliaryExecutable :: proc "c" (
    	self:           ^Bundle, 
    	executableName: ^String, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: PathForAuxiliaryExecutable
    Syntax Usage
    res := self->PathForAuxiliaryExecutable(executableName)
    

    Bundle_URLForAuxiliaryExecutable ¶

    Bundle_URLForAuxiliaryExecutable :: proc "c" (
    	self:           ^Bundle, 
    	executableName: ^String, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: URLForAuxiliaryExecutable
    Syntax Usage
    res := self->URLForAuxiliaryExecutable(executableName)
    

    Bundle_allBundles ¶

    Bundle_allBundles :: proc "c" () -> (all: ^Array) {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: allBundles
    Syntax Usage
    all := self->allBundles()
    

    Bundle_allFrameworks ¶

    Bundle_allFrameworks :: proc "c" () -> (all: ^Array) {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: allFrameworks
    Syntax Usage
    all := self->allFrameworks()
    

    Bundle_alloc ¶

    Bundle_alloc :: proc "c" () -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Bundle.alloc()
    

    Bundle_appStoreReceiptPath ¶

    Bundle_appStoreReceiptPath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: appStoreReceiptPath
    Syntax Usage
    res := self->appStoreReceiptPath()
    

    Bundle_appStoreReceiptURL ¶

    Bundle_appStoreReceiptURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: appStoreReceiptURL
    Syntax Usage
    res := self->appStoreReceiptURL()
    

    Bundle_builtInPlugInsPath ¶

    Bundle_builtInPlugInsPath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: builtInPlugInsPath
    Syntax Usage
    res := self->builtInPlugInsPath()
    

    Bundle_builtInPlugInsURL ¶

    Bundle_builtInPlugInsURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: builtInPlugInsURL
    Syntax Usage
    res := self->builtInPlugInsURL()
    

    Bundle_bundleIdentifier ¶

    Bundle_bundleIdentifier :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: bundleIdentifier
    Syntax Usage
    res := self->bundleIdentifier()
    

    Bundle_bundlePath ¶

    Bundle_bundlePath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: bundlePath
    Syntax Usage
    res := self->bundlePath()
    

    Bundle_bundleURL ¶

    Bundle_bundleURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: bundleURL
    Syntax Usage
    res := self->bundleURL()
    

    Bundle_bundleWithPath ¶

    Bundle_bundleWithPath :: proc "c" (
    	path: ^String, 
    ) -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: bundleWithPath
    • Kind: Class Method
    Syntax Usage
    res := Bundle.bundleWithPath(path)
    

    Bundle_bundleWithURL ¶

    Bundle_bundleWithURL :: proc "c" (
    	url: ^URL, 
    ) -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: bundleWithURL
    • Kind: Class Method
    Syntax Usage
    res := Bundle.bundleWithURL(url)
    

    Bundle_executablePath ¶

    Bundle_executablePath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: executablePath
    Syntax Usage
    res := self->executablePath()
    

    Bundle_executableURL ¶

    Bundle_executableURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: executableURL
    Syntax Usage
    res := self->executableURL()
    

    Bundle_infoDictionary ¶

    Bundle_infoDictionary :: proc "c" (
    	self: ^Bundle, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: infoDictionary
    Syntax Usage
    res := self->infoDictionary()
    

    Bundle_init ¶

    Bundle_init :: proc "c" (
    	self: ^Bundle, 
    ) -> ^Bundle {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Bundle_initWithPath ¶

    Bundle_initWithPath :: proc "c" (
    	self: ^Bundle, 
    	path: ^String, 
    ) -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: initWithPath
    Syntax Usage
    res := self->initWithPath(path)
    

    Bundle_initWithURL ¶

    Bundle_initWithURL :: proc "c" (
    	self: ^Bundle, 
    	url:  ^URL, 
    ) -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: initWithURL
    Syntax Usage
    res := self->initWithURL(url)
    

    Bundle_isLoaded ¶

    Bundle_isLoaded :: proc "c" (
    	self: ^Bundle, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: isLoaded
    Syntax Usage
    res := self->isLoaded()
    

    Bundle_load ¶

    Bundle_load :: proc "c" (
    	self: ^Bundle, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->load()
    

    Bundle_loadAndReturnError ¶

    Bundle_loadAndReturnError :: proc "contextless" (
    	self: ^Bundle, 
    ) -> (ok: bool, error: ^Error) {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: loadAndReturnError
    Syntax Usage
    ok, error := self->loadAndReturnError()
    

    Bundle_localizedInfoDictionary ¶

    Bundle_localizedInfoDictionary :: proc "c" (
    	self: ^Bundle, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: localizedInfoDictionary
    Syntax Usage
    res := self->localizedInfoDictionary()
    

    Bundle_localizedStringForKey ¶

    Bundle_localizedStringForKey :: proc "c" (
    	self:      ^Bundle, 
    	key:       ^String, 
    	value:     ^String = nil, 
    	tableName: ^String = nil, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: localizedStringForKey
    Syntax Usage
    res := self->localizedStringForKey(
    	key,
    	value,
    	tableName,
    )
    

    Bundle_mainBundle ¶

    Bundle_mainBundle :: proc "c" () -> ^Bundle {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: mainBundle
    • Kind: Class Method
    Syntax Usage
    res := Bundle.mainBundle()
    

    Bundle_objectForInfoDictionaryKey ¶

    Bundle_objectForInfoDictionaryKey :: proc "c" (
    	self: ^Bundle, 
    	key:  ^String, 
    ) -> ^Object {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: objectForInfoDictionaryKey
    Syntax Usage
    res := self->objectForInfoDictionaryKey(key)
    

    Bundle_preflightAndReturnError ¶

    Bundle_preflightAndReturnError :: proc "contextless" (
    	self: ^Bundle, 
    ) -> (ok: bool, error: ^Error) {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: preflightAndReturnError
    Syntax Usage
    ok, error := self->preflightAndReturnError()
    

    Bundle_privateFrameworksPath ¶

    Bundle_privateFrameworksPath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: privateFrameworksPath
    Syntax Usage
    res := self->privateFrameworksPath()
    

    Bundle_privateFrameworksURL ¶

    Bundle_privateFrameworksURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: privateFrameworksURL
    Syntax Usage
    res := self->privateFrameworksURL()
    

    Bundle_resourcePath ¶

    Bundle_resourcePath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: resourcePath
    Syntax Usage
    res := self->resourcePath()
    

    Bundle_resourceURL ¶

    Bundle_resourceURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: resourceURL
    Syntax Usage
    res := self->resourceURL()
    

    Bundle_sharedFrameworksPath ¶

    Bundle_sharedFrameworksPath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: sharedFrameworksPath
    Syntax Usage
    res := self->sharedFrameworksPath()
    

    Bundle_sharedFrameworksURL ¶

    Bundle_sharedFrameworksURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: sharedFrameworksURL
    Syntax Usage
    res := self->sharedFrameworksURL()
    

    Bundle_sharedSupportPath ¶

    Bundle_sharedSupportPath :: proc "c" (
    	self: ^Bundle, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: sharedSupportPath
    Syntax Usage
    res := self->sharedSupportPath()
    

    Bundle_sharedSupportURL ¶

    Bundle_sharedSupportURL :: proc "c" (
    	self: ^Bundle, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: Bundle
    • Name: sharedSupportURL
    Syntax Usage
    res := self->sharedSupportURL()
    

    Bundle_unload ¶

    Bundle_unload :: proc "c" (
    	self: ^Bundle, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->unload()
    

    ClassFromString ¶

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

    Color_blackColor ¶

    Color_blackColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: blackColor
    • Kind: Class Method
    Syntax Usage
    res := Color.blackColor()
    

    Color_blueColor ¶

    Color_blueColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: blueColor
    • Kind: Class Method
    Syntax Usage
    res := Color.blueColor()
    

    Color_colorSpace ¶

    Color_colorSpace :: proc "c" (
    	self: ^Color, 
    ) -> ^ColorSpace {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorSpace
    Syntax Usage
    res := self->colorSpace()
    

    Color_colorSpaceName ¶

    Color_colorSpaceName :: proc "c" (
    	self: ^Color, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorSpaceName
    Syntax Usage
    res := self->colorSpaceName()
    

    Color_colorUsingColorSpaceName ¶

    Color_colorUsingColorSpaceName :: proc "c" (
    	self:       ^Color, 
    	colorSpace: ^String, 
    	device:     ^Dictionary = nil, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorUsingColorSpaceName
    Syntax Usage
    res := self->colorUsingColorSpaceName(
    	colorSpace,
    	device,
    )
    

    Color_colorWithCalibratedHue ¶

    Color_colorWithCalibratedHue :: proc "c" (
    	hue, saturation, brightness, 
    	alpha:                       Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithCalibratedHue
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithCalibratedHue(
    	hue,
    	saturation,
    	brightness,
    	alpha,
    )
    

    Color_colorWithCalibratedRed ¶

    Color_colorWithCalibratedRed :: proc "c" (
    	red, green, blue, 
    	alpha:            Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithCalibratedRed
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithCalibratedRed(
    	red,
    	green,
    	blue,
    	alpha,
    )
    

    Color_colorWithCalibratedWhite ¶

    Color_colorWithCalibratedWhite :: proc "c" (
    	white, 
    	alpha: Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithCalibratedWhite
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithCalibratedWhite(
    	white,
    	alpha,
    )
    

    Color_colorWithColorSpace ¶

    Color_colorWithColorSpace :: proc "c" (
    	space:      ^ColorSpace, 
    	components: []Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithColorSpace
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithColorSpace(
    	space,
    	components,
    )
    

    Color_colorWithDeviceCyan ¶

    Color_colorWithDeviceCyan :: proc "c" (
    	cyan, magenta, yellow, black, 
    	alpha:                        Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithDeviceCyan
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithDeviceCyan(
    	cyan,
    	magenta,
    	yellow,
    	black,
    	alpha,
    )
    

    Color_colorWithDeviceHue ¶

    Color_colorWithDeviceHue :: proc "c" (
    	hue, saturation, brightness, 
    	alpha:                       Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithDeviceHue
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithDeviceHue(
    	hue,
    	saturation,
    	brightness,
    	alpha,
    )
    

    Color_colorWithDeviceRed ¶

    Color_colorWithDeviceRed :: proc "c" (
    	red, green, blue, 
    	alpha:            Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithDeviceRed
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithDeviceRed(
    	red,
    	green,
    	blue,
    	alpha,
    )
    

    Color_colorWithDeviceWhite ¶

    Color_colorWithDeviceWhite :: proc "c" (
    	white, 
    	alpha: Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithDeviceWhite
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithDeviceWhite(
    	white,
    	alpha,
    )
    

    Color_colorWithSRGBRed ¶

    Color_colorWithSRGBRed :: proc "c" (
    	red, green, blue, 
    	alpha:            Float, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: colorWithSRGBRed
    • Kind: Class Method
    Syntax Usage
    res := Color.colorWithSRGBRed(
    	red,
    	green,
    	blue,
    	alpha,
    )
    

    Color_cyanColor ¶

    Color_cyanColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: cyanColor
    • Kind: Class Method
    Syntax Usage
    res := Color.cyanColor()
    

    Color_getCMYKA ¶

    Color_getCMYKA :: proc "c" (
    	self: ^Color, 
    ) -> (cyan, magenta, yellow, black, alpha: Float) {…}
    Objective-C Method Information
    • Class: Color
    • Name: getCMYKA
    Syntax Usage
    cyan, magenta, yellow, black, alpha := self->getCMYKA()
    

    Color_getComponents ¶

    Color_getComponents :: proc "c" (
    	self:       ^Color, 
    	components: [^]Float, 
    ) {…}
    Objective-C Method Information
    • Class: Color
    • Name: getComponents
    Syntax Usage
    self->getComponents(components)
    

    Color_getHSBA ¶

    Color_getHSBA :: proc "c" (
    	self: ^Color, 
    ) -> (hue, saturation, brightness, alpha: Float) {…}
    Objective-C Method Information
    • Class: Color
    • Name: getHSBA
    Syntax Usage
    hue, saturation, brightness, alpha := self->getHSBA()
    

    Color_getRGBA ¶

    Color_getRGBA :: proc "c" (
    	self: ^Color, 
    ) -> (red, green, blue, alpha: Float) {…}
    Objective-C Method Information
    • Class: Color
    • Name: getRGBA
    Syntax Usage
    red, green, blue, alpha := self->getRGBA()
    

    Color_getWhiteAlpha ¶

    Color_getWhiteAlpha :: proc "c" (
    	self: ^Color, 
    ) -> (white, alpha: Float) {…}
    Objective-C Method Information
    • Class: Color
    • Name: getWhiteAlpha
    Syntax Usage
    white, alpha := self->getWhiteAlpha()
    

    Color_greenColor ¶

    Color_greenColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: greenColor
    • Kind: Class Method
    Syntax Usage
    res := Color.greenColor()
    

    Color_magentaColor ¶

    Color_magentaColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: magentaColor
    • Kind: Class Method
    Syntax Usage
    res := Color.magentaColor()
    

    Color_numberOfComponents ¶

    Color_numberOfComponents :: proc "c" (
    	self: ^Color, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Color
    • Name: numberOfComponents
    Syntax Usage
    res := self->numberOfComponents()
    

    Color_orangeColor ¶

    Color_orangeColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: orangeColor
    • Kind: Class Method
    Syntax Usage
    res := Color.orangeColor()
    

    Color_purpleColor ¶

    Color_purpleColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: purpleColor
    • Kind: Class Method
    Syntax Usage
    res := Color.purpleColor()
    

    Color_redColor ¶

    Color_redColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: redColor
    • Kind: Class Method
    Syntax Usage
    res := Color.redColor()
    

    Color_whiteColor ¶

    Color_whiteColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: whiteColor
    • Kind: Class Method
    Syntax Usage
    res := Color.whiteColor()
    

    Color_yellowColor ¶

    Color_yellowColor :: proc "c" () -> ^Color {…}
    Objective-C Method Information
    • Class: Color
    • Name: yellowColor
    • Kind: Class Method
    Syntax Usage
    res := Color.yellowColor()
    

    Condition_alloc ¶

    Condition_alloc :: proc "c" () -> ^Condition {…}
    Objective-C Method Information
    • Class: Condition
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Condition.alloc()
    

    Condition_broadcast ¶

    Condition_broadcast :: proc "c" (
    	self: ^Condition, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->broadcast()
    

    Condition_init ¶

    Condition_init :: proc "c" (
    	self: ^Condition, 
    ) -> ^Condition {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Condition_lock ¶

    Condition_lock :: proc "c" (
    	self: ^Condition, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->lock()
    

    Condition_signal ¶

    Condition_signal :: proc "c" (
    	self: ^Condition, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->signal()
    

    Condition_unlock ¶

    Condition_unlock :: proc "c" (
    	self: ^Condition, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->unlock()
    

    Condition_wait ¶

    Condition_wait :: proc "c" (
    	self: ^Condition, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->wait()
    

    Condition_waitUntilDate ¶

    Condition_waitUntilDate :: proc "c" (
    	self:  ^Condition, 
    	limit: ^Date, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->waitUntilDate(limit)
    

    Data_alloc ¶

    Data_alloc :: proc "c" () -> ^Data {…}
    Objective-C Method Information
    • Class: Data
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Data.alloc()
    

    Data_init ¶

    Data_init :: proc "c" (
    	self: ^Data, 
    ) -> ^Data {…}
    Objective-C Method Information
    • Class: Data
    • Name: init
    Syntax Usage
    res := self->init()
    

    Data_length ¶

    Data_length :: proc "c" (
    	self: ^Data, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Data
    • Name: length
    Syntax Usage
    res := self->length()
    

    Data_mutableBytes ¶

    Data_mutableBytes :: proc "c" (
    	self: ^Data, 
    ) -> rawptr {…}
    Objective-C Method Information
    • Class: Data
    • Name: mutableBytes
    Syntax Usage
    res := self->mutableBytes()
    

    Date_alloc ¶

    Date_alloc :: proc "c" () -> ^Date {…}
    Objective-C Method Information
    • Class: Date
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Date.alloc()
    

    Date_dateWithTimeIntervalSinceNow ¶

    Date_dateWithTimeIntervalSinceNow :: proc "c" (
    	secs: TimeInterval, 
    ) -> ^Date {…}
    Objective-C Method Information
    • Class: Date
    • Name: dateWithTimeIntervalSinceNow
    Syntax Usage
    res := self->dateWithTimeIntervalSinceNow()
    

    Date_distantFuture ¶

    Date_distantFuture :: proc "c" () -> ^Date {…}
    Objective-C Method Information
    • Class: Date
    • Name: distantFuture
    • Kind: Class Method
    Syntax Usage
    res := Date.distantFuture()
    

    Date_distantPast ¶

    Date_distantPast :: proc "c" () -> ^Date {…}
    Objective-C Method Information
    • Class: Date
    • Name: distantPast
    • Kind: Class Method
    Syntax Usage
    res := Date.distantPast()
    

    Date_init ¶

    Date_init :: proc "c" (
    	self: ^Date, 
    ) -> ^Date {…}
    Objective-C Method Information
    • Class: Date
    • Name: init
    Syntax Usage
    res := self->init()
    

    DeallocateObject ¶

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

    Dictionary_alloc ¶

    Dictionary_alloc :: proc "c" () -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Dictionary
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Dictionary.alloc()
    

    Dictionary_count ¶

    Dictionary_count :: proc "c" (
    	self: ^Dictionary, 
    ) -> UInteger {…}
    Objective-C Method Information
    Syntax Usage
    res := self->count()
    

    Dictionary_dictionary ¶

    Dictionary_dictionary :: proc "c" () -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Dictionary
    • Name: dictionary
    • Kind: Class Method
    Syntax Usage
    res := Dictionary.dictionary()
    

    Dictionary_dictionaryWithObject ¶

    Dictionary_dictionaryWithObject :: proc "c" (
    	object: ^Object, 
    	forKey: ^Object, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Dictionary
    • Name: dictionaryWithObject
    • Kind: Class Method
    Syntax Usage
    res := Dictionary.dictionaryWithObject(
    	object,
    	forKey,
    )
    

    Dictionary_dictionaryWithObjects ¶

    Dictionary_dictionaryWithObjects :: proc "c" (
    	objects: [^]^Object, 
    	forKeys: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Dictionary
    • Name: dictionaryWithObjects
    • Kind: Class Method
    Syntax Usage
    res := Dictionary.dictionaryWithObjects(
    	objects,
    	forKeys,
    	count,
    )
    

    Dictionary_init ¶

    Dictionary_init :: proc "c" (
    	self: ^Dictionary, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Dictionary_initWithObjects ¶

    Dictionary_initWithObjects :: proc "c" (
    	self:    ^Dictionary, 
    	objects: [^]^Object, 
    	forKeys: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    Syntax Usage
    res := self->initWithObjects(
    	objects,
    	forKeys,
    	count,
    )
    

    Dictionary_keyEnumerator ¶

    Dictionary_keyEnumerator :: proc "c" (
    	self:    ^Dictionary, 
    	$KeyType: typeid, 
    ) -> (enumerator: ^Enumerator($T=typeid)) {…}
    Objective-C Method Information
    Syntax Usage
    enumerator := self->keyEnumerator(KeyType)
    

    Dictionary_objectForKey ¶

    Dictionary_objectForKey :: proc "c" (
    	self: ^Dictionary, 
    	key:  ^Object, 
    ) -> ^Object {…}
    Objective-C Method Information
    Syntax Usage
    res := self->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 ¶

    Error_alloc :: proc "c" () -> ^Error {…}
    Objective-C Method Information
    • Class: Error
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Error.alloc()
    

    Error_code ¶

    Error_code :: proc "c" (
    	self: ^Error, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Error
    • Name: code
    Syntax Usage
    res := self->code()
    

    Error_domain ¶

    Error_domain :: proc "c" (
    	self: ^Error, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Error
    • Name: domain
    Syntax Usage
    res := self->domain()
    

    Error_errorWithDomain ¶

    Error_errorWithDomain :: proc "c" (
    	domain:   ^String, 
    	code:     Integer, 
    	userInfo: ^Dictionary, 
    ) -> ^Error {…}
    Objective-C Method Information
    • Class: Error
    • Name: errorWithDomain
    • Kind: Class Method
    Syntax Usage
    res := Error.errorWithDomain(
    	domain,
    	code,
    	userInfo,
    )
    

    Error_init ¶

    Error_init :: proc "c" (
    	self: ^Error, 
    ) -> ^Error {…}
    Objective-C Method Information
    • Class: Error
    • Name: init
    Syntax Usage
    res := self->init()
    

    Error_initWithDomain ¶

    Error_initWithDomain :: proc "c" (
    	self:     ^Error, 
    	domain:   ^String, 
    	code:     Integer, 
    	userInfo: ^Dictionary, 
    ) -> ^Error {…}
    Objective-C Method Information
    • Class: Error
    • Name: initWithDomain
    Syntax Usage
    res := self->initWithDomain(
    	domain,
    	code,
    	userInfo,
    )
    

    Error_localizedDescription ¶

    Error_localizedDescription :: proc "c" (
    	self: ^Error, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Error
    • Name: localizedDescription
    Syntax Usage
    res := self->localizedDescription()
    

    Error_localizedFailureReason ¶

    Error_localizedFailureReason :: proc "c" (
    	self: ^Error, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Error
    • Name: localizedFailureReason
    Syntax Usage
    res := self->localizedFailureReason()
    

    Error_localizedRecoveryOptions ¶

    Error_localizedRecoveryOptions :: proc "c" (
    	self: ^Error, 
    ) -> (options: ^Array) {…}
    Objective-C Method Information
    • Class: Error
    • Name: localizedRecoveryOptions
    Syntax Usage
    options := self->localizedRecoveryOptions()
    

    Error_localizedRecoverySuggestion ¶

    Error_localizedRecoverySuggestion :: proc "c" (
    	self: ^Error, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Error
    • Name: localizedRecoverySuggestion
    Syntax Usage
    res := self->localizedRecoverySuggestion()
    

    Error_userInfo ¶

    Error_userInfo :: proc "c" (
    	self: ^Error, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    • Class: Error
    • Name: userInfo
    Syntax Usage
    res := self->userInfo()
    

    Event_absolute ¶

    Event_absolute :: proc "c" (
    	self: ^Event, 
    ) -> (x, y, z: Integer) {…}
    Objective-C Method Information
    • Class: Event
    • Name: absolute
    Syntax Usage
    x, y, z := self->absolute()
    

    Event_absoluteX ¶

    Event_absoluteX :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: absoluteX
    Syntax Usage
    res := self->absoluteX()
    

    Event_absoluteY ¶

    Event_absoluteY :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: absoluteY
    Syntax Usage
    res := self->absoluteY()
    

    Event_absoluteZ ¶

    Event_absoluteZ :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: absoluteZ
    Syntax Usage
    res := self->absoluteZ()
    

    Event_buttonMask ¶

    Event_buttonMask :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: buttonMask
    Syntax Usage
    res := self->buttonMask()
    

    Event_buttonNumber ¶

    Event_buttonNumber :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: buttonNumber
    Syntax Usage
    res := self->buttonNumber()
    
     

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

    Event_capabilityMask ¶

    Event_capabilityMask :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: capabilityMask
    Syntax Usage
    res := self->capabilityMask()
    

    Event_characters ¶

    Event_characters :: proc "c" (
    	self: ^Event, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Event
    • Name: characters
    Syntax Usage
    res := self->characters()
    

    Event_charactersIgnoringModifiers ¶

    Event_charactersIgnoringModifiers :: proc "c" (
    	self: ^Event, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Event
    • Name: charactersIgnoringModifiers
    Syntax Usage
    res := self->charactersIgnoringModifiers()
    

    Event_clickCount ¶

    Event_clickCount :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: clickCount
    Syntax Usage
    res := self->clickCount()
    

    Event_data1 ¶

    Event_data1 :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: data1
    Syntax Usage
    res := self->data1()
    

    Event_data2 ¶

    Event_data2 :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: data2
    Syntax Usage
    res := self->data2()
    

    Event_delta ¶

    Event_delta :: proc "c" (
    	self: ^Event, 
    ) -> (x, y, z: Float) {…}
    Objective-C Method Information
    • Class: Event
    • Name: delta
    Syntax Usage
    x, y, z := self->delta()
    

    Event_deltaX ¶

    Event_deltaX :: proc "c" (
    	self: ^Event, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Event
    • Name: deltaX
    Syntax Usage
    res := self->deltaX()
    

    Event_deltaY ¶

    Event_deltaY :: proc "c" (
    	self: ^Event, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Event
    • Name: deltaY
    Syntax Usage
    res := self->deltaY()
    

    Event_deltaZ ¶

    Event_deltaZ :: proc "c" (
    	self: ^Event, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Event
    • Name: deltaZ
    Syntax Usage
    res := self->deltaZ()
    

    Event_eventNumber ¶

    Event_eventNumber :: proc "c" (
    	self: ^Event, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Event
    • Name: eventNumber
    Syntax Usage
    res := self->eventNumber()
    
     

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

    Event_hasPreciseScrollingDeltas ¶

    Event_hasPreciseScrollingDeltas :: proc "c" (
    	self: ^Event, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Event
    • Name: hasPreciseScrollingDeltas
    Syntax Usage
    res := self->hasPreciseScrollingDeltas()
    

    Event_isARepeat ¶

    Event_isARepeat :: proc "c" (
    	self: ^Event, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Event
    • Name: isARepeat
    Syntax Usage
    res := self->isARepeat()
    

    Event_isDirectionInvertedFromDevice ¶

    Event_isDirectionInvertedFromDevice :: proc "c" (
    	self: ^Event, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Event
    • Name: isDirectionInvertedFromDevice
    Syntax Usage
    res := self->isDirectionInvertedFromDevice()
    

    Event_isEnteringProximity ¶

    Event_isEnteringProximity :: proc "c" (
    	self: ^Event, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Event
    • Name: isEnteringProximity
    Syntax Usage
    res := self->isEnteringProximity()
    

    Event_isSwipeTrackingFromScrollEventsEnabled ¶

    Event_isSwipeTrackingFromScrollEventsEnabled :: proc "c" (
    	self: ^Event, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Event
    • Name: isSwipeTrackingFromScrollEventsEnabled
    Syntax Usage
    res := self->isSwipeTrackingFromScrollEventsEnabled()
    

    Event_keyCode ¶

    Event_keyCode :: proc "c" (
    	self: ^Event, 
    ) -> u16 {…}
    Objective-C Method Information
    • Class: Event
    • Name: keyCode
    Syntax Usage
    res := self->keyCode()
    

    Event_locationInWindow ¶

    Event_locationInWindow :: proc "c" (
    	self: ^Event, 
    ) -> Point {…}
    Objective-C Method Information
    • Class: Event
    • Name: locationInWindow
    Syntax Usage
    res := self->locationInWindow()
    
     

    -locationInWindow is valid for all mouse-related events

    Event_modifierFlags ¶

    Event_modifierFlags :: proc "c" (
    	self: ^Event, 
    ) -> EventModifierFlags {…}
    Objective-C Method Information
    • Class: Event
    • Name: modifierFlags
    Syntax Usage
    res := self->modifierFlags()
    

    Event_momentumPhase ¶

    Event_momentumPhase :: proc "c" (
    	self: ^Event, 
    ) -> EventPhase {…}
    Objective-C Method Information
    • Class: Event
    • Name: momentumPhase
    Syntax Usage
    res := self->momentumPhase()
    

    Event_phase ¶

    Event_phase :: proc "c" (
    	self: ^Event, 
    ) -> EventPhase {…}
    Objective-C Method Information
    • Class: Event
    • Name: phase
    Syntax Usage
    res := self->phase()
    

    Event_pointingDeviceID ¶

    Event_pointingDeviceID :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: pointingDeviceID
    Syntax Usage
    res := self->pointingDeviceID()
    

    Event_pointingDeviceSerialNumber ¶

    Event_pointingDeviceSerialNumber :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: pointingDeviceSerialNumber
    Syntax Usage
    res := self->pointingDeviceSerialNumber()
    

    Event_pointingDeviceType ¶

    Event_pointingDeviceType :: proc "c" (
    	self: ^Event, 
    ) -> PointingDeviceType {…}
    Objective-C Method Information
    • Class: Event
    • Name: pointingDeviceType
    Syntax Usage
    res := self->pointingDeviceType()
    

    Event_pressure ¶

    Event_pressure :: proc "c" (
    	self: ^Event, 
    ) -> f32 {…}
    Objective-C Method Information
    • Class: Event
    • Name: pressure
    Syntax Usage
    res := self->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: Float) {…}
    Objective-C Method Information
    • Class: Event
    • Name: scrollingDelta
    Syntax Usage
    x, y := self->scrollingDelta()
    

    Event_scrollingDeltaX ¶

    Event_scrollingDeltaX :: proc "c" (
    	self: ^Event, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Event
    • Name: scrollingDeltaX
    Syntax Usage
    res := self->scrollingDeltaX()
    

    Event_scrollingDeltaY ¶

    Event_scrollingDeltaY :: proc "c" (
    	self: ^Event, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Event
    • Name: scrollingDeltaY
    Syntax Usage
    res := self->scrollingDeltaY()
    

    Event_subtype ¶

    Event_subtype :: proc "c" (
    	self: ^Event, 
    ) -> i16 {…}
    Objective-C Method Information
    • Class: Event
    • Name: subtype
    Syntax Usage
    res := self->subtype()
    

    Event_systemTabletID ¶

    Event_systemTabletID :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: systemTabletID
    Syntax Usage
    res := self->systemTabletID()
    

    Event_tabletID ¶

    Event_tabletID :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: tabletID
    Syntax Usage
    res := self->tabletID()
    

    Event_tangentialPressure ¶

    Event_tangentialPressure :: proc "c" (
    	self: ^Event, 
    ) -> f32 {…}
    Objective-C Method Information
    • Class: Event
    • Name: tangentialPressure
    Syntax Usage
    res := self->tangentialPressure()
    

    Event_timestamp ¶

    Event_timestamp :: proc "c" (
    	self: ^Event, 
    ) -> TimeInterval {…}
    Objective-C Method Information
    • Class: Event
    • Name: timestamp
    Syntax Usage
    res := self->timestamp()
    

    Event_type ¶

    Event_type :: proc "c" (
    	self: ^Event, 
    ) -> EventType {…}
    Objective-C Method Information
    • Class: Event
    • Name: type
    Syntax Usage
    res := self->type()
    

    Event_uniqueID ¶

    Event_uniqueID :: proc "c" (
    	self: ^Event, 
    ) -> u64 {…}
    Objective-C Method Information
    • Class: Event
    • Name: uniqueID
    Syntax Usage
    res := self->uniqueID()
    

    Event_vendorDefined ¶

    Event_vendorDefined :: proc "c" (
    	self: ^Event, 
    ) -> ^.objc_object {…}
    Objective-C Method Information
    • Class: Event
    • Name: vendorDefined
    Syntax Usage
    res := self->vendorDefined()
    

    Event_vendorID ¶

    Event_vendorID :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: vendorID
    Syntax Usage
    res := self->vendorID()
    

    Event_vendorPointingDeviceType ¶

    Event_vendorPointingDeviceType :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: vendorPointingDeviceType
    Syntax Usage
    res := self->vendorPointingDeviceType()
    

    Event_window ¶

    Event_window :: proc "c" (
    	self: ^Event, 
    ) -> ^Window {…}
    Objective-C Method Information
    • Class: Event
    • Name: window
    Syntax Usage
    res := self->window()
    

    Event_windowNumber ¶

    Event_windowNumber :: proc "c" (
    	self: ^Event, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Event
    • Name: windowNumber
    Syntax Usage
    res := self->windowNumber()
    

    FastEnumeration_alloc ¶

    FastEnumeration_alloc :: proc "c" () -> ^FastEnumeration {…}
    Objective-C Method Information
    Syntax Usage
    res := FastEnumeration.alloc()
    

    FastEnumeration_countByEnumerating ¶

    FastEnumeration_countByEnumerating :: proc "c" (
    	self:   ^FastEnumeration, 
    	state:  ^FastEnumerationState, 
    	buffer: [^]^Object, 
    	len:    UInteger, 
    ) -> UInteger {…}
    Objective-C Method Information
    Syntax Usage
    res := self->countByEnumerating(
    	state,
    	buffer,
    	len,
    )
    

    FastEnumeration_init ¶

    FastEnumeration_init :: proc "c" (
    	self: ^FastEnumeration, 
    ) -> ^FastEnumeration {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Layer_addSublayer ¶

    Layer_addSublayer :: proc "c" (
    	self:  ^Layer, 
    	layer: ^Layer, 
    ) {…}
    Objective-C Method Information
    • Class: Layer
    • Name: addSublayer
    Syntax Usage
    self->addSublayer(layer)
    

    Layer_contentsScale ¶

    Layer_contentsScale :: proc "c" (
    	self: ^Layer, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Layer
    • Name: contentsScale
    Syntax Usage
    res := self->contentsScale()
    

    Layer_frame ¶

    Layer_frame :: proc "c" (
    	self: ^Layer, 
    ) -> Rect {…}
    Objective-C Method Information
    • Class: Layer
    • Name: frame
    Syntax Usage
    res := self->frame()
    

    Layer_setContentsScale ¶

    Layer_setContentsScale :: proc "c" (
    	self:  ^Layer, 
    	scale: Float, 
    ) {…}
    Objective-C Method Information
    • Class: Layer
    • Name: setContentsScale
    Syntax Usage
    self->setContentsScale(scale)
    

    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.

    MenuItem_alloc :: proc "c" () -> ^MenuItem {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := MenuItem.alloc()
    
    MenuItem_init :: proc "c" (
    	self: ^MenuItem, 
    ) -> ^MenuItem {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    
    MenuItem_keyEquivalentModifierMask :: proc "c" (
    	self: ^MenuItem, 
    ) -> KeyEquivalentModifierMask {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: keyEquivalentModifierMask
    Syntax Usage
    res := self->keyEquivalentModifierMask()
    
    MenuItem_registerActionCallback :: proc "c" (
    	name:     cstring, 
    	callback: MenuItemCallback, 
    ) -> ^.objc_selector {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: registerActionCallback
    • Kind: Class Method
    Syntax Usage
    res := MenuItem.registerActionCallback(
    	name,
    	callback,
    )
    
    MenuItem_setKeyEquivalentModifierMask :: proc "c" (
    	self:         ^MenuItem, 
    	modifierMask: KeyEquivalentModifierMask, 
    ) {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: setKeyEquivalentModifierMask
    Syntax Usage
    self->setKeyEquivalentModifierMask(modifierMask)
    
    MenuItem_setSubmenu :: proc "c" (
    	self:    ^MenuItem, 
    	submenu: ^Menu, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setSubmenu(submenu)
    
    MenuItem_title :: proc "c" (
    	self: ^MenuItem, 
    ) -> ^String {…}
    Objective-C Method Information
    Syntax Usage
    res := self->title()
    
    Menu_addItem :: proc "c" (
    	self: ^Menu, 
    	item: ^MenuItem, 
    ) {…}
    Objective-C Method Information
    • Class: Menu
    • Name: addItem
    Syntax Usage
    self->addItem(item)
    
    Menu_addItemWithTitle :: proc "c" (
    	self:          ^Menu, 
    	title:         ^String, 
    	selector:      ^.objc_selector, 
    	keyEquivalent: ^String, 
    ) -> ^MenuItem {…}
    Objective-C Method Information
    • Class: Menu
    • Name: addItemWithTitle
    Syntax Usage
    res := self->addItemWithTitle(
    	title,
    	selector,
    	keyEquivalent,
    )
    
    Menu_alloc :: proc "c" () -> ^Menu {…}
    Objective-C Method Information
    • Class: Menu
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Menu.alloc()
    
    Menu_init :: proc "c" (
    	self: ^Menu, 
    ) -> ^Menu {…}
    Objective-C Method Information
    • Class: Menu
    • Name: init
    Syntax Usage
    res := self->init()
    
    Menu_initWithTitle :: proc "c" (
    	self:  ^Menu, 
    	title: ^String, 
    ) -> ^Menu {…}
    Objective-C Method Information
    • Class: Menu
    • Name: initWithTitle
    Syntax Usage
    res := self->initWithTitle(title)
    
    Menu_itemArray :: proc "c" (
    	self: ^Menu, 
    ) -> ^Array {…}
    Objective-C Method Information
    • Class: Menu
    • Name: itemArray
    Syntax Usage
    res := self->itemArray()
    

    NotificationCenter_addObserverName ¶

    NotificationCenter_addObserverName :: proc "c" (
    	self:   ^NotificationCenter, 
    	name:   ^String, 
    	pObj:   ^Object, 
    	pQueue: rawptr, 
    	block:  ^Block, 
    ) -> ^Object {…}
    Objective-C Method Information
    Syntax Usage
    res := self->addObserver(
    	name,
    	pObj,
    	pQueue,
    	block,
    )
    

    NotificationCenter_alloc ¶

    NotificationCenter_alloc :: proc "c" () -> ^NotificationCenter {…}
    Objective-C Method Information
    Syntax Usage
    res := NotificationCenter.alloc()
    

    NotificationCenter_defaultCenter ¶

    NotificationCenter_defaultCenter :: proc "c" () -> ^NotificationCenter {…}
    Objective-C Method Information
    Syntax Usage
    res := NotificationCenter.defaultCenter()
    

    NotificationCenter_init ¶

    NotificationCenter_init :: proc "c" (
    	self: ^NotificationCenter, 
    ) -> ^NotificationCenter {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    NotificationCenter_removeObserver ¶

    NotificationCenter_removeObserver :: proc "c" (
    	self:      ^NotificationCenter, 
    	pObserver: ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->removeObserver(pObserver)
    

    Notification_alloc ¶

    Notification_alloc :: proc "c" () -> ^Notification {…}
    Objective-C Method Information
    Syntax Usage
    res := Notification.alloc()
    

    Notification_init ¶

    Notification_init :: proc "c" (
    	self: ^Notification, 
    ) -> ^Notification {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Notification_name ¶

    Notification_name :: proc "c" (
    	self: ^Notification, 
    ) -> ^String {…}
    Objective-C Method Information
    Syntax Usage
    res := self->name()
    

    Notification_object ¶

    Notification_object :: proc "c" (
    	self: ^Notification, 
    ) -> ^Object {…}
    Objective-C Method Information
    Syntax Usage
    res := self->object()
    

    Notification_userInfo ¶

    Notification_userInfo :: proc "c" (
    	self: ^Notification, 
    ) -> ^Dictionary {…}
    Objective-C Method Information
    Syntax Usage
    res := self->userInfo()
    

    Number_alloc ¶

    Number_alloc :: proc "c" () -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Number.alloc()
    

    Number_boolValue ¶

    Number_boolValue :: proc "c" (
    	self: ^Number, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Number
    • Name: boolValue
    Syntax Usage
    res := self->boolValue()
    

    Number_compare ¶

    Number_compare :: proc "c" (
    	self, 
    	other: ^Number, 
    ) -> ComparisonResult {…}
    Objective-C Method Information
    Syntax Usage
    res := self->compare(other)
    

    Number_descriptionWithLocale ¶

    Number_descriptionWithLocale :: proc "c" (
    	self:   ^Number, 
    	locale: ^Object, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Number
    • Name: descriptionWithLocale
    Syntax Usage
    res := self->descriptionWithLocale(locale)
    

    Number_f32Value ¶

    Number_f32Value :: proc "c" (
    	self: ^Number, 
    ) -> f32 {…}
    Objective-C Method Information
    • Class: Number
    • Name: f32Value
    Syntax Usage
    res := self->f32Value()
    

    Number_f64Value ¶

    Number_f64Value :: proc "c" (
    	self: ^Number, 
    ) -> f64 {…}
    Objective-C Method Information
    • Class: Number
    • Name: f64Value
    Syntax Usage
    res := self->f64Value()
    

    Number_i16Value ¶

    Number_i16Value :: proc "c" (
    	self: ^Number, 
    ) -> i16 {…}
    Objective-C Method Information
    • Class: Number
    • Name: i16Value
    Syntax Usage
    res := self->i16Value()
    

    Number_i32Value ¶

    Number_i32Value :: proc "c" (
    	self: ^Number, 
    ) -> i32 {…}
    Objective-C Method Information
    • Class: Number
    • Name: i32Value
    Syntax Usage
    res := self->i32Value()
    

    Number_i64Value ¶

    Number_i64Value :: proc "c" (
    	self: ^Number, 
    ) -> i64 {…}
    Objective-C Method Information
    • Class: Number
    • Name: i64Value
    Syntax Usage
    res := self->i64Value()
    

    Number_i8Value ¶

    Number_i8Value :: proc "c" (
    	self: ^Number, 
    ) -> i8 {…}
    Objective-C Method Information
    Syntax Usage
    res := self->i8Value()
    

    Number_init ¶

    Number_init :: proc "c" (
    	self: ^Number, 
    ) -> ^Number {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    Number_initWithBool ¶

    Number_initWithBool :: proc "c" (
    	self:  ^Number, 
    	value: bool, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithBool
    Syntax Usage
    res := self->initWithBool(value)
    

    Number_initWithF32 ¶

    Number_initWithF32 :: proc "c" (
    	self:  ^Number, 
    	value: f32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithF32
    Syntax Usage
    res := self->initWithF32(value)
    

    Number_initWithF64 ¶

    Number_initWithF64 :: proc "c" (
    	self:  ^Number, 
    	value: f64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithF64
    Syntax Usage
    res := self->initWithF64(value)
    

    Number_initWithI16 ¶

    Number_initWithI16 :: proc "c" (
    	self:  ^Number, 
    	value: i16, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithI16
    Syntax Usage
    res := self->initWithI16(value)
    

    Number_initWithI32 ¶

    Number_initWithI32 :: proc "c" (
    	self:  ^Number, 
    	value: i32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithI32
    Syntax Usage
    res := self->initWithI32(value)
    

    Number_initWithI64 ¶

    Number_initWithI64 :: proc "c" (
    	self:  ^Number, 
    	value: i64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithI64
    Syntax Usage
    res := self->initWithI64(value)
    

    Number_initWithI8 ¶

    Number_initWithI8 :: proc "c" (
    	self:  ^Number, 
    	value: i8, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithI8
    Syntax Usage
    res := self->initWithI8(value)
    

    Number_initWithInt ¶

    Number_initWithInt :: proc "c" (
    	self:  ^Number, 
    	value: int, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithInt
    Syntax Usage
    res := self->initWithInt(value)
    

    Number_initWithU16 ¶

    Number_initWithU16 :: proc "c" (
    	self:  ^Number, 
    	value: u16, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithU16
    Syntax Usage
    res := self->initWithU16(value)
    

    Number_initWithU32 ¶

    Number_initWithU32 :: proc "c" (
    	self:  ^Number, 
    	value: u32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithU32
    Syntax Usage
    res := self->initWithU32(value)
    

    Number_initWithU64 ¶

    Number_initWithU64 :: proc "c" (
    	self:  ^Number, 
    	value: u64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithU64
    Syntax Usage
    res := self->initWithU64(value)
    

    Number_initWithU8 ¶

    Number_initWithU8 :: proc "c" (
    	self:  ^Number, 
    	value: u8, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithU8
    Syntax Usage
    res := self->initWithU8(value)
    

    Number_initWithUint ¶

    Number_initWithUint :: proc "c" (
    	self:  ^Number, 
    	value: uint, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: initWithUint
    Syntax Usage
    res := self->initWithUint(value)
    

    Number_intValue ¶

    Number_intValue :: proc "c" (
    	self: ^Number, 
    ) -> int {…}
    Objective-C Method Information
    • Class: Number
    • Name: intValue
    Syntax Usage
    res := self->intValue()
    

    Number_integerValue ¶

    Number_integerValue :: proc "c" (
    	self: ^Number, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Number
    • Name: integerValue
    Syntax Usage
    res := self->integerValue()
    

    Number_isEqualToNumber ¶

    Number_isEqualToNumber :: proc "c" (
    	self, 
    	other: ^Number, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Number
    • Name: isEqualToNumber
    Syntax Usage
    res := self->isEqualToNumber(other)
    

    Number_numberWithBool ¶

    Number_numberWithBool :: proc "c" (
    	value: bool, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithBool
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithBool(value)
    

    Number_numberWithF32 ¶

    Number_numberWithF32 :: proc "c" (
    	value: f32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithF32
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithF32(value)
    

    Number_numberWithF64 ¶

    Number_numberWithF64 :: proc "c" (
    	value: f64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithF64
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithF64(value)
    

    Number_numberWithI16 ¶

    Number_numberWithI16 :: proc "c" (
    	value: i16, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithI16
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithI16(value)
    

    Number_numberWithI32 ¶

    Number_numberWithI32 :: proc "c" (
    	value: i32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithI32
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithI32(value)
    

    Number_numberWithI64 ¶

    Number_numberWithI64 :: proc "c" (
    	value: i64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithI64
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithI64(value)
    

    Number_numberWithI8 ¶

    Number_numberWithI8 :: proc "c" (
    	value: i8, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithI8
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithI8(value)
    

    Number_numberWithInt ¶

    Number_numberWithInt :: proc "c" (
    	value: int, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithInt
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithInt(value)
    

    Number_numberWithU16 ¶

    Number_numberWithU16 :: proc "c" (
    	value: u16, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithU16
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithU16(value)
    

    Number_numberWithU32 ¶

    Number_numberWithU32 :: proc "c" (
    	value: u32, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithU32
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithU32(value)
    

    Number_numberWithU64 ¶

    Number_numberWithU64 :: proc "c" (
    	value: u64, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithU64
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithU64(value)
    

    Number_numberWithU8 ¶

    Number_numberWithU8 :: proc "c" (
    	value: u8, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithU8
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithU8(value)
    

    Number_numberWithUint ¶

    Number_numberWithUint :: proc "c" (
    	value: uint, 
    ) -> ^Number {…}
    Objective-C Method Information
    • Class: Number
    • Name: numberWithUint
    • Kind: Class Method
    Syntax Usage
    res := Number.numberWithUint(value)
    

    Number_stringValue ¶

    Number_stringValue :: proc "c" (
    	self: ^Number, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Number
    • Name: stringValue
    Syntax Usage
    res := self->stringValue()
    

    Number_u16Value ¶

    Number_u16Value :: proc "c" (
    	self: ^Number, 
    ) -> u16 {…}
    Objective-C Method Information
    • Class: Number
    • Name: u16Value
    Syntax Usage
    res := self->u16Value()
    

    Number_u32Value ¶

    Number_u32Value :: proc "c" (
    	self: ^Number, 
    ) -> u32 {…}
    Objective-C Method Information
    • Class: Number
    • Name: u32Value
    Syntax Usage
    res := self->u32Value()
    

    Number_u64Value ¶

    Number_u64Value :: proc "c" (
    	self: ^Number, 
    ) -> u64 {…}
    Objective-C Method Information
    • Class: Number
    • Name: u64Value
    Syntax Usage
    res := self->u64Value()
    

    Number_u8Value ¶

    Number_u8Value :: proc "c" (
    	self: ^Number, 
    ) -> u8 {…}
    Objective-C Method Information
    Syntax Usage
    res := self->u8Value()
    

    Number_uintValue ¶

    Number_uintValue :: proc "c" (
    	self: ^Number, 
    ) -> uint {…}
    Objective-C Method Information
    • Class: Number
    • Name: uintValue
    Syntax Usage
    res := self->uintValue()
    

    Number_uintegerValue ¶

    Number_uintegerValue :: proc "c" (
    	self: ^Number, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Number
    • Name: uintegerValue
    Syntax Usage
    res := self->uintegerValue()
    

    OpenPanel_URLs ¶

    OpenPanel_URLs :: proc "c" (
    	self: ^OpenPanel, 
    ) -> ^Array {…}
    Objective-C Method Information
    Syntax Usage
    res := self->URLs()
    

    OpenPanel_openPanel ¶

    OpenPanel_openPanel :: proc "c" () -> ^OpenPanel {…}
    Objective-C Method Information
    • Class: OpenPanel
    • Name: openPanel
    • Kind: Class Method
    Syntax Usage
    res := OpenPanel.openPanel()
    

    OpenPanel_setAllowedFileTypes ¶

    OpenPanel_setAllowedFileTypes :: proc "c" (
    	self:  ^OpenPanel, 
    	types: ^Array, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setAllowedFileTypes(types)
    

    OpenPanel_setAllowsMultipleSelection ¶

    OpenPanel_setAllowsMultipleSelection :: proc "c" (
    	self:    ^OpenPanel, 
    	setting: bool, 
    ) {…}
    Objective-C Method Information
    • Class: OpenPanel
    • Name: setAllowsMultipleSelection
    Syntax Usage
    self->setAllowsMultipleSelection(setting)
    

    OpenPanel_setCanChooseDirectories ¶

    OpenPanel_setCanChooseDirectories :: proc "c" (
    	self:    ^OpenPanel, 
    	setting: bool, 
    ) {…}
    Objective-C Method Information
    • Class: OpenPanel
    • Name: setCanChooseDirectories
    Syntax Usage
    self->setCanChooseDirectories(setting)
    

    OpenPanel_setCanChooseFiles ¶

    OpenPanel_setCanChooseFiles :: proc "c" (
    	self:    ^OpenPanel, 
    	setting: bool, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setCanChooseFiles(setting)
    

    OpenPanel_setResolvesAliases ¶

    OpenPanel_setResolvesAliases :: proc "c" (
    	self:    ^OpenPanel, 
    	setting: bool, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setResolvesAliases(setting)
    

    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 {…}

    Range_Max ¶

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

    RunningApplication_currentApplication ¶

    RunningApplication_currentApplication :: proc "c" () -> ^RunningApplication {…}
    Objective-C Method Information
    Syntax Usage
    res := RunningApplication.currentApplication()
    

    RunningApplication_localizedName ¶

    RunningApplication_localizedName :: proc "c" (
    	self: ^RunningApplication, 
    ) -> ^String {…}
    Objective-C Method Information
    Syntax Usage
    res := self->localizedName()
    

    SavePanel_runModal ¶

    SavePanel_runModal :: proc "c" (
    	self: ^SavePanel, 
    ) -> ModalResponse {…}
    Objective-C Method Information
    Syntax Usage
    res := self->runModal()
    

    Screen_backingScaleFactor ¶

    Screen_backingScaleFactor :: proc "c" (
    	self: ^Screen, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Screen
    • Name: backingScaleFactor
    Syntax Usage
    res := self->backingScaleFactor()
    

    Screen_colorSpace ¶

    Screen_colorSpace :: proc "c" (
    	self: ^Screen, 
    ) -> ^ColorSpace {…}
    Objective-C Method Information
    • Class: Screen
    • Name: colorSpace
    Syntax Usage
    res := self->colorSpace()
    

    Screen_deepestScreen ¶

    Screen_deepestScreen :: proc "c" () -> ^Screen {…}
    Objective-C Method Information
    • Class: Screen
    • Name: deepestScreen
    Syntax Usage
    res := self->deepestScreen()
    

    Screen_depth ¶

    Screen_depth :: proc "c" (
    	self: ^Screen, 
    ) -> Depth {…}
    Objective-C Method Information
    Syntax Usage
    res := self->depth()
    

    Screen_frame ¶

    Screen_frame :: proc "c" (
    	self: ^Screen, 
    ) -> Rect {…}
    Objective-C Method Information
    Syntax Usage
    res := self->frame()
    

    Screen_mainScreen ¶

    Screen_mainScreen :: proc "c" () -> ^Screen {…}
    Objective-C Method Information
    • Class: Screen
    • Name: mainScreen
    Syntax Usage
    res := self->mainScreen()
    

    Screen_screens ¶

    Screen_screens :: proc "c" () -> ^Array {…}
    Objective-C Method Information
    Syntax Usage
    res := self->screens()
    

    Screen_visibleFrame ¶

    Screen_visibleFrame :: proc "c" (
    	self: ^Screen, 
    ) -> Rect {…}
    Objective-C Method Information
    • Class: Screen
    • Name: visibleFrame
    Syntax Usage
    res := self->visibleFrame()
    

    SelectorFromString ¶

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

    Set_alloc ¶

    Set_alloc :: proc "c" () -> ^Set {…}
    Objective-C Method Information
    • Class: Set
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Set.alloc()
    

    Set_init ¶

    Set_init :: proc "c" (
    	self: ^Set, 
    ) -> ^Set {…}
    Objective-C Method Information
    • Class: Set
    • Name: init
    Syntax Usage
    res := self->init()
    

    Set_initWithCoder ¶

    Set_initWithCoder :: proc "c" (
    	self:  ^Set, 
    	coder: ^Coder, 
    ) -> ^Set {…}
    Objective-C Method Information
    • Class: Set
    • Name: initWithCoder
    Syntax Usage
    res := self->initWithCoder(coder)
    

    Set_initWithObjects ¶

    Set_initWithObjects :: proc "c" (
    	self:    ^Set, 
    	objects: [^]^Object, 
    	count:   UInteger, 
    ) -> ^Set {…}
    Objective-C Method Information
    • Class: Set
    • Name: initWithObjects
    Syntax Usage
    res := self->initWithObjects(
    	objects,
    	count,
    )
    

    StringFromClass ¶

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

    StringFromSelector ¶

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

    String_UTF8String ¶

    String_UTF8String :: proc "c" (
    	self: ^String, 
    ) -> cstring {…}
    Objective-C Method Information
    • Class: String
    • Name: UTF8String
    Syntax Usage
    res := self->UTF8String()
    

    String_alloc ¶

    String_alloc :: proc "c" () -> ^String {…}
    Objective-C Method Information
    • Class: String
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := String.alloc()
    

    String_characterAtIndex ¶

    String_characterAtIndex :: proc "c" (
    	self:  ^String, 
    	index: UInteger, 
    ) -> unichar {…}
    Objective-C Method Information
    • Class: String
    • Name: characterAtIndex
    Syntax Usage
    res := self->characterAtIndex(index)
    

    String_cstringUsingEncoding ¶

    String_cstringUsingEncoding :: proc "c" (
    	self:     ^String, 
    	encoding: StringEncoding, 
    ) -> cstring {…}
    Objective-C Method Information
    • Class: String
    • Name: cstringUsingEncoding
    Syntax Usage
    res := self->cstringUsingEncoding(encoding)
    

    String_init ¶

    String_init :: proc "c" (
    	self: ^String, 
    ) -> ^String {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    String_initWithBytesNoCopy ¶

    String_initWithBytesNoCopy :: proc "c" (
    	self:         ^String, 
    	pBytes:       rawptr, 
    	length:       UInteger, 
    	encoding:     StringEncoding, 
    	freeWhenDone: bool, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: String
    • Name: initWithBytesNoCopy
    Syntax Usage
    res := self->initWithBytesNoCopy(
    	pBytes,
    	length,
    	encoding,
    	freeWhenDone,
    )
    

    String_initWithCString ¶

    String_initWithCString :: proc "c" (
    	self:     ^String, 
    	pString:  cstring, 
    	encoding: StringEncoding, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: String
    • Name: initWithCString
    Syntax Usage
    res := self->initWithCString(
    	pString,
    	encoding,
    )
    

    String_initWithOdinString ¶

    String_initWithOdinString :: proc "c" (
    	self: ^String, 
    	str:  string, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: String
    • Name: initWithOdinString
    Syntax Usage
    res := self->initWithOdinString(str)
    

    String_initWithString ¶

    String_initWithString :: proc "c" (
    	self:  ^String, 
    	other: ^String, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: String
    • Name: initWithString
    Syntax Usage
    res := self->initWithString(other)
    

    String_isEqualToString ¶

    String_isEqualToString :: proc "c" (
    	self:  ^String, 
    	other: ^String, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: String
    • Name: isEqualToString
    Syntax Usage
    res := self->isEqualToString(other)
    

    String_length ¶

    String_length :: proc "c" (
    	self: ^String, 
    ) -> UInteger {…}
    Objective-C Method Information
    Syntax Usage
    res := self->length()
    

    String_lengthOfBytesUsingEncoding ¶

    String_lengthOfBytesUsingEncoding :: proc "c" (
    	self:     ^String, 
    	encoding: StringEncoding, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: String
    • Name: lengthOfBytesUsingEncoding
    Syntax Usage
    res := self->lengthOfBytesUsingEncoding(encoding)
    

    String_maximumLengthOfBytesUsingEncoding ¶

    String_maximumLengthOfBytesUsingEncoding :: proc "c" (
    	self:     ^String, 
    	encoding: StringEncoding, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: String
    • Name: maximumLengthOfBytesUsingEncoding
    Syntax Usage
    res := self->maximumLengthOfBytesUsingEncoding(encoding)
    

    String_odinString ¶

    String_odinString :: proc "c" (
    	self: ^String, 
    ) -> string {…}
    Objective-C Method Information
    • Class: String
    • Name: odinString
    Syntax Usage
    res := self->odinString()
    

    String_rangeOfString ¶

    String_rangeOfString :: proc "c" (
    	self, other: ^String, 
    	options:     StringCompareOptions, 
    ) -> Range {…}
    Objective-C Method Information
    • Class: String
    • Name: rangeOfString
    Syntax Usage
    res := self->rangeOfString(
    	other,
    	options,
    )
    

    URL_alloc ¶

    URL_alloc :: proc "c" () -> ^URL {…}
    Objective-C Method Information
    • Class: URL
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := URL.alloc()
    

    URL_fileSystemRepresentation ¶

    URL_fileSystemRepresentation :: proc "c" (
    	self: ^URL, 
    ) -> cstring {…}
    Objective-C Method Information
    • Class: URL
    • Name: fileSystemRepresentation
    Syntax Usage
    res := self->fileSystemRepresentation()
    

    URL_init ¶

    URL_init :: proc "c" (
    	self: ^URL, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: URL
    • Name: init
    Syntax Usage
    res := self->init()
    

    URL_initFileURLWithPath ¶

    URL_initFileURLWithPath :: proc "c" (
    	self: ^URL, 
    	path: ^String, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: URL
    • Name: initFileURLWithPath
    Syntax Usage
    res := self->initFileURLWithPath(path)
    

    URL_initWithString ¶

    URL_initWithString :: proc "c" (
    	self:  ^URL, 
    	value: ^String, 
    ) -> ^URL {…}
    Objective-C Method Information
    • Class: URL
    • Name: initWithString
    Syntax Usage
    res := self->initWithString(value)
    

    UserDefaults_setBoolForKey ¶

    UserDefaults_setBoolForKey :: proc "c" (
    	self:  ^UserDefaults, 
    	value: bool, 
    	name:  ^String, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->setBoolForKey(
    	value,
    	name,
    )
    

    UserDefaults_standardUserDefaults ¶

    UserDefaults_standardUserDefaults :: proc "c" () -> ^UserDefaults {…}
    Objective-C Method Information
    • Class: UserDefaults
    • Name: standardUserDefaults
    • Kind: Class Method
    Syntax Usage
    res := UserDefaults.standardUserDefaults()
    

    Value_alloc ¶

    Value_alloc :: proc "c" () -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Value.alloc()
    

    Value_getValue ¶

    Value_getValue :: proc "c" (
    	self:  ^Value, 
    	value: rawptr, 
    	size:  UInteger, 
    ) {…}
    Objective-C Method Information
    • Class: Value
    • Name: getValue
    Syntax Usage
    self->getValue(
    	value,
    	size,
    )
    

    Value_init ¶

    Value_init :: proc "c" (
    	self: ^Value, 
    ) -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: init
    Syntax Usage
    res := self->init()
    

    Value_initWithBytes ¶

    Value_initWithBytes :: proc "c" (
    	self:  ^Value, 
    	value: rawptr, 
    	type:  cstring, 
    ) -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: initWithBytes
    Syntax Usage
    res := self->initWithBytes(
    	value,
    	type,
    )
    

    Value_initWithCoder ¶

    Value_initWithCoder :: proc "c" (
    	self:  ^Value, 
    	coder: ^Coder, 
    ) -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: initWithCoder
    Syntax Usage
    res := self->initWithCoder(coder)
    

    Value_isEqualToValue ¶

    Value_isEqualToValue :: proc "c" (
    	self, 
    	other: ^Value, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Value
    • Name: isEqualToValue
    Syntax Usage
    res := self->isEqualToValue(other)
    

    Value_objCType ¶

    Value_objCType :: proc "c" (
    	self: ^Value, 
    ) -> cstring {…}
    Objective-C Method Information
    • Class: Value
    • Name: objCType
    Syntax Usage
    res := self->objCType()
    

    Value_pointerValue ¶

    Value_pointerValue :: proc "c" (
    	self: ^Value, 
    ) -> rawptr {…}
    Objective-C Method Information
    • Class: Value
    • Name: pointerValue
    Syntax Usage
    res := self->pointerValue()
    

    Value_valueWithBytes ¶

    Value_valueWithBytes :: proc "c" (
    	value: rawptr, 
    	type:  cstring, 
    ) -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: valueWithBytes
    • Kind: Class Method
    Syntax Usage
    res := Value.valueWithBytes(
    	value,
    	type,
    )
    

    Value_valueWithPointer ¶

    Value_valueWithPointer :: proc "c" (
    	pointer: rawptr, 
    ) -> ^Value {…}
    Objective-C Method Information
    • Class: Value
    • Name: valueWithPointer
    • Kind: Class Method
    Syntax Usage
    res := Value.valueWithPointer(pointer)
    

    View_bounds ¶

    View_bounds :: proc "c" (
    	self: ^View, 
    ) -> Rect {…}
    Objective-C Method Information
    • Class: View
    • Name: bounds
    Syntax Usage
    res := self->bounds()
    

    View_convertPointFromView ¶

    View_convertPointFromView :: proc "c" (
    	self:  ^View, 
    	point: Point, 
    	view:  ^View, 
    ) -> Point {…}
    Objective-C Method Information
    • Class: View
    • Name: convertPointFromView
    Syntax Usage
    res := self->convertPointFromView(
    	point,
    	view,
    )
    

    View_initWithFrame ¶

    View_initWithFrame :: proc "c" (
    	self:  ^View, 
    	frame: Rect, 
    ) -> ^View {…}
    Objective-C Method Information
    • Class: View
    • Name: initWithFrame
    Syntax Usage
    res := self->initWithFrame(frame)
    

    View_layer ¶

    View_layer :: proc "c" (
    	self: ^View, 
    ) -> ^Layer {…}
    Objective-C Method Information
    • Class: View
    • Name: layer
    Syntax Usage
    res := self->layer()
    

    View_setLayer ¶

    View_setLayer :: proc "c" (
    	self:  ^View, 
    	layer: ^Layer, 
    ) {…}
    Objective-C Method Information
    • Class: View
    • Name: setLayer
    Syntax Usage
    self->setLayer(layer)
    

    View_setWantsLayer ¶

    View_setWantsLayer :: proc "c" (
    	self:       ^View, 
    	wantsLayer: bool, 
    ) {…}
    Objective-C Method Information
    • Class: View
    • Name: setWantsLayer
    Syntax Usage
    self->setWantsLayer(wantsLayer)
    

    View_wantsLayer ¶

    View_wantsLayer :: proc "c" (
    	self: ^View, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: View
    • Name: wantsLayer
    Syntax Usage
    res := self->wantsLayer()
    

    Window_alloc ¶

    Window_alloc :: proc "c" () -> ^Window {…}
    Objective-C Method Information
    • Class: Window
    • Name: alloc
    • Kind: Class Method
    Syntax Usage
    res := Window.alloc()
    

    Window_backgroundColor ¶

    Window_backgroundColor :: proc "c" (
    	self: ^Window, 
    ) -> ^Color {…}
    Objective-C Method Information
    • Class: Window
    • Name: backgroundColor
    Syntax Usage
    res := self->backgroundColor()
    

    Window_backingScaleFactor ¶

    Window_backingScaleFactor :: proc "c" (
    	self: ^Window, 
    ) -> Float {…}
    Objective-C Method Information
    • Class: Window
    • Name: backingScaleFactor
    Syntax Usage
    res := self->backingScaleFactor()
    

    Window_close ¶

    Window_close :: proc "c" (
    	self: ^Window, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->close()
    

    Window_contentLayoutRect ¶

    Window_contentLayoutRect :: proc "c" (
    	self: ^Window, 
    ) -> Rect {…}
    Objective-C Method Information
    • Class: Window
    • Name: contentLayoutRect
    Syntax Usage
    res := self->contentLayoutRect()
    

    Window_contentView ¶

    Window_contentView :: proc "c" (
    	self: ^Window, 
    ) -> ^View {…}
    Objective-C Method Information
    • Class: Window
    • Name: contentView
    Syntax Usage
    res := self->contentView()
    

    Window_frame ¶

    Window_frame :: proc "c" (
    	self: ^Window, 
    ) -> Rect {…}
    Objective-C Method Information
    Syntax Usage
    res := self->frame()
    

    Window_hasCloseBox ¶

    Window_hasCloseBox :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: hasCloseBox
    Syntax Usage
    res := self->hasCloseBox()
    

    Window_hasTitleBar ¶

    Window_hasTitleBar :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: hasTitleBar
    Syntax Usage
    res := self->hasTitleBar()
    

    Window_initWithContentRect ¶

    Window_initWithContentRect :: proc(
    	self:        ^Window, 
    	contentRect: Rect, 
    	styleMask:   WindowStyleMask, 
    	backing:     BackingStoreType, 
    	doDefer:     bool, 
    ) -> ^Window {…}
    Objective-C Method Information
    • Class: Window
    • Name: initWithContentRect
    Syntax Usage
    res := self->initWithContentRect(
    	contentRect,
    	styleMask,
    	backing,
    	doDefer,
    )
    

    Window_isFloatingPanel ¶

    Window_isFloatingPanel :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: isFloatingPanel
    Syntax Usage
    res := self->isFloatingPanel()
    

    Window_isMiniaturizable ¶

    Window_isMiniaturizable :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: isMiniaturizable
    Syntax Usage
    res := self->isMiniaturizable()
    

    Window_isModalPanel ¶

    Window_isModalPanel :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: isModalPanel
    Syntax Usage
    res := self->isModalPanel()
    

    Window_isResizable ¶

    Window_isResizable :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: isResizable
    Syntax Usage
    res := self->isResizable()
    

    Window_isZoomable ¶

    Window_isZoomable :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    • Class: Window
    • Name: isZoomable
    Syntax Usage
    res := self->isZoomable()
    

    Window_mainMenu ¶

    Window_mainMenu :: proc "c" (
    	self: ^Application, 
    ) -> ^Menu {…}
    Objective-C Method Information
    Syntax Usage
    res := self->mainMenu()
    

    Window_makeKeyAndOrderFront ¶

    Window_makeKeyAndOrderFront :: proc "c" (
    	self: ^Window, 
    	key:  ^Object, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: makeKeyAndOrderFront
    Syntax Usage
    self->makeKeyAndOrderFront(key)
    

    Window_opaque ¶

    Window_opaque :: proc "c" (
    	self: ^Window, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->opaque()
    

    Window_orderedIndex ¶

    Window_orderedIndex :: proc "c" (
    	self: ^Window, 
    ) -> Integer {…}
    Objective-C Method Information
    • Class: Window
    • Name: orderedIndex
    Syntax Usage
    res := self->orderedIndex()
    

    Window_setBackgroundColor ¶

    Window_setBackgroundColor :: proc "c" (
    	self:  ^Window, 
    	color: ^Color, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setBackgroundColor
    Syntax Usage
    self->setBackgroundColor(color)
    

    Window_setContentView ¶

    Window_setContentView :: proc "c" (
    	self:         ^Window, 
    	content_view: ^View, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setContentView
    Syntax Usage
    self->setContentView(content_view)
    

    Window_setDelegate ¶

    Window_setDelegate :: proc "c" (
    	self:     ^Window, 
    	delegate: ^WindowDelegate, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setDelegate
    Syntax Usage
    self->setDelegate(delegate)
    

    Window_setFrame ¶

    Window_setFrame :: proc "c" (
    	self:  ^Window, 
    	frame: Rect, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setFrame
    Syntax Usage
    self->setFrame(frame)
    

    Window_setIsMiniaturized ¶

    Window_setIsMiniaturized :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setIsMiniaturized
    Syntax Usage
    self->setIsMiniaturized(ok)
    

    Window_setIsVisible ¶

    Window_setIsVisible :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setIsVisible
    Syntax Usage
    self->setIsVisible(ok)
    

    Window_setIsZoomed ¶

    Window_setIsZoomed :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setIsZoomed
    Syntax Usage
    self->setIsZoomed(ok)
    

    Window_setMovable ¶

    Window_setMovable :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setMovable
    Syntax Usage
    self->setMovable(ok)
    

    Window_setMovableByWindowBackground ¶

    Window_setMovableByWindowBackground :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setMovableByWindowBackground
    Syntax Usage
    self->setMovableByWindowBackground(ok)
    

    Window_setOpaque ¶

    Window_setOpaque :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setOpaque
    Syntax Usage
    self->setOpaque(ok)
    

    Window_setStyleMask ¶

    Window_setStyleMask :: proc "c" (
    	self:       ^Window, 
    	style_mask: WindowStyleMask, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setStyleMask
    Syntax Usage
    self->setStyleMask(style_mask)
    

    Window_setTitle ¶

    Window_setTitle :: proc "c" (
    	self:  ^Window, 
    	title: ^String, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setTitle
    Syntax Usage
    self->setTitle(title)
    

    Window_setTitlebarAppearsTransparent ¶

    Window_setTitlebarAppearsTransparent :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setTitlebarAppearsTransparent
    Syntax Usage
    self->setTitlebarAppearsTransparent(ok)
    

    Window_setWantsLayer ¶

    Window_setWantsLayer :: proc "c" (
    	self: ^Window, 
    	ok:   bool, 
    ) {…}
    Objective-C Method Information
    • Class: Window
    • Name: setWantsLayer
    Syntax Usage
    self->setWantsLayer(ok)
    

    alloc ¶

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

    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, 
    ) {…}
    Objective-C Method Information
    • Class: Object
    • Name: autorelease
    Syntax Usage
    self->autorelease()
    

    bridgingCast ¶

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

    class ¶

    class :: proc "c" (
    	self: ^Object, 
    ) -> ^.objc_class {…}
    Objective-C Method Information
    Syntax Usage
    res := self->class()
    

    class_addIvar ¶

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

    class_addMethod ¶

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

    class_addProperty ¶

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

    class_addProtocol ¶

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

    class_conformsToProtocol ¶

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

    class_copyIvarList ¶

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

    class_copyMethodList ¶

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

    class_copyPropertyList ¶

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

    class_copyProtocolList ¶

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

    class_createInstance ¶

    class_createInstance :: proc "c" (
    	cls:        ^.objc_class, 
    	extraBytes: uint, 
    ) -> ^.objc_object ---

    class_getClassMethod ¶

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

    class_getClassVariable ¶

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

    class_getInstanceMethod ¶

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

    class_getInstanceSize ¶

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

    class_getInstanceVariable ¶

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

    class_getMethodImplementation ¶

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

    class_getName ¶

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

    class_getProperty ¶

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

    class_getSuperclass ¶

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

    class_getVersion ¶

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

    class_isMetaClass ¶

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

    class_replaceMethod ¶

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

    class_replaceProperty ¶

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

    class_respondsToSelector ¶

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

    class_setVersion ¶

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

    copy ¶

    copy :: proc "c" (
    	self: ^Copying($T), 
    ) -> ^$T {…}
    Objective-C Method Information
    Syntax Usage
    res := self->copy()
    

    debugDescription ¶

    debugDescription :: proc "c" (
    	self: ^Object, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Object
    • Name: debugDescription
    Syntax Usage
    res := self->debugDescription()
    

    description ¶

    description :: proc "c" (
    	self: ^Object, 
    ) -> ^String {…}
    Objective-C Method Information
    • Class: Object
    • Name: description
    Syntax Usage
    res := self->description()
    

    hash ¶

    hash :: proc "c" (
    	self: ^Object, 
    ) -> UInteger {…}
    Objective-C Method Information
    Syntax Usage
    res := self->hash()
    

    init ¶

    init :: proc "c" (
    	self: ^$T, 
    ) -> ^$T {…}
    Objective-C Method Information
    Syntax Usage
    res := self->init()
    

    isEqual ¶

    isEqual :: proc "c" (
    	self, 
    	pObject: ^Object, 
    ) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->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 ---

    methodSignatureForSelector ¶

    methodSignatureForSelector :: proc "c" (
    	obj:      ^Object, 
    	selector: ^.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: ^.objc_selector, 
    ) -> bool {…}

    new ¶

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

    objc_allocateClassPair ¶

    objc_allocateClassPair :: proc "c" (
    	superclass: ^.objc_class, 
    	name:       cstring, 
    	extraBytes: uint, 
    ) -> ^.objc_class ---

    objc_constructInstance ¶

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

    objc_copyClassList ¶

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

    objc_copyProtocolList ¶

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

    objc_destructInstance ¶

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

    objc_disposeClassPair ¶

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

    objc_duplicateClass ¶

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

    objc_getAssociatedObject ¶

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

    objc_getClassList ¶

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

    objc_getMetaClass ¶

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

    objc_getProtocol ¶

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

    objc_getRequiredClass ¶

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

    objc_lookUpClass ¶

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

    objc_registerClassPair ¶

    objc_registerClassPair :: proc "c" (
    	cls: ^.objc_class, 
    ) ---

    objc_removeAssociatedObjects ¶

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

    objc_setAssociatedObject ¶

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

    object_copy ¶

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

    object_dispose ¶

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

    object_getClass ¶

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

    object_getClassName ¶

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

    object_getIndexedIvars ¶

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

    object_getInstanceVariable ¶

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

    object_getIvar ¶

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

    object_setClass ¶

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

    object_setInstanceVariable ¶

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

    object_setIvar ¶

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

    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 ---

    release ¶

    release :: proc "c" (
    	self: ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->release()
    

    respondsToSelector ¶

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

    retain ¶

    retain :: proc "c" (
    	self: ^Object, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->retain()
    

    retainCount ¶

    retainCount :: proc "c" (
    	self: ^Object, 
    ) -> UInteger {…}
    Objective-C Method Information
    • Class: Object
    • Name: retainCount
    Syntax Usage
    res := self->retainCount()
    

    scoped_autoreleasepool ¶

    scoped_autoreleasepool :: proc "c" () -> ^AutoreleasePool {…}

    sel_getName ¶

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

    sel_isEqual ¶

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

    sel_registerName ¶

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

    tilt ¶

    tilt :: proc "c" (
    	self: ^Event, 
    ) -> Point {…}
    Objective-C Method Information
    • Class: Event
    • Name: tilt
    Syntax Usage
    res := self->tilt()
    

    window_delegate_register_and_alloc ¶

    window_delegate_register_and_alloc :: proc(
    	template:         WindowDelegateTemplate, 
    	class_name:       string, 
    	delegate_context: runtime.Maybe($T=Context), 
    ) -> ^WindowDelegate {…}

    Procedure Groups

    Number_number ¶

    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,
    }
    
    Objective-C Method Information
    • Class: Number
    • Name: number
    • Kind: Class Method
    Syntax Usage
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    res := Number.number(value)
    

    Source Files

    Generation Information

    Generated with odin version dev-2024-11 (vendor "odin") Windows_amd64 @ 2024-11-04 21:11:08.404820400 +0000 UTC