package vendor:darwin/Foundation

Index

Procedures (250)
Procedure Groups (1)

Types

ActivationPolicy ¶

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

ApplicationDelegate ¶

ApplicationDelegate :: struct {
	willFinishLaunching:                  proc "cdecl" (self: ^ApplicationDelegate, notification: ^Notification),
	didFinishLaunching:                   proc "cdecl" (self: ^ApplicationDelegate, notification: ^Notification),
	shouldTerminateAfterLastWindowClosed: proc "cdecl" (self: ^ApplicationDelegate, sender: ^Application),
	user_data:                            rawptr,
}

Application ¶

Application :: struct {
	_: Object,
}

Array ¶

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

AutoreleasePool ¶

AutoreleasePool :: struct {
	_: Object,
}

BOOL ¶

BOOL :: bool

BackingStoreType ¶

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

Block ¶

Block :: struct {
	_: Object,
}

Bundle ¶

Bundle :: struct {
	_: Object,
}

Coder ¶

Coder :: struct {
	_: Object,
}

Color ¶

Color :: struct {
	_: Object,
}

ComparisonResult ¶

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

Condition ¶

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

Copying ¶

Copying :: struct {}

Data ¶

Data :: struct {
	_: Copying(Data),
}

Date ¶

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

Dictionary ¶

Dictionary :: struct {
	_: Copying(Dictionary),
}

Enumerator ¶

Enumerator :: struct {}

Error ¶

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

ErrorDomain ¶

ErrorDomain :: ^String

ErrorUserInfoKey ¶

ErrorUserInfoKey :: ^String

FastEnumeration ¶

FastEnumeration :: struct {
	_: Object,
}

FastEnumerationState ¶

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

Float ¶

Float :: distinct f64

IMP ¶

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

Integer ¶

Integer :: distinct int

KeyEquivalentModifierFlag ¶

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

KeyEquivalentModifierMask ¶

KeyEquivalentModifierMask :: distinct bit_set[KeyEquivalentModifierFlag; UInteger]

Layer ¶

Layer :: struct {
	_: Object,
}

Locking ¶

Locking :: struct {}
MenuItem :: struct {
	_: Object,
}
MenuItemCallback :: proc "cdecl" (unused: rawptr, name: ^.objc_selector, sender: ^Object)
Menu :: struct {
	_: Object,
}

Notification ¶

Notification :: struct {
	_: Object,
}

Number ¶

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

Object ¶

Object :: struct {
	_: .objc_object,
}

OperatingSystemVersion ¶

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

Point ¶

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

Protocol ¶

Protocol :: struct {
	_: .objc_object,
}

Range ¶

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

Rect ¶

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

Responder ¶

Responder :: struct {
	_: Object,
}

RunningApplication ¶

RunningApplication :: struct {
	_: Object,
}

Size ¶

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

StringCompareOptions ¶

StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger]

StringCompareOption ¶

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

StringEncoding ¶

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

String ¶

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

TimeInterval ¶

TimeInterval :: distinct f64

UInteger ¶

UInteger :: distinct uint

URL ¶

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

Value ¶

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

View ¶

View :: struct {
	_: Responder,
}

WindowStyleFlag ¶

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

Window ¶

Window :: struct {
	_: Responder,
}

WindowStyleMask ¶

WindowStyleMask :: distinct bit_set[WindowStyleFlag; UInteger]

Zone ¶

Zone :: struct {
	_: Object,
}

objc_cache ¶

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

objc_class_internals ¶

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

objc_ivar_list ¶

objc_ivar_list :: struct {}

objc_ivar ¶

objc_ivar :: struct {}

objc_method ¶

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

objc_method_list ¶

objc_method_list :: struct {}

objc_object_internals ¶

objc_object_internals :: struct {
	isa: ^objc_class_internals,
}

objc_protocol_list ¶

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

unichar ¶

unichar :: distinct u16

Constants

IntegerMax ¶

IntegerMax: Integer : max(Integer)

Integermin ¶

Integermin: Integer : min(Integer)

NO ¶

NO :: false

NotFound ¶

NotFound :: IntegerMax

UIntegerMax ¶

UIntegerMax: UInteger : max(UInteger)

WindowStyleMaskBorderless ¶

