package vendor:darwin/Foundation
Source

⌘K
Ctrl+K
or
/

    Index

    Types (89)
    Constants (33)
    Procedures (277)
    Procedure Groups (1)

    Types

    ActivationPolicy ¶
    Source

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

    Application ¶
    Source

    Application :: struct {
	 using _: Object,
}

    ApplicationDelegate ¶
    Source

    ApplicationDelegate :: struct {
	 using _: Object,
}

    ApplicationDelegateTemplate ¶
    Source

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

    ApplicationPresentationOptionFlag ¶
    Source

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

    ApplicationPresentationOptions :: distinct bit_set[ApplicationPresentationOptionFlag; UInteger]

    ApplicationPrintReply ¶
    Source

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

    ApplicationTerminateReply ¶
    Source

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

    Array ¶
    Source

    Array :: struct {
	 using _: Copying(Array),
}

    AutoreleasePool ¶
    Source

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

    BOOL ¶
    Source

    BOOL :: bool
     

    TODO(bill): should this be distinct?

    BackingStoreType ¶
    Source

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

    Block ¶
    Source

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

    Bundle ¶
    Source

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

    Class ¶
    Source

    Class :: ^.objc_class

    Coder ¶
    Source

    Coder :: struct {
	 using _: Object,
}

    Color ¶
    Source

    Color :: struct {
	 using _: Object,
}

    ComparisonResult ¶
    Source

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

    Condition ¶
    Source

    Condition :: struct {
	 using _: Locking(Condition),
}

    Copying ¶
    Source

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

    Data ¶
    Source

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

    Date ¶
    Source

    Date :: struct {
	 using _: Copying(Date),
}

    Dictionary ¶
    Source

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

    Enumerator ¶
    Source

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

    Error ¶
    Source

    Error :: struct {
	 using _: Copying(Error),
}

    ErrorDomain ¶
    Source

    ErrorDomain :: ^String

    ErrorUserInfoKey ¶
    Source

    ErrorUserInfoKey :: ^String

    Event ¶
    Source

    Event :: struct {
	 using _: Object,
}

    FastEnumeration ¶
    Source

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

    FastEnumerationState ¶
    Source

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

    Float ¶
    Source

    Float :: distinct f64

    IMP ¶
    Source

    IMP :: proc "c" (object: ^.objc_object, sel: ^.objc_selector, args: ..any) -> ^.objc_object

    Integer ¶
    Source

    Integer :: distinct int

    KeyEquivalentModifierFlag ¶
    Source

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

    KeyEquivalentModifierMask :: distinct bit_set[KeyEquivalentModifierFlag; UInteger]

    Layer ¶
    Source

    Layer :: struct {
	 using _: Object,
}

    Locking ¶
    Source

    Locking :: struct($T: typeid) {}
    Menu :: struct {
	 using _: Object,
}
    MenuItem :: struct {
	 using _: Object,
}
    MenuItemCallback :: proc "c" (unused: rawptr, name: ^.objc_selector, sender: ^Object)

    Method ¶
    Source

    Method :: ^objc_method

    ModalResponse ¶
    Source

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

    Notification ¶
    Source

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

    NotificationCenter ¶
    Source

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

    NotificationName ¶
    Source

    NotificationName :: ^String

    Number ¶
    Source

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

    Object ¶
    Source

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

    OpenPanel ¶
    Source

    OpenPanel :: struct {
	 using _: SavePanel,
}

    OperatingSystemVersion ¶
    Source

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

    Panel ¶
    Source

    Panel :: struct {
	 using _: Window,
}

    Pasteboard ¶
    Source

    Pasteboard :: struct {
	 using _: Object,
}

    Point ¶
    Source

    Point :: struct {
	x: Float,
	y: Float,
}

    Protocol ¶
    Source

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

    Range ¶
    Source

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

    Rect ¶
    Source

    Rect :: struct {
	 using origin: Point,
	 using size:   Size,
}

    Responder ¶
    Source

    Responder :: struct {
	 using _: Object,
}

    RunningApplication ¶
    Source

    RunningApplication :: struct {
	 using _: Object,
}

    SEL ¶
    Source

    SEL :: ^.objc_selector

    SavePanel ¶
    Source

    SavePanel :: struct {
	 using _: Panel,
}

    Screen ¶
    Source

    Screen :: struct {
	 using _: Object,
}

    Size ¶
    Source

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

    String ¶
    Source

    String :: struct {
	 using _: Copying(String),
}

    StringCompareOption ¶
    Source

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

    StringCompareOptions ¶
    Source

    StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger]

    StringEncoding ¶
    Source

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

    TimeInterval ¶
    Source

    TimeInterval :: distinct f64

    UInteger ¶
    Source

    UInteger :: distinct uint

    URL ¶
    Source

    URL :: struct {
	 using _: Copying(URL),
}

    UndoManager ¶
    Source

    UndoManager :: struct {
	 using _: Object,
}

    UserActivity ¶
    Source

    UserActivity :: struct {
	 using _: Object,
}

    UserDefaults ¶
    Source

    UserDefaults :: struct {
	 using _: Object,
}

    Value ¶
    Source

    Value :: struct {
	 using _: Copying(Value),
}

    View ¶
    Source

    View :: struct {
	 using _: Responder,
}

    Window ¶
    Source

    Window :: struct {
	 using _: Responder,
}

    WindowDelegate ¶
    Source

    WindowDelegate :: struct {
	 using _: Object,
}

    WindowDelegateTemplate ¶
    Source

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

    WindowStyleFlag ¶
    Source

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

    WindowStyleMask :: distinct bit_set[WindowStyleFlag; UInteger]

    Zone ¶
    Source

    Zone :: struct {
	 using _: Object,
}

    id ¶
    Source

    id :: ^.objc_object

    objc_cache ¶
    Source

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

    objc_class_internals ¶
    Source

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

    objc_ivar :: struct {}

    objc_ivar_list ¶
    Source

    objc_ivar_list :: struct {}

    objc_method ¶
    Source

    objc_method :: struct {
	method_name:  ^.objc_selector,
	method_types: cstring,
	method_imp:   IMP,
}

    objc_method_list ¶
    Source

    objc_method_list :: struct {}

    objc_object_internals ¶
    Source

    objc_object_internals :: struct {
	isa: ^objc_class_internals,
}

    objc_protocol_list ¶
    Source

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

    unichar ¶
    Source

    unichar :: distinct u16

    Constants

    ApplicationPresentationOptionsAutoHideDock ¶
    Source

    ApplicationPresentationOptionsAutoHideDock :: ApplicationPresentationOptions{.AutoHideDock}

    ApplicationPresentationOptionsAutoHideMenuBar ¶
    Source

    ApplicationPresentationOptionsAutoHideMenuBar :: ApplicationPresentationOptions{.AutoHideMenuBar}

    ApplicationPresentationOptionsAutoHideToolbar ¶
    Source

    ApplicationPresentationOptionsAutoHideToolbar :: ApplicationPresentationOptions{.AutoHideToolbar}

    ApplicationPresentationOptionsDefault ¶
    Source

    ApplicationPresentationOptionsDefault :: ApplicationPresentationOptions{}

    ApplicationPresentationOptionsDisableAppleMenu ¶
    Source

    ApplicationPresentationOptionsDisableAppleMenu :: ApplicationPresentationOptions{.DisableAppleMenu}

    ApplicationPresentationOptionsDisableCursorLocationAssistance ¶
    Source

    ApplicationPresentationOptionsDisableCursorLocationAssistance :: ApplicationPresentationOptions{.DisableCursorLocationAssistance}

    ApplicationPresentationOptionsDisableForceQuit ¶
    Source

    ApplicationPresentationOptionsDisableForceQuit :: ApplicationPresentationOptions{.DisableForceQuit}

    ApplicationPresentationOptionsDisableHideApplication ¶
    Source

    ApplicationPresentationOptionsDisableHideApplication :: ApplicationPresentationOptions{.DisableHideApplication}

    ApplicationPresentationOptionsDisableMenuBarTransparency ¶
    Source

    ApplicationPresentationOptionsDisableMenuBarTransparency :: ApplicationPresentationOptions{.DisableMenuBarTransparency}

    ApplicationPresentationOptionsDisableProcessSwitching ¶
    Source

    ApplicationPresentationOptionsDisableProcessSwitching :: ApplicationPresentationOptions{.DisableProcessSwitching}

    ApplicationPresentationOptionsDisableSessionTermination ¶
    Source

    ApplicationPresentationOptionsDisableSessionTermination :: ApplicationPresentationOptions{.DisableSessionTermination}

    ApplicationPresentationOptionsFullScreen ¶
    Source

    ApplicationPresentationOptionsFullScreen :: ApplicationPresentationOptions{.FullScreen}

    ApplicationPresentationOptionsHideDock ¶
    Source

    ApplicationPresentationOptionsHideDock :: ApplicationPresentationOptions{.HideDock}

    ApplicationPresentationOptionsHideMenuBar ¶
    Source

    ApplicationPresentationOptionsHideMenuBar :: ApplicationPresentationOptions{.HideMenuBar}

    IntegerMax ¶
    Source

    IntegerMax: Integer : max(Integer)

    Integermin ¶
    Source

    Integermin: Integer : min(Integer)

    NO ¶
    Source

    NO :: false

    NotFound ¶
    Source

    NotFound :: IntegerMax

    UIntegerMax ¶
    Source

    UIntegerMax: UInteger : max(UInteger)

    WindowStyleMaskBorderless ¶
    Source

    WindowStyleMaskBorderless :: WindowStyleMask{}

    WindowStyleMaskClosable ¶
    Source

    WindowStyleMaskClosable :: WindowStyleMask{.Closable}

    WindowStyleMaskDocModalWindow ¶
    Source

    WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow}

    WindowStyleMaskFullScreen ¶
    Source

    WindowStyleMaskFullScreen :: WindowStyleMask{.FullScreen}

    WindowStyleMaskFullSizeContentView ¶
    Source

    WindowStyleMaskFullSizeContentView :: WindowStyleMask{.FullSizeContentView}

    WindowStyleMaskHUDWindow ¶
    Source

    WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow}

    WindowStyleMaskMiniaturizable ¶
    Source

    WindowStyleMaskMiniaturizable :: WindowStyleMask{.Miniaturizable}

    WindowStyleMaskNonactivatingPanel ¶
    Source

    WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel}

    WindowStyleMaskResizable ¶
    Source

    WindowStyleMaskResizable :: WindowStyleMask{.Resizable}

    WindowStyleMaskTexturedBackground ¶
    Source

    WindowStyleMaskTexturedBackground :: WindowStyleMask{.TexturedBackground}

    WindowStyleMaskTitled ¶
    Source

    WindowStyleMaskTitled :: WindowStyleMask{.Titled}

    WindowStyleMaskUnifiedTitleAndToolbar ¶
    Source

    WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}

    WindowStyleMaskUtilityWindow ¶
    Source

    WindowStyleMaskUtilityWindow :: WindowStyleMask{.UtilityWindow}

    YES ¶
    Source

    YES :: true

    Variables

    CocoaErrorDomain ¶
    Source

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

    DebugDescriptionErrorKey ¶
    Source

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

    FilePathErrorKey ¶
    Source

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

    HelpAnchorErrorKey ¶
    Source

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

    KeyEventModifierFlagDeviceIndependentFlagsMask ¶
    Source

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

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

    LocalizedFailureErrorKey ¶
    Source

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

    LocalizedFailureReasonErrorKey ¶
    Source

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

    LocalizedRecoveryOptionsErrorKey ¶
    Source

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

    LocalizedRecoverySuggestionErrorKey ¶
    Source

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

    MachErrorDomain ¶
    Source

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

    OSStatusErrorDomain ¶
    Source

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

    POSIXErrorDomain ¶
    Source

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

    RecoveryAttempterErrorKey ¶
    Source

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

    StringEncodingErrorKey ¶
    Source

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

    URLErrorKey ¶
    Source

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

    UnderlyingErrorKey ¶
    Source

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

    Procedures

    AT ¶
    Source

    AllocateObject ¶
    Source

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

    Application_activateIgnoringOtherApps ¶
    Source

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

    Application_run ¶
    Source

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

    Application_setActivationPolicy ¶
    Source

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

    Application_setDelegate ¶
    Source

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

    Application_setMainMenu ¶
    Source

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

    Application_sharedApplication ¶
    Source

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

    Application_terminate ¶
    Source

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

    Application_windows ¶
    Source

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

    Array_alloc ¶
    Source

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

    Array_count ¶
    Source

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

    Array_init ¶
    Source

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

    Array_initWithCoder ¶
    Source

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

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

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

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

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

    AutoreleasePool_alloc ¶
    Source

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

    AutoreleasePool_drain ¶
    Source

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

    AutoreleasePool_init ¶
    Source

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

    AutoreleasePool_showPools ¶
    Source

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

    Block_createGlobal ¶
    Source

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

    Block_createLocal ¶
    Source

    Block_createLocal :: proc "c" (
	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,
)

    Bundle_PathForAuxiliaryExecutable ¶
    Source

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

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

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

    Bundle_allFrameworks ¶
    Source

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

    Bundle_alloc ¶
    Source

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

    Bundle_appStoreReceiptPath ¶
    Source

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

    Bundle_appStoreReceiptURL ¶
    Source

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

    Bundle_builtInPlugInsPath ¶
    Source

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

    Bundle_builtInPlugInsURL ¶
    Source

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

    Bundle_bundleIdentifier ¶
    Source

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

    Bundle_bundlePath ¶
    Source

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

    Bundle_bundleURL ¶
    Source

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

    Bundle_bundleWithPath ¶
    Source

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

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

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

    Bundle_executableURL ¶
    Source

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

    Bundle_infoDictionary ¶
    Source

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

    Bundle_init ¶
    Source

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

    Bundle_initWithPath ¶
    Source

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

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

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

    Bundle_load ¶
    Source

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

    Bundle_loadAndReturnError ¶
    Source

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

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

    Bundle_localizedStringForKey ¶
    Source

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

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

    Bundle_objectForInfoDictionaryKey ¶
    Source

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

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

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

    Bundle_privateFrameworksURL ¶
    Source

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

    Bundle_resourcePath ¶
    Source

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

    Bundle_resourceURL ¶
    Source

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

    Bundle_sharedFrameworksPath ¶
    Source

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

    Bundle_sharedFrameworksURL ¶
    Source

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

    Bundle_sharedSupportPath ¶
    Source

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

    Bundle_sharedSupportURL ¶
    Source

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

    Bundle_unload ¶
    Source

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

    Condition_alloc ¶
    Source

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

    Condition_broadcast ¶
    Source

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

    Condition_init ¶
    Source

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

    Condition_lock ¶
    Source

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

    Condition_signal ¶
    Source

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

    Condition_unlock ¶
    Source

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

    Condition_wait ¶
    Source

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

    Condition_waitUntilDate ¶
    Source

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

    Data_alloc ¶
    Source

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

    Data_init ¶
    Source

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

    Data_length ¶
    Source

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

    Data_mutableBytes ¶
    Source

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

    Date_alloc ¶
    Source

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

    Date_dateWithTimeIntervalSinceNow ¶
    Source

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

    Date_init ¶
    Source

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

    DeallocateObject ¶
    Source

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

    Dictionary_alloc ¶
    Source

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

    Dictionary_count ¶
    Source

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

    Dictionary_dictionary ¶
    Source

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

    Dictionary_dictionaryWithObject ¶
    Source

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

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

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

    Dictionary_initWithObjects ¶
    Source

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

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

    Dictionary_objectForKey ¶
    Source

    Dictionary_objectForKey :: proc "c" (
	self: ^Dictionary, 
	key:  ^Object, 
) -> ^Object {…}
    Objective-C Method Information
    Syntax Usage
    res := self->objectForKey(key)

    Enumerator_allObjects ¶
    Source

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

    Enumerator_iterator ¶
    Source

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

    Enumerator_nextObject ¶
    Source

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

    Error_alloc ¶
    Source

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

    Error_code ¶
    Source

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

    Error_domain ¶
    Source

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

    Error_errorWithDomain ¶
    Source

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

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

    Error_initWithDomain ¶
    Source

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

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

    Error_localizedFailureReason ¶
    Source

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

    Error_localizedRecoveryOptions ¶
    Source

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

    Error_localizedRecoverySuggestion ¶
    Source

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

    Error_userInfo ¶
    Source

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

    FastEnumeration_alloc ¶
    Source

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

    FastEnumeration_countByEnumerating ¶
    Source

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

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

    Layer_addSublayer ¶
    Source

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

    Layer_contentsScale ¶
    Source

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

    Layer_frame ¶
    Source

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

    Layer_setContentsScale ¶
    Source

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

    Locking_lock ¶
    Source

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

    Locking_unlock ¶
    Source

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

    MakeConstantString ¶
    Source

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

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

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

    NotificationCenter_defaultCenter ¶
    Source

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

    NotificationCenter_init ¶
    Source

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

    NotificationCenter_removeObserver ¶
    Source

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

    Notification_alloc ¶
    Source

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

    Notification_init ¶
    Source

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

    Notification_name ¶
    Source

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

    Notification_object ¶
    Source

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

    Notification_userInfo ¶
    Source

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

    Number_alloc ¶
    Source

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

    Number_boolValue ¶
    Source

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

    Number_compare ¶
    Source

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

    Number_descriptionWithLocale ¶
    Source

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

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

    Number_f64Value ¶
    Source

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

    Number_i16Value ¶
    Source

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

    Number_i32Value ¶
    Source

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

    Number_i64Value ¶
    Source

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

    Number_i8Value ¶
    Source

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

    Number_init ¶
    Source

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

    Number_initWithBool ¶
    Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Number_integerValue ¶
    Source

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

    Number_isEqualToNumber ¶
    Source

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

    Number_numberWithBool ¶
    Source

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

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

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

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

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

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

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

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

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

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

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

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

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

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

    Number_u16Value ¶
    Source

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

    Number_u32Value ¶
    Source

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

    Number_u64Value ¶
    Source

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

    Number_u8Value ¶
    Source

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

    Number_uintValue ¶
    Source

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

    Number_uintegerValue ¶
    Source

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

    OpenPanel_URLs ¶
    Source

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

    OpenPanel_openPanel ¶
    Source

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

    OpenPanel_setAllowsMultipleSelection ¶
    Source

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

    OpenPanel_setCanChooseDirectories ¶
    Source

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

    OpenPanel_setCanChooseFiles ¶
    Source

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

    OpenPanel_setResolvesAliases ¶
    Source

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

    Range_Equal ¶
    Source

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

    Range_LocationInRange ¶
    Source

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

    Range_Make ¶
    Source

    Range_Make :: proc "c" (
	loc, 
	len: UInteger, 
) -> Range {…}

    Range_Max ¶
    Source

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

    RunningApplication_currentApplication ¶
    Source

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

    RunningApplication_localizedName ¶
    Source

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

    SavePanel_runModal ¶
    Source

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

    StringFromClass ¶
    Source

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

    String_UTF8String ¶
    Source

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

    String_alloc ¶
    Source

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

    String_characterAtIndex ¶
    Source

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

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

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

    String_initWithBytesNoCopy ¶
    Source

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

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

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

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

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

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

    String_lengthOfBytesUsingEncoding ¶
    Source

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

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

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

    String_rangeOfString ¶
    Source

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

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

    URL_fileSystemRepresentation ¶
    Source

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

    URL_init ¶
    Source

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

    URL_initFileURLWithPath ¶
    Source

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

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

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

    UserDefaults_standardUserDefaults ¶
    Source

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

    Value_alloc ¶
    Source

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

    Value_getValue ¶
    Source

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

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

    Value_initWithBytes ¶
    Source

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

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

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

    Value_objCType ¶
    Source

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

    Value_pointerValue ¶
    Source

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

    Value_valueWithBytes ¶
    Source

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

    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_initWithFrame ¶
    Source

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

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

    View_setLayer ¶
    Source

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

    View_setWantsLayer ¶
    Source

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

    View_wantsLayer ¶
    Source

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

    Window_alloc ¶
    Source

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

    Window_backgroundColor ¶
    Source

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

    Window_close ¶
    Source

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

    Window_contentLayoutRect ¶
    Source

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

    Window_contentView ¶
    Source

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

    Window_frame ¶
    Source

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

    Window_initWithContentRect ¶
    Source

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

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

    Window_opaque ¶
    Source

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

    Window_setBackgroundColor ¶
    Source

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

    Window_setContentView ¶
    Source

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

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

    Window_setFrame ¶
    Source

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

    Window_setMovable ¶
    Source

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

    Window_setMovableByWindowBackground ¶
    Source

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

    Window_setOpaque ¶
    Source

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

    Window_setStyleMask ¶
    Source

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

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

    Window_setTitlebarAppearsTransparent ¶
    Source

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

    alloc ¶
    Source

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

    application_delegate_register_and_alloc ¶
    Source

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

    autorelease ¶
    Source

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

    bridgingCast ¶
    Source

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

    class ¶
    Source

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

    class_addMethod ¶
    Source

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

    class_createInstance ¶
    Source

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

    class_getInstanceMethod ¶
    Source

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

    copy ¶
    Source

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

    debugDescription ¶
    Source

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

    description ¶
    Source

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

    hash ¶
    Source

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

    init ¶
    Source

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

    isEqual ¶
    Source

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

    methodSignatureForSelector ¶
    Source

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

    method_setImplementation ¶
    Source

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

    msgSendSafeCheck ¶
    Source

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

    new ¶
    Source

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

    objc_allocateClassPair ¶
    Source

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

    objc_lookUpClass ¶
    Source

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

    objc_registerClassPair ¶
    Source

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

    object_getIndexedIvars ¶
    Source

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

    release ¶
    Source

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

    respondsToSelector ¶
    Source

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

    retain ¶
    Source

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

    retainCount ¶
    Source

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

    scoped_autoreleasepool ¶
    Source

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

    sel_registerName ¶
    Source

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

    window_delegate_register_and_alloc ¶
    Source

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

    Procedure Groups

    Number_number ¶
    Source

    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-2023-06 (vendor "odin") Windows_amd64 @ 2023-06-02 21:08:32.820117100 +0000 UTC