package vendor:darwin/Foundation

⌘K
Ctrl+K
or
/

    Index

    Types (99)
    Constants (41)
    Procedures (373)
    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, 
    }

    ApplicationPresentationOptions ¶

    ApplicationPresentationOptions :: distinct bit_set[ApplicationPresentationOptionFlag; UInteger]

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

    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

    EventPhase ¶

    EventPhase :: distinct bit_set[EventPhaseFlag; UInteger]
    Related Procedures With Returns

    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

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

    WindowStyleMask ¶

    WindowStyleMask :: distinct bit_set[WindowStyleFlag; UInteger]
    Related Procedures With Parameters

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

    objc_ivar :: struct {}

    objc_ivar_list ¶

    objc_ivar_list :: struct {}

    objc_method ¶

    objc_method :: struct {
    	method_name:  ^.objc_selector,
    	method_types: cstring,
    	method_imp:   IMP,
    }
    Related Procedures With Parameters
    Related Procedures With Returns

    objc_method_list ¶

    objc_method_list :: struct {}

    objc_object_internals ¶

    objc_object_internals :: struct {
    	isa: ^objc_class_internals,
    }

    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 : ~EventMask{}

    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

    AllocateObject ¶

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

    Application_activateIgnoringOtherApps ¶

    Application_activateIgnoringOtherApps :: proc "c" (
    	self:            ^Application, 
    	ignoreOtherApps: bool, 
    ) {…}
    Objective-C Method Information
    Syntax Usage
    self->activateIgnoringOtherApps(ignoreOtherApps)
    

    Application_currentEvent ¶

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

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

    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_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, 
    ) -> UInteger {…}
    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 {…}
    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)
    
    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)
    

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

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

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

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

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

    class_createInstance ¶

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

    class_getInstanceMethod ¶

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

    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)
    

    methodSignatureForSelector ¶

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

    method_setImplementation ¶

    method_setImplementation :: proc "c" (
    	method: ^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_lookUpClass ¶

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

    objc_registerClassPair ¶

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

    object_getIndexedIvars ¶

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

    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_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-03 (vendor "odin") Windows_amd64 @ 2024-03-01 21:10:24.554757900 +0000 UTC