WindowStyleMaskBorderless :: WindowStyleMask{}

WindowStyleMaskClosable ¶

WindowStyleMaskClosable :: WindowStyleMask{.Closable}

WindowStyleMaskDocModalWindow ¶

WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow}

WindowStyleMaskFullScreen ¶

WindowStyleMaskFullScreen :: WindowStyleMask{.FullScreen}

WindowStyleMaskFullSizeContentView ¶

WindowStyleMaskFullSizeContentView :: WindowStyleMask{.FullSizeContentView}

WindowStyleMaskHUDWindow ¶

WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow}

WindowStyleMaskMiniaturizable ¶

WindowStyleMaskMiniaturizable :: WindowStyleMask{.Miniaturizable}

WindowStyleMaskNonactivatingPanel ¶

WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel}

WindowStyleMaskResizable ¶

WindowStyleMaskResizable :: WindowStyleMask{.Resizable}

WindowStyleMaskTexturedBackground ¶

WindowStyleMaskTexturedBackground :: WindowStyleMask{.TexturedBackground}

WindowStyleMaskTitled ¶

WindowStyleMaskTitled :: WindowStyleMask{.Titled}

WindowStyleMaskUnifiedTitleAndToolbar ¶

WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}

WindowStyleMaskUtilityWindow ¶

WindowStyleMaskUtilityWindow :: WindowStyleMask{.UtilityWindow}

YES ¶

YES :: true

Variables

CocoaErrorDomain ¶

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

DebugDescriptionErrorKey ¶

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

FilePathErrorKey ¶

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

HelpAnchorErrorKey ¶

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

KeyEventModifierFlagDeviceIndependentFlagsMask ¶

KeyEventModifierFlagDeviceIndependentFlagsMask: KeyEquivalentModifierMask = …
 

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

LocalizedDescriptionKey ¶

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

LocalizedFailureErrorKey ¶

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

LocalizedFailureReasonErrorKey ¶

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

LocalizedRecoveryOptionsErrorKey ¶

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

LocalizedRecoverySuggestionErrorKey ¶

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

MachErrorDomain ¶

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

OSStatusErrorDomain ¶

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

POSIXErrorDomain ¶

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

RecoveryAttempterErrorKey ¶

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

StringEncodingErrorKey ¶

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

URLErrorKey ¶

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

UnderlyingErrorKey ¶

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

Procedures

AllocateObject ¶

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

Application_activateIgnoringOtherApps ¶

Application_activateIgnoringOtherApps :: proc "odin" (self: ^Application, ignoreOtherApps: bool) {…}

Application_run ¶

Application_run :: proc "odin" (self: ^Application) {…}

Application_setActivationPolicy ¶

Application_setActivationPolicy :: proc "odin" (self: ^Application, activationPolicy: ActivationPolicy) -> bool {…}

Application_setDelegate ¶

Application_setDelegate :: proc "odin" (self: ^Application, delegate: ^ApplicationDelegate) {…}

Application_setMainMenu ¶

Application_setMainMenu :: proc "odin" (self: ^Application, menu: ^Menu) {…}

Application_sharedApplication ¶

Application_sharedApplication :: proc "odin" () -> ^Application {…}

Application_terminate ¶

Application_terminate :: proc "odin" (self: ^Application, sender: ^Object) {…}

Application_windows ¶

Application_windows :: proc "odin" (self: ^Application) -> ^Array {…}

Array_alloc ¶

Array_alloc :: proc "odin" () -> ^Array {…}

Array_count ¶

Array_count :: proc "odin" (self: ^Array) -> UInteger {…}

Array_init ¶

Array_init :: proc "odin" (self: ^Array) -> ^Array {…}

Array_initWithCoder ¶

Array_initWithCoder :: proc "odin" (self: ^Array, coder: ^Coder) -> ^Array {…}

Array_initWithObjects ¶

Array_initWithObjects :: proc "odin" (self: ^Array, objects: [^]^Object, count: UInteger) -> ^Array {…}

Array_object ¶

Array_object :: proc "odin" (self: ^Array, index: UInteger) -> ^Object {…}

Array_objectAs ¶

Array_objectAs :: proc "odin" (self: ^Array, index: UInteger, $T: typeid) -> typeid {…}

AutoreleasePool_addObject ¶

AutoreleasePool_addObject :: proc "odin" (self: ^AutoreleasePool, obj: ^Object) {…}

AutoreleasePool_alloc ¶

AutoreleasePool_alloc :: proc "odin" () -> ^AutoreleasePool {…}

AutoreleasePool_drain ¶

AutoreleasePool_drain :: proc "odin" (self: ^AutoreleasePool) {…}

AutoreleasePool_init ¶

AutoreleasePool_init :: proc "odin" (self: ^AutoreleasePool) -> ^AutoreleasePool {…}

AutoreleasePool_showPools ¶

AutoreleasePool_showPools :: proc "odin" (self: ^AutoreleasePool, obj: ^Object) {…}

Block_createGlobal ¶

Block_createGlobal :: proc "cdecl" (user_data: rawptr, user_proc: proc "cdecl" (_: rawptr)) -> ^Block {…}

Block_createLocal ¶

Block_createLocal :: proc "cdecl" (user_data: rawptr, user_proc: proc "cdecl" (_: rawptr)) -> ^Block {…}

Bundle_PathForAuxiliaryExecutable ¶

Bundle_PathForAuxiliaryExecutable :: proc "odin" (self: ^Bundle, executableName: ^String) -> ^String {…}

Bundle_URLForAuxiliaryExecutable ¶

Bundle_URLForAuxiliaryExecutable :: proc "odin" (self: ^Bundle, executableName: ^String) -> ^URL {…}

Bundle_allBundles ¶

Bundle_allBundles :: proc "odin" () -> ^Array {…}

Bundle_allFrameworks ¶

Bundle_allFrameworks :: proc "odin" () -> ^Array {…}

Bundle_alloc ¶

Bundle_alloc :: proc "odin" () -> ^Bundle {…}

Bundle_appStoreReceiptPath ¶

Bundle_appStoreReceiptPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_appStoreReceiptURL ¶

Bundle_appStoreReceiptURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_builtInPlugInsPath ¶

Bundle_builtInPlugInsPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_builtInPlugInsURL ¶

Bundle_builtInPlugInsURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_bundleIdentifier ¶

Bundle_bundleIdentifier :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_bundlePath ¶

Bundle_bundlePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_bundleURL ¶

Bundle_bundleURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_bundleWithPath ¶

Bundle_bundleWithPath :: proc "odin" (path: ^String) -> ^Bundle {…}

Bundle_bundleWithURL ¶

Bundle_bundleWithURL :: proc "odin" (url: ^URL) -> ^Bundle {…}

Bundle_executablePath ¶

Bundle_executablePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_executableURL ¶

Bundle_executableURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_infoDictionary ¶

Bundle_infoDictionary :: proc "odin" (self: ^Bundle) -> ^Dictionary {…}

Bundle_init ¶

Bundle_init :: proc "odin" (self: ^Bundle) -> ^Bundle {…}

Bundle_initWithPath ¶

Bundle_initWithPath :: proc "odin" (self: ^Bundle, path: ^String) -> ^Bundle {…}

Bundle_initWithURL ¶

Bundle_initWithURL :: proc "odin" (self: ^Bundle, url: ^URL) -> ^Bundle {…}

Bundle_isLoaded ¶

Bundle_isLoaded :: proc "odin" (self: ^Bundle) -> bool {…}

Bundle_load ¶

Bundle_load :: proc "odin" (self: ^Bundle) -> bool {…}

Bundle_loadAndReturnError ¶

Bundle_loadAndReturnError :: proc "odin" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}

Bundle_localizedInfoDictionary ¶

Bundle_localizedInfoDictionary :: proc "odin" (self: ^Bundle) -> ^Dictionary {…}

Bundle_localizedStringForKey ¶

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

Bundle_mainBundle ¶

Bundle_mainBundle :: proc "odin" () -> ^Bundle {…}

Bundle_objectForInfoDictionaryKey ¶

Bundle_objectForInfoDictionaryKey :: proc "odin" (self: ^Bundle, key: ^String) -> ^Object {…}

Bundle_preflightAndReturnError ¶

Bundle_preflightAndReturnError :: proc "odin" (self: ^Bundle) -> (ok: bool, error: ^Error) {…}

Bundle_privateFrameworksPath ¶

Bundle_privateFrameworksPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_privateFrameworksURL ¶

Bundle_privateFrameworksURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_resourcePath ¶

Bundle_resourcePath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_resourceURL ¶

Bundle_resourceURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_sharedFrameworksPath ¶

Bundle_sharedFrameworksPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_sharedFrameworksURL ¶

Bundle_sharedFrameworksURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_sharedSupportPath ¶

Bundle_sharedSupportPath :: proc "odin" (self: ^Bundle) -> ^String {…}

Bundle_sharedSupportURL ¶

Bundle_sharedSupportURL :: proc "odin" (self: ^Bundle) -> ^URL {…}

Bundle_unload ¶

Bundle_unload :: proc "odin" (self: ^Bundle) -> bool {…}

Condition_alloc ¶

Condition_alloc :: proc "odin" () -> ^Condition {…}

Condition_broadcast ¶

Condition_broadcast :: proc "odin" (self: ^Condition) {…}

Condition_init ¶

Condition_init :: proc "odin" (self: ^Condition) -> ^Condition {…}

Condition_lock ¶

Condition_lock :: proc "odin" (self: ^Condition) {…}

Condition_signal ¶

Condition_signal :: proc "odin" (self: ^Condition) {…}

Condition_unlock ¶

Condition_unlock :: proc "odin" (self: ^Condition) {…}

Condition_wait ¶

Condition_wait :: proc "odin" (self: ^Condition) {…}

Condition_waitUntilDate ¶

Condition_waitUntilDate :: proc "odin" (self: ^Condition, limit: ^Date) -> bool {…}

Data_alloc ¶

Data_alloc :: proc "odin" () -> ^Data {…}

Data_init ¶

Data_init :: proc "odin" (self: ^Data) -> ^Data {…}

Data_length ¶

Data_length :: proc "odin" (self: ^Data) -> UInteger {…}

Data_mutableBytes ¶

Data_mutableBytes :: proc "odin" (self: ^Data) -> rawptr {…}

Date_alloc ¶

Date_alloc :: proc "odin" () -> ^Date {…}

Date_dateWithTimeIntervalSinceNow ¶

Date_dateWithTimeIntervalSinceNow :: proc "odin" (secs: TimeInterval) -> ^Date {…}

Date_init ¶

Date_init :: proc "odin" (self: ^Date) -> ^Date {…}

DeallocateObject ¶

DeallocateObject :: proc "cdecl" (object: ^.objc_object) ---

Dictionary_alloc ¶

Dictionary_alloc :: proc "odin" () -> ^Dictionary {…}

Dictionary_count ¶

Dictionary_count :: proc "odin" (self: ^Dictionary) -> UInteger {…}

Dictionary_dictionaryWithObjects ¶

Dictionary_dictionaryWithObjects :: proc "odin" (objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {…}

Dictionary_dictionaryWithObject ¶

Dictionary_dictionaryWithObject :: proc "odin" (object: ^Object, forKey: ^Object) -> ^Dictionary {…}

Dictionary_dictionary ¶

Dictionary_dictionary :: proc "odin" () -> ^Dictionary {…}

Dictionary_initWithObjects ¶

Dictionary_initWithObjects :: proc "odin" (self: ^Dictionary, objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {…}

Dictionary_init ¶

Dictionary_init :: proc "odin" (self: ^Dictionary) -> ^Dictionary {…}

Dictionary_keyEnumerator ¶

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

Dictionary_objectForKey ¶

Dictionary_objectForKey :: proc "odin" (self: ^Dictionary, key: ^Object) -> ^Object {…}

Enumerator_allObjects ¶

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

Enumerator_iterator ¶

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

Enumerator_nextObject ¶

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

Error_alloc ¶

Error_alloc :: proc "odin" () -> ^Error {…}

Error_code ¶

Error_code :: proc "odin" (self: ^Error) -> Integer {…}

Error_domain ¶

Error_domain :: proc "odin" (self: ^Error) -> ^String {…}

Error_errorWithDomain ¶

Error_errorWithDomain :: proc "odin" (domain: ^String, code: Integer, userInfo: ^Dictionary) -> ^Error {…}

Error_init ¶

Error_init :: proc "odin" (self: ^Error) -> ^Error {…}

Error_initWithDomain ¶

Error_initWithDomain :: proc "odin" (self: ^Error, domain: ^String, code: Integer, userInfo: ^Dictionary) -> ^Error {…}

Error_localizedDescription ¶

Error_localizedDescription :: proc "odin" (self: ^Error) -> ^String {…}

Error_localizedFailureReason ¶

Error_localizedFailureReason :: proc "odin" (self: ^Error) -> ^String {…}

Error_localizedRecoveryOptions ¶

Error_localizedRecoveryOptions :: proc "odin" (self: ^Error) -> (options: ^Array) {…}

Error_localizedRecoverySuggestion ¶

Error_localizedRecoverySuggestion :: proc "odin" (self: ^Error) -> ^String {…}

Error_userInfo ¶

Error_userInfo :: proc "odin" (self: ^Error) -> ^Dictionary {…}

FastEnumeration_alloc ¶

FastEnumeration_alloc :: proc "odin" () -> ^FastEnumeration {…}

FastEnumeration_countByEnumerating ¶

FastEnumeration_countByEnumerating :: proc "odin" (self: ^FastEnumeration, state: ^FastEnumerationState, buffer: [^]^Object, len: UInteger) -> UInteger {…}

FastEnumeration_init ¶

FastEnumeration_init :: proc "odin" (self: ^FastEnumeration) -> ^FastEnumeration {…}

Layer_addSublayer ¶

Layer_addSublayer :: proc "odin" (self: ^Layer, layer: ^Layer) {…}

Layer_contentsScale ¶

Layer_contentsScale :: proc "odin" (self: ^Layer) -> Float {…}

Layer_frame ¶

Layer_frame :: proc "odin" (self: ^Layer) -> Rect {…}

Layer_setContentsScale ¶

Layer_setContentsScale :: proc "odin" (self: ^Layer, scale: Float) {…}

Locking_lock ¶

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

Locking_unlock ¶

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

MakeConstantString ¶

MakeConstantString :: proc "cdecl" (#const c: cstring) -> ^String {…}
MenuItem_alloc :: proc "odin" () -> ^MenuItem {…}
MenuItem_init :: proc "odin" (self: ^MenuItem) -> ^MenuItem {…}
MenuItem_keyEquivalentModifierMask :: proc "odin" (self: ^MenuItem) -> KeyEquivalentModifierMask {…}
MenuItem_registerActionCallback :: proc "odin" (name: cstring, callback: MenuItemCallback) -> ^.objc_selector {…}
MenuItem_setKeyEquivalentModifierMask :: proc "odin" (self: ^MenuItem, modifierMask: KeyEquivalentModifierMask) {…}
MenuItem_setSubmenu :: proc "odin" (self: ^MenuItem, submenu: ^Menu) {…}
Menu_addItemWithTitle :: proc "odin" (self: ^Menu, title: ^String, selector: ^.objc_selector, keyEquivalent: ^String) -> ^MenuItem {…}
Menu_addItem :: proc "odin" (self: ^Menu, item: ^MenuItem) {…}
Menu_alloc :: proc "odin" () -> ^Menu {…}
Menu_init :: proc "odin" (self: ^Menu) -> ^Menu {…}
Menu_initWithTitle :: proc "odin" (self: ^Menu, title: ^String) -> ^Menu {…}

Notification_alloc ¶

Notification_alloc :: proc "odin" () -> ^Notification {…}

Notification_init ¶

Notification_init :: proc "odin" (self: ^Notification) -> ^Notification {…}

Notification_name ¶

Notification_name :: proc "odin" (self: ^Notification) -> ^String {…}

Notification_object ¶

Notification_object :: proc "odin" (self: ^Notification) -> ^Object {…}

Notification_userInfo ¶

Notification_userInfo :: proc "odin" (self: ^Notification) -> ^Dictionary {…}

Number_alloc ¶

Number_alloc :: proc "odin" () -> ^Number {…}

Number_boolValue ¶

Number_boolValue :: proc "odin" (self: ^Number) -> bool {…}

Number_compare ¶

Number_compare :: proc "odin" (self, other: ^Number) -> ComparisonResult {…}

Number_descriptionWithLocale ¶

Number_descriptionWithLocale :: proc "odin" (self: ^Number, locale: ^Object) -> ^String {…}

Number_f32Value ¶

Number_f32Value :: proc "odin" (self: ^Number) -> f32 {…}

Number_f64Value ¶

Number_f64Value :: proc "odin" (self: ^Number) -> f64 {…}

Number_i16Value ¶

Number_i16Value :: proc "odin" (self: ^Number) -> i16 {…}

Number_i32Value ¶

Number_i32Value :: proc "odin" (self: ^Number) -> i32 {…}

Number_i64Value ¶

Number_i64Value :: proc "odin" (self: ^Number) -> i64 {…}

Number_i8Value ¶

Number_i8Value :: proc "odin" (self: ^Number) -> i8 {…}

Number_init ¶

Number_init :: proc "odin" (self: ^Number) -> ^Number {…}

Number_initWithBool ¶

Number_initWithBool :: proc "odin" (self: ^Number, value: bool) -> ^Number {…}

Number_initWithF32 ¶

Number_initWithF32 :: proc "odin" (self: ^Number, value: f32) -> ^Number {…}

Number_initWithF64 ¶

Number_initWithF64 :: proc "odin" (self: ^Number, value: f64) -> ^Number {…}

Number_initWithI16 ¶

Number_initWithI16 :: proc "odin" (self: ^Number, value: i16) -> ^Number {…}

Number_initWithI32 ¶

Number_initWithI32 :: proc "odin" (self: ^Number, value: i32) -> ^Number {…}

Number_initWithI64 ¶

Number_initWithI64 :: proc "odin" (self: ^Number, value: i64) -> ^Number {…}

Number_initWithI8 ¶

Number_initWithI8 :: proc "odin" (self: ^Number, value: i8) -> ^Number {…}

Number_initWithInt ¶

Number_initWithInt :: proc "odin" (self: ^Number, value: int) -> ^Number {…}

Number_initWithU16 ¶

Number_initWithU16 :: proc "odin" (self: ^Number, value: u16) -> ^Number {…}

Number_initWithU32 ¶

Number_initWithU32 :: proc "odin" (self: ^Number, value: u32) -> ^Number {…}

Number_initWithU64 ¶

Number_initWithU64 :: proc "odin" (self: ^Number, value: u64) -> ^Number {…}

Number_initWithU8 ¶

Number_initWithU8 :: proc "odin" (self: ^Number, value: u8) -> ^Number {…}

Number_initWithUint ¶

Number_initWithUint :: proc "odin" (self: ^Number, value: uint) -> ^Number {…}

Number_intValue ¶

Number_intValue :: proc "odin" (self: ^Number) -> int {…}

Number_integerValue ¶

Number_integerValue :: proc "odin" (self: ^Number) -> Integer {…}

Number_isEqualToNumber ¶

Number_isEqualToNumber :: proc "odin" (self, other: ^Number) -> bool {…}

Number_numberWithBool ¶

Number_numberWithBool :: proc "odin" (value: bool) -> ^Number {…}

Number_numberWithF32 ¶

Number_numberWithF32 :: proc "odin" (value: f32) -> ^Number {…}

Number_numberWithF64 ¶

Number_numberWithF64 :: proc "odin" (value: f64) -> ^Number {…}

Number_numberWithI16 ¶

Number_numberWithI16 :: proc "odin" (value: i16) -> ^Number {…}

Number_numberWithI32 ¶

Number_numberWithI32 :: proc "odin" (value: i32) -> ^Number {…}

Number_numberWithI64 ¶

Number_numberWithI64 :: proc "odin" (value: i64) -> ^Number {…}

Number_numberWithI8 ¶

Number_numberWithI8 :: proc "odin" (value: i8) -> ^Number {…}

Number_numberWithInt ¶

Number_numberWithInt :: proc "odin" (value: int) -> ^Number {…}

Number_numberWithU16 ¶

Number_numberWithU16 :: proc "odin" (value: u16) -> ^Number {…}

Number_numberWithU32 ¶

Number_numberWithU32 :: proc "odin" (value: u32) -> ^Number {…}

Number_numberWithU64 ¶

Number_numberWithU64 :: proc "odin" (value: u64) -> ^Number {…}

Number_numberWithU8 ¶

Number_numberWithU8 :: proc "odin" (value: u8) -> ^Number {…}

Number_numberWithUint ¶

Number_numberWithUint :: proc "odin" (value: uint) -> ^Number {…}

Number_stringValue ¶

Number_stringValue :: proc "odin" (self: ^Number) -> ^String {…}

Number_u16Value ¶

Number_u16Value :: proc "odin" (self: ^Number) -> u16 {…}

Number_u32Value ¶

Number_u32Value :: proc "odin" (self: ^Number) -> u32 {…}

Number_u64Value ¶

Number_u64Value :: proc "odin" (self: ^Number) -> u64 {…}

Number_u8Value ¶

Number_u8Value :: proc "odin" (self: ^Number) -> u8 {…}

Number_uintValue ¶

Number_uintValue :: proc "odin" (self: ^Number) -> uint {…}

Number_uintegerValue ¶

Number_uintegerValue :: proc "odin" (self: ^Number) -> UInteger {…}

Range_Equal ¶

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

Range_LocationInRange ¶

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

Range_Make ¶

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

Range_Max ¶

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

RunningApplication_currentApplication ¶

RunningApplication_currentApplication :: proc "odin" () -> ^RunningApplication {…}

RunningApplication_localizedName ¶

RunningApplication_localizedName :: proc "odin" (self: ^RunningApplication) -> ^String {…}

StringFromClass ¶

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

String_UTF8String ¶

String_UTF8String :: proc "odin" (self: ^String) -> cstring {…}

String_alloc ¶

String_alloc :: proc "odin" () -> ^String {…}

String_characterAtIndex ¶

String_characterAtIndex :: proc "odin" (self: ^String, index: UInteger) -> unichar {…}

String_cstringUsingEncoding ¶

String_cstringUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> cstring {…}

String_init ¶

String_init :: proc "odin" (self: ^String) -> ^String {…}

String_initWithBytesNoCopy ¶

String_initWithBytesNoCopy :: proc "odin" (self: ^String, pBytes: rawptr, length: UInteger, encoding: StringEncoding, freeWhenDone: bool) -> ^String {…}

String_initWithCString ¶

String_initWithCString :: proc "odin" (self: ^String, pString: cstring, encoding: StringEncoding) -> ^String {…}

String_initWithOdinString ¶

String_initWithOdinString :: proc "odin" (self: ^String, str: string) -> ^String {…}

String_initWithString ¶

String_initWithString :: proc "odin" (self: ^String, other: ^String) -> ^String {…}

String_isEqualToString ¶

String_isEqualToString :: proc "odin" (self: ^String, other: ^String) -> bool {…}

String_length ¶

String_length :: proc "odin" (self: ^String) -> UInteger {…}

String_lengthOfBytesUsingEncoding ¶

String_lengthOfBytesUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_maximumLengthOfBytesUsingEncoding ¶

String_maximumLengthOfBytesUsingEncoding :: proc "odin" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_odinString ¶

String_odinString :: proc "odin" (self: ^String) -> string {…}

String_rangeOfString ¶

String_rangeOfString :: proc "odin" (self, other: ^String, options: StringCompareOptions) -> Range {…}

URL_alloc ¶

URL_alloc :: proc "odin" () -> ^URL {…}

URL_fileSystemRepresentation ¶

URL_fileSystemRepresentation :: proc "odin" (self: ^URL) -> ^String {…}

URL_initFileURLWithPath ¶

URL_initFileURLWithPath :: proc "odin" (self: ^URL, value: ^String) -> ^URL {…}

URL_initWithString ¶

URL_initWithString :: proc "odin" (self: ^URL, value: ^String) -> ^URL {…}

URL_init ¶

URL_init :: proc "odin" (self: ^URL) -> ^URL {…}

Value_alloc ¶

Value_alloc :: proc "odin" () -> ^Value {…}

Value_getValue ¶

Value_getValue :: proc "odin" (self: ^Value, value: rawptr, size: UInteger) {…}

Value_init ¶

Value_init :: proc "odin" (self: ^Value) -> ^Value {…}

Value_initWithBytes ¶

Value_initWithBytes :: proc "odin" (self: ^Value, value: rawptr, type: cstring) -> ^Value {…}

Value_initWithCoder ¶

Value_initWithCoder :: proc "odin" (self: ^Value, coder: ^Coder) -> ^Value {…}

Value_isEqualToValue ¶

Value_isEqualToValue :: proc "cdecl" (self, other: ^Value) -> bool {…}

Value_objCType ¶

Value_objCType :: proc "cdecl" (self: ^Value) -> cstring {…}

Value_pointerValue ¶

Value_pointerValue :: proc "cdecl" (self: ^Value) -> rawptr {…}

Value_valueWithBytes ¶

Value_valueWithBytes :: proc "odin" (value: rawptr, type: cstring) -> ^Value {…}

Value_valueWithPointer ¶

Value_valueWithPointer :: proc "odin" (pointer: rawptr) -> ^Value {…}

View_initWithFrame ¶

View_initWithFrame :: proc "odin" (self: ^View, frame: Rect) -> ^View {…}

View_layer ¶

View_layer :: proc "odin" (self: ^View) -> ^Layer {…}

View_setLayer ¶

View_setLayer :: proc "odin" (self: ^View, layer: ^Layer) {…}

View_setWantsLayer ¶

View_setWantsLayer :: proc "odin" (self: ^View, wantsLayer: bool) {…}

View_wantsLayer ¶

View_wantsLayer :: proc "odin" (self: ^View) -> bool {…}

Window_alloc ¶

Window_alloc :: proc "odin" () -> ^Window {…}

Window_backgroundColor ¶

Window_backgroundColor :: proc "odin" (self: ^Window) -> ^Color {…}

Window_close ¶

Window_close :: proc "odin" (self: ^Window) {…}

Window_contentView ¶

Window_contentView :: proc "odin" (self: ^Window) -> ^View {…}

Window_frame ¶

Window_frame :: proc "odin" (self: ^Window) -> Rect {…}

Window_initWithContentRect ¶

Window_initWithContentRect :: proc "odin" (self: ^Window, contentRect: Rect, styleMask: WindowStyleMask, backing: BackingStoreType, doDefer: bool) -> ^Window {…}

Window_makeKeyAndOrderFront ¶

Window_makeKeyAndOrderFront :: proc "odin" (self: ^Window, key: ^Object) {…}

Window_opaque ¶

Window_opaque :: proc "odin" (self: ^Window) -> bool {…}

Window_setBackgroundColor ¶

Window_setBackgroundColor :: proc "odin" (self: ^Window, color: ^Color) {…}

Window_setContentView ¶

Window_setContentView :: proc "odin" (self: ^Window, content_view: ^View) {…}

Window_setFrame ¶

Window_setFrame :: proc "odin" (self: ^Window, frame: Rect) {…}

Window_setOpaque ¶

Window_setOpaque :: proc "odin" (self: ^Window, ok: bool) {…}

Window_setTitle ¶

Window_setTitle :: proc "odin" (self: ^Window, title: ^String) {…}

alloc ¶

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

autorelease ¶

autorelease :: proc "odin" (self: ^Object) {…}

bridgingCast ¶

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

class ¶

class :: proc "odin" (self: ^Object) -> ^.objc_class {…}

class_addMethod ¶

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

copy ¶

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

debugDescription ¶

debugDescription :: proc "odin" (self: ^Object) -> ^String {…}

description ¶

description :: proc "odin" (self: ^Object) -> ^String {…}

hash ¶

hash :: proc "odin" (self: ^Object) -> UInteger {…}

init ¶

init :: proc "odin" (self: ^$) -> ^$ {…}

isEqual ¶

isEqual :: proc "odin" (self, pObject: ^Object) -> bool {…}

methodSignatureForSelector ¶

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

msgSendSafeCheck ¶

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

new ¶

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

objc_allocateClassPair ¶

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

objc_lookUpClass ¶

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

release ¶

release :: proc "odin" (self: ^Object) {…}

respondsToSelector ¶

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

retainCount ¶

retainCount :: proc "odin" (self: ^Object) -> UInteger {…}

retain ¶

retain :: proc "odin" (self: ^Object) {…}

scoped_autoreleasepool ¶

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

sel_registerName ¶

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

Procedure Groups

Source Files

Generation Information

Generated with odin version dev-2022-07 (vendor "odin") Windows_amd64 @ 2022-07-01 21:08:58.808210300 +0000 UTC