Platform-specific package target: darwin_arm64

Collection Info

View Source
Collection
core
Path
sys/darwin/Foundation
Entries
1041
Constants 66
Jump to Constants
ApplicationPresentationOptionsAutoHideDock ApplicationPresentationOptionsAutoHideMenuBar ApplicationPresentationOptionsAutoHideToolbar ApplicationPresentationOptionsDefault ApplicationPresentationOptionsDisableAppleMenu ApplicationPresentationOptionsDisableCursorLocationAssistance ApplicationPresentationOptionsDisableForceQuit ApplicationPresentationOptionsDisableHideApplication ApplicationPresentationOptionsDisableMenuBarTransparency ApplicationPresentationOptionsDisableProcessSwitching ApplicationPresentationOptionsDisableSessionTermination ApplicationPresentationOptionsFullScreen ApplicationPresentationOptionsHideDock ApplicationPresentationOptionsHideMenuBar EventMaskAny EventModifierFlagCapsLock +50 more
Types 138
Jump to Types
ActivationPolicy ActivityOptions ActivityOptionsBits Application ApplicationDelegate ApplicationDelegateTemplate ApplicationPresentationOptionFlag ApplicationPresentationOptions ApplicationPrintReply ApplicationTerminateReply Array AutoreleasePool BackingStoreType BitmapFormatFlag BitmapFormatFlags BitmapImageRep +122 more
Procedures 807
Jump to Procedures
alloc alloc_user_object AllocateObject Application_activate Application_activateIgnoringOtherApps Application_active Application_currentEvent application_delegate_register_and_alloc Application_finishLaunching Application_isRunning Application_keyWindow Application_mainMenu Application_mainWindow Application_nextEventMatchingMask Application_postEvent Application_run +791 more
Procedure Groups 8
Jump to Procedure Groups
BitmapImageRep_initWithBitmapDataPlanes Menu_cancelPreviousPerformRequestsWithTarget Menu_paletteMenuWithColors Menu_popUpContextMenu MenuDelegate_menu MenuItem_cancelPreviousPerformRequestsWithTarget NotificationCenter_addObserverForName Number_number
Variables 22
Jump to Variables
CocoaErrorDomain DebugDescriptionErrorKey DefaultRunLoopMode DeviceRGBColorSpace EventTrackingRunLoopMode FilePathErrorKey HelpAnchorErrorKey KeyEventModifierFlagDeviceIndependentFlagsMask LocalizedDescriptionKey LocalizedFailureErrorKey LocalizedFailureReasonErrorKey LocalizedRecoveryOptionsErrorKey LocalizedRecoverySuggestionErrorKey MachErrorDomain ModalPanelRunLoopMode OSStatusErrorDomain +6 more

Source Files

Constants

66

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}

EventMaskAny #

Source 
EventMaskAny :: transmute(EventMask)(max(UInteger))

EventModifierFlagCapsLock #

Source 
EventModifierFlagCapsLock :: EventModifierFlags{.CapsLock}

EventModifierFlagCommand #

Source 
EventModifierFlagCommand :: EventModifierFlags{.Command}

EventModifierFlagControl #

Source 
EventModifierFlagControl :: EventModifierFlags{.Control}

EventModifierFlagDeviceIndependentFlagsMask #

Source 
EventModifierFlagDeviceIndependentFlagsMask :: 0xffff0000

EventModifierFlagFunction #

Source 
EventModifierFlagFunction :: EventModifierFlags{.Function}

EventModifierFlagHelp #

Source 
EventModifierFlagHelp :: EventModifierFlags{.Help}

EventModifierFlagNumericPad #

Source 
EventModifierFlagNumericPad :: EventModifierFlags{.NumericPad}

EventModifierFlagOption #

Source 
EventModifierFlagOption :: EventModifierFlags{.Option}

EventModifierFlagShift #

Source 
EventModifierFlagShift :: EventModifierFlags{.Shift}

EventPhaseCancelled #

Source 
EventPhaseCancelled :: EventPhase{.Cancelled}

EventPhaseMayBegin #

Source 
EventPhaseMayBegin :: EventPhase{.MayBegin}

EventPhaseStationary #

Source 
EventPhaseStationary :: EventPhase{.Stationary}

WindowCollectionBehaviorAuxiliary #

Source 
WindowCollectionBehaviorAuxiliary :: WindowCollectionBehavior{.Auxiliary, .FullScreenNone}

WindowCollectionBehaviorCanJoinAllApplications #

Source 
WindowCollectionBehaviorCanJoinAllApplications :: WindowCollectionBehavior{.CanJoinAllApplications}

WindowCollectionBehaviorCanJoinAllSpaces #

Source 
WindowCollectionBehaviorCanJoinAllSpaces :: WindowCollectionBehavior{.CanJoinAllSpaces}

WindowCollectionBehaviorDefault #

Source 
WindowCollectionBehaviorDefault :: WindowCollectionBehavior{}

WindowCollectionBehaviorFullScreenAllowsTiling #

Source 
WindowCollectionBehaviorFullScreenAllowsTiling :: WindowCollectionBehavior{.FullScreenAllowsTiling}

WindowCollectionBehaviorFullScreenAuxiliary #

Source 
WindowCollectionBehaviorFullScreenAuxiliary :: WindowCollectionBehavior{.FullScreenAuxiliary}

WindowCollectionBehaviorFullScreenDisallowsTiling #

Source 
WindowCollectionBehaviorFullScreenDisallowsTiling :: WindowCollectionBehavior{.FullScreenDisallowsTiling}

WindowCollectionBehaviorFullScreenNone #

Source 
WindowCollectionBehaviorFullScreenNone :: WindowCollectionBehavior{.FullScreenNone}

WindowCollectionBehaviorFullScreenPrimary #

Source 
WindowCollectionBehaviorFullScreenPrimary :: WindowCollectionBehavior{.FullScreenPrimary}

WindowCollectionBehaviorIgnoresCycle #

Source 
WindowCollectionBehaviorIgnoresCycle :: WindowCollectionBehavior{.IgnoresCycle}

WindowCollectionBehaviorManaged #

Source 
WindowCollectionBehaviorManaged :: WindowCollectionBehavior{.Managed}

WindowCollectionBehaviorMoveToActiveSpace #

Source 
WindowCollectionBehaviorMoveToActiveSpace :: WindowCollectionBehavior{.MoveToActiveSpace}

WindowCollectionBehaviorParticipatesInCycle #

Source 
WindowCollectionBehaviorParticipatesInCycle :: WindowCollectionBehavior{.ParticipatesInCycle}

WindowCollectionBehaviorPrimary #

Source 
WindowCollectionBehaviorPrimary :: WindowCollectionBehavior{.Primary, .FullScreenAuxiliary}

WindowCollectionBehaviorStationary #

Source 
WindowCollectionBehaviorStationary :: WindowCollectionBehavior{.Stationary}

WindowCollectionBehaviorTransient #

Source 
WindowCollectionBehaviorTransient :: WindowCollectionBehavior{.Transient}

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}

Types

138

PointingDeviceType #

Source 
PointingDeviceType :: PointingDeviceType

pointer types for NSTabletProximity events or mouse events with subtype NSTabletProximityEventSubtype

Procedures

807

alloc_user_object #

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

Application_activate #

Source 
@(objc_type=Application)
@(objc_name="activate")
Application_activate :: proc "c" (self: ^Application) {…}

Application_activateIgnoringOtherApps #

Source 
@(objc_type=Application)
@(objc_name="activateIgnoringOtherApps")
Application_activateIgnoringOtherApps :: proc "c" (self: ^Application, ignoreOtherApps: bool) {…}

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

Application_currentEvent #

Source 
@(objc_type=Application)
@(objc_name="currentEvent")
Application_currentEvent :: proc "c" (self: ^Application) -> ^Event {…}

Application_finishLaunching #

Source 
@(objc_type=Application)
@(objc_name="finishLaunching")
Application_finishLaunching :: proc "c" (self: ^Application) {…}

Application_isRunning #

Source 
@(objc_type=Application)
@(objc_name="isRunning")
Application_isRunning :: proc "c" (self: ^Application) -> bool {…}

Application_mainMenu #

Source 
@(objc_type=Application)
@(objc_name="mainMenu")
Application_mainMenu :: proc "c" (self: ^Application) -> ^Menu {…}

Application_mainWindow #

Source 
@(objc_type=Application)
@(objc_name="mainWindow")
Application_mainWindow :: proc "c" (self: ^Application) -> ^Window {…}

Application_postEvent #

Source 
@(objc_type=Application)
@(objc_name="postEvent")
Application_postEvent :: proc "c" (self: ^Application, event: ^Event, atStart: bool) {…}

Application_sendAction #

Source 
@(objc_type=Application)
@(objc_name="sendAction")
Application_sendAction :: proc "c" (self: ^Application, action: ^objc_selector, to: ^objc_object, from: ^objc_object) {…}

Application_sendEvent #

Source 
@(objc_type=Application)
@(objc_name="sendEvent")
Application_sendEvent :: proc "c" (self: ^Application, event: ^Event) {…}

Application_servicesMenu #

Source 
@(objc_type=Application)
@(objc_name="servicesMenu")
Application_servicesMenu :: proc "c" (self: ^Application) -> ^Menu {…}

Application_setAppleMenu #

Source 
@(objc_type=Application)
@(objc_name="setAppleMenu")
Application_setAppleMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}

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

Application_setMainMenu #

Source 
@(objc_type=Application)
@(objc_name="setMainMenu")
Application_setMainMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}

Application_setServicesMenu #

Source 
@(objc_type=Application)
@(objc_name="setServicesMenu")
Application_setServicesMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}

Application_setTitle #

Source 
@(objc_type=Application)
@(objc_name="setTitle")
Application_setTitle :: proc "c" (self: ^Application, title: ^String) {…}

Application_setWindowsMenu #

Source 
@(objc_type=Application)
@(objc_name="setWindowsMenu")
Application_setWindowsMenu :: proc "c" (self: ^Application, menu: ^Menu) {…}

Application_sharedApplication #

Source 
@(objc_type=Application)
@(objc_name="sharedApplication")
@(objc_is_class_method=true)
Application_sharedApplication :: proc "c" () -> ^Application {…}

Application_terminate #

Source 
@(objc_type=Application)
@(objc_name="terminate")
Application_terminate :: proc "c" (self: ^Application, sender: ^Object) {…}

Application_updateWindows #

Source 
@(objc_type=Application)
@(objc_name="updateWindows")
Application_updateWindows :: proc "c" (self: ^Application) {…}

Application_windowsMenu #

Source 
@(objc_type=Application)
@(objc_name="windowsMenu")
Application_windowsMenu :: proc "c" (self: ^Application) -> ^Menu {…}

Array_alloc #

Source 
@(objc_type=Array)
@(objc_name="alloc")
@(objc_is_class_method=true)
Array_alloc :: proc "c" () -> ^Array {…}

Array_initWithCoder #

Source 
@(objc_type=Array)
@(objc_name="initWithCoder")
Array_initWithCoder :: proc "c" (self: ^Array, coder: ^Coder) -> ^Array {…}

AT #

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

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

autorelease #

Source 
@(objc_type=Object)
@(objc_name="autorelease")
autorelease :: proc "c" (self: ^Object) {…}

AutoreleasePool_alloc #

Source 
@(objc_type=AutoreleasePool)
@(objc_name="alloc")
@(objc_is_class_method=true)
AutoreleasePool_alloc :: proc "c" () -> ^AutoreleasePool {…}

AutoreleasePool_drain #

Source 
@(objc_type=AutoreleasePool)
@(objc_name="drain")
AutoreleasePool_drain :: proc "c" (self: ^AutoreleasePool) {…}

BitmapImageRep_alloc #

Source 
@(objc_type=BitmapImageRep)
@(objc_name="alloc")
@(objc_is_class_method=true)
BitmapImageRep_alloc :: proc "c" () -> ^BitmapImageRep {…}

Block_createGlobal #

Source 
@(objc_type=Block)
@(objc_name="createGlobal")
@(objc_is_class_method=true)
Block_createGlobal :: proc(user_data: rawptr, user_proc: proc "c" (user_data: rawptr), allocator := context.allocator) -> (^Block, Allocator_Error) #optional_ok {…}

Block_createGlobalWithParam #

Source 
@(objc_type=Block)
@(objc_name="createGlobalWithParam")
@(objc_is_class_method=true)
Block_createGlobalWithParam :: proc(user_data: rawptr, user_proc: proc "c" (user_data: rawptr, t: $T), allocator := context.allocator) -> (^Block, Allocator_Error) #optional_ok {…}

Block_createLocal #

Source 
@(objc_type=Block)
@(objc_name="createLocal")
@(objc_is_class_method=true)
Block_createLocal :: proc(user_data: rawptr, user_proc: proc "c" (user_data: rawptr)) -> ^Block {…}

Block_createLocalWithParam #

Source 
@(objc_type=Block)
@(objc_name="createLocalWithParam")
@(objc_is_class_method=true)
Block_createLocalWithParam :: proc(user_data: rawptr, user_proc: proc "c" (user_data: rawptr, t: $T)) -> ^Block {…}

Bundle_allBundles #

Source 
@(objc_type=Bundle)
@(objc_name="allBundles")
Bundle_allBundles :: proc "c" () -> (all: ^Array) {…}

Bundle_allFrameworks #

Source 
@(objc_type=Bundle)
@(objc_name="allFrameworks")
Bundle_allFrameworks :: proc "c" () -> (all: ^Array) {…}

Bundle_alloc #

Source 
@(objc_type=Bundle)
@(objc_name="alloc")
@(objc_is_class_method=true)
Bundle_alloc :: proc "c" () -> ^Bundle {…}

Bundle_appStoreReceiptPath #

Source 
@(objc_type=Bundle)
@(objc_name="appStoreReceiptPath")
Bundle_appStoreReceiptPath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_appStoreReceiptURL #

Source 
@(objc_type=Bundle)
@(objc_name="appStoreReceiptURL")
Bundle_appStoreReceiptURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_builtInPlugInsPath #

Source 
@(objc_type=Bundle)
@(objc_name="builtInPlugInsPath")
Bundle_builtInPlugInsPath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_builtInPlugInsURL #

Source 
@(objc_type=Bundle)
@(objc_name="builtInPlugInsURL")
Bundle_builtInPlugInsURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_bundleIdentifier #

Source 
@(objc_type=Bundle)
@(objc_name="bundleIdentifier")
Bundle_bundleIdentifier :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_bundlePath #

Source 
@(objc_type=Bundle)
@(objc_name="bundlePath")
Bundle_bundlePath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_bundleURL #

Source 
@(objc_type=Bundle)
@(objc_name="bundleURL")
Bundle_bundleURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_bundleWithPath #

Source 
@(objc_type=Bundle)
@(objc_name="bundleWithPath")
@(objc_is_class_method=true)
Bundle_bundleWithPath :: proc "c" (path: ^String) -> ^Bundle {…}

Bundle_bundleWithURL #

Source 
@(objc_type=Bundle)
@(objc_name="bundleWithURL")
@(objc_is_class_method=true)
Bundle_bundleWithURL :: proc "c" (url: ^URL) -> ^Bundle {…}

Bundle_executablePath #

Source 
@(objc_type=Bundle)
@(objc_name="executablePath")
Bundle_executablePath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_executableURL #

Source 
@(objc_type=Bundle)
@(objc_name="executableURL")
Bundle_executableURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_infoDictionary #

Source 
@(objc_type=Bundle)
@(objc_name="infoDictionary")
Bundle_infoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {…}

Bundle_initWithURL #

Source 
@(objc_type=Bundle)
@(objc_name="initWithURL")
Bundle_initWithURL :: proc "c" (self: ^Bundle, url: ^URL) -> ^Bundle {…}

Bundle_isLoaded #

Source 
@(objc_type=Bundle)
@(objc_name="isLoaded")
Bundle_isLoaded :: proc "c" (self: ^Bundle) -> bool {…}

Bundle_loadAndReturnError #

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

Bundle_localizedInfoDictionary #

Source 
@(objc_type=Bundle)
@(objc_name="localizedInfoDictionary")
Bundle_localizedInfoDictionary :: proc "c" (self: ^Bundle) -> ^Dictionary {…}

Bundle_localizedStringForKey #

Source 
@(objc_type=Bundle)
@(objc_name="localizedStringForKey")
Bundle_localizedStringForKey :: proc "c" (self: ^Bundle, key: ^String, value: ^String = nil, tableName: ^String = nil) -> ^String {…}

Bundle_mainBundle #

Source 
@(objc_type=Bundle)
@(objc_name="mainBundle")
@(objc_is_class_method=true)
Bundle_mainBundle :: proc "c" () -> ^Bundle {…}

Bundle_objectForInfoDictionaryKey #

Source 
@(objc_type=Bundle)
@(objc_name="objectForInfoDictionaryKey")
Bundle_objectForInfoDictionaryKey :: proc "c" (self: ^Bundle, key: ^String) -> ^Object {…}

Bundle_PathForAuxiliaryExecutable #

Source 
@(objc_type=Bundle)
@(objc_name="PathForAuxiliaryExecutable")
Bundle_PathForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^String {…}

Bundle_preflightAndReturnError #

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

Bundle_privateFrameworksPath #

Source 
@(objc_type=Bundle)
@(objc_name="privateFrameworksPath")
Bundle_privateFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_privateFrameworksURL #

Source 
@(objc_type=Bundle)
@(objc_name="privateFrameworksURL")
Bundle_privateFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_resourcePath #

Source 
@(objc_type=Bundle)
@(objc_name="resourcePath")
Bundle_resourcePath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_resourceURL #

Source 
@(objc_type=Bundle)
@(objc_name="resourceURL")
Bundle_resourceURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_sharedFrameworksPath #

Source 
@(objc_type=Bundle)
@(objc_name="sharedFrameworksPath")
Bundle_sharedFrameworksPath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_sharedFrameworksURL #

Source 
@(objc_type=Bundle)
@(objc_name="sharedFrameworksURL")
Bundle_sharedFrameworksURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_sharedSupportPath #

Source 
@(objc_type=Bundle)
@(objc_name="sharedSupportPath")
Bundle_sharedSupportPath :: proc "c" (self: ^Bundle) -> ^String {…}

Bundle_sharedSupportURL #

Source 
@(objc_type=Bundle)
@(objc_name="sharedSupportURL")
Bundle_sharedSupportURL :: proc "c" (self: ^Bundle) -> ^URL {…}

Bundle_unload #

Source 
@(objc_type=Bundle)
@(objc_name="unload")
Bundle_unload :: proc "c" (self: ^Bundle) -> bool {…}

Bundle_URLForAuxiliaryExecutable #

Source 
@(objc_type=Bundle)
@(objc_name="URLForAuxiliaryExecutable")
Bundle_URLForAuxiliaryExecutable :: proc "c" (self: ^Bundle, executableName: ^String) -> ^URL {…}

class #

Source 
@(objc_type=Object)
@(objc_name="class")
class :: proc "c" (self: ^Object) -> ^objc_class {…}

class_createInstance #

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

class_get_metaclass #

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

class_getInstanceMethod #

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

class_getInstanceSize #

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

class_getMethodImplementation #

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

class_getSuperclass #

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

class_getVersion #

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

class_replaceMethod #

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

class_respondsToSelector #

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

class_setVersion #

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

Color_blackColor #

Source 
@(objc_type=Color)
@(objc_name="blackColor")
@(objc_is_class_method=true)
Color_blackColor :: proc "c" () -> ^Color {…}

Color_blueColor #

Source 
@(objc_type=Color)
@(objc_name="blueColor")
@(objc_is_class_method=true)
Color_blueColor :: proc "c" () -> ^Color {…}

Color_colorSpaceName #

Source 
@(objc_type=Color)
@(objc_name="colorSpaceName")
Color_colorSpaceName :: proc "c" (self: ^Color) -> ^String {…}

Color_colorUsingColorSpaceName #

Source 
@(objc_type=Color)
@(objc_name="colorUsingColorSpaceName")
Color_colorUsingColorSpaceName :: proc "c" (self: ^Color, colorSpace: ^String, device: ^Dictionary = nil) -> ^Color {…}

Color_colorWithCalibratedHue #

Source 
@(objc_type=Color)
@(objc_name="colorWithCalibratedHue")
@(objc_is_class_method=true)
Color_colorWithCalibratedHue :: proc "c" (hue, saturation, brightness, alpha: CGFloat) -> ^Color {…}

Color_colorWithCalibratedRed #

Source 
@(objc_type=Color)
@(objc_name="colorWithCalibratedRed")
@(objc_is_class_method=true)
Color_colorWithCalibratedRed :: proc "c" (red, green, blue, alpha: CGFloat) -> ^Color {…}

Color_colorWithCalibratedWhite #

Source 
@(objc_type=Color)
@(objc_name="colorWithCalibratedWhite")
@(objc_is_class_method=true)
Color_colorWithCalibratedWhite :: proc "c" (white, alpha: CGFloat) -> ^Color {…}

Color_colorWithColorSpace #

Source 
@(objc_type=Color)
@(objc_name="colorWithColorSpace")
@(objc_is_class_method=true)
Color_colorWithColorSpace :: proc "c" (space: ^ColorSpace, components: []CGFloat) -> ^Color {…}

Color_colorWithDeviceCyan #

Source 
@(objc_type=Color)
@(objc_name="colorWithDeviceCyan")
@(objc_is_class_method=true)
Color_colorWithDeviceCyan :: proc "c" (cyan, magenta, yellow, black, alpha: CGFloat) -> ^Color {…}

Color_colorWithDeviceHue #

Source 
@(objc_type=Color)
@(objc_name="colorWithDeviceHue")
@(objc_is_class_method=true)
Color_colorWithDeviceHue :: proc "c" (hue, saturation, brightness, alpha: CGFloat) -> ^Color {…}

Color_colorWithDeviceRed #

Source 
@(objc_type=Color)
@(objc_name="colorWithDeviceRed")
@(objc_is_class_method=true)
Color_colorWithDeviceRed :: proc "c" (red, green, blue, alpha: CGFloat) -> ^Color {…}

Color_colorWithDeviceWhite #

Source 
@(objc_type=Color)
@(objc_name="colorWithDeviceWhite")
@(objc_is_class_method=true)
Color_colorWithDeviceWhite :: proc "c" (white, alpha: CGFloat) -> ^Color {…}

Color_colorWithSRGBRed #

Source 
@(objc_type=Color)
@(objc_name="colorWithSRGBRed")
@(objc_is_class_method=true)
Color_colorWithSRGBRed :: proc "c" (red, green, blue, alpha: CGFloat) -> ^Color {…}

Color_cyanColor #

Source 
@(objc_type=Color)
@(objc_name="cyanColor")
@(objc_is_class_method=true)
Color_cyanColor :: proc "c" () -> ^Color {…}

Color_getCMYKA #

Source 
@(objc_type=Color)
@(objc_name="getCMYKA")
Color_getCMYKA :: proc "c" (self: ^Color) -> (cyan, magenta, yellow, black, alpha: CGFloat) {…}

Color_getComponents #

Source 
@(objc_type=Color)
@(objc_name="getComponents")
Color_getComponents :: proc "c" (self: ^Color, components: [^]CGFloat) {…}

Color_getHSBA #

Source 
@(objc_type=Color)
@(objc_name="getHSBA")
Color_getHSBA :: proc "c" (self: ^Color) -> (hue, saturation, brightness, alpha: CGFloat) {…}

Color_getRGBA #

Source 
@(objc_type=Color)
@(objc_name="getRGBA")
Color_getRGBA :: proc "c" (self: ^Color) -> (red, green, blue, alpha: CGFloat) {…}

Color_getWhiteAlpha #

Source 
@(objc_type=Color)
@(objc_name="getWhiteAlpha")
Color_getWhiteAlpha :: proc "c" (self: ^Color) -> (white, alpha: CGFloat) {…}

Color_greenColor #

Source 
@(objc_type=Color)
@(objc_name="greenColor")
@(objc_is_class_method=true)
Color_greenColor :: proc "c" () -> ^Color {…}

Color_magentaColor #

Source 
@(objc_type=Color)
@(objc_name="magentaColor")
@(objc_is_class_method=true)
Color_magentaColor :: proc "c" () -> ^Color {…}

Color_numberOfComponents #

Source 
@(objc_type=Color)
@(objc_name="numberOfComponents")
Color_numberOfComponents :: proc "c" (self: ^Color) -> Integer {…}

Color_orangeColor #

Source 
@(objc_type=Color)
@(objc_name="orangeColor")
@(objc_is_class_method=true)
Color_orangeColor :: proc "c" () -> ^Color {…}

Color_purpleColor #

Source 
@(objc_type=Color)
@(objc_name="purpleColor")
@(objc_is_class_method=true)
Color_purpleColor :: proc "c" () -> ^Color {…}

Color_redColor #

Source 
@(objc_type=Color)
@(objc_name="redColor")
@(objc_is_class_method=true)
Color_redColor :: proc "c" () -> ^Color {…}

Color_whiteColor #

Source 
@(objc_type=Color)
@(objc_name="whiteColor")
@(objc_is_class_method=true)
Color_whiteColor :: proc "c" () -> ^Color {…}

Color_yellowColor #

Source 
@(objc_type=Color)
@(objc_name="yellowColor")
@(objc_is_class_method=true)
Color_yellowColor :: proc "c" () -> ^Color {…}

Condition_alloc #

Source 
@(objc_type=Condition)
@(objc_name="alloc")
@(objc_is_class_method=true)
Condition_alloc :: proc "c" () -> ^Condition {…}

Condition_broadcast #

Source 
@(objc_type=Condition)
@(objc_name="broadcast")
Condition_broadcast :: proc "c" (self: ^Condition) {…}

Condition_lock #

Source 
@(objc_type=Condition)
@(objc_name="lock")
Condition_lock :: proc "c" (self: ^Condition) {…}

Condition_signal #

Source 
@(objc_type=Condition)
@(objc_name="signal")
Condition_signal :: proc "c" (self: ^Condition) {…}

Condition_unlock #

Source 
@(objc_type=Condition)
@(objc_name="unlock")
Condition_unlock :: proc "c" (self: ^Condition) {…}

Condition_wait #

Source 
@(objc_type=Condition)
@(objc_name="wait")
Condition_wait :: proc "c" (self: ^Condition) {…}

Condition_waitUntilDate #

Source 
@(objc_type=Condition)
@(objc_name="waitUntilDate")
Condition_waitUntilDate :: proc "c" (self: ^Condition, limit: ^Date) -> bool {…}

copy #

Source 
@(objc_type=Object)
@(objc_name="copy")
copy :: proc "c" (self: ^Copying($T)) -> $$deferred_return {…}

Cursor_alloc #

Source 
@(objc_type=Cursor)
@(objc_name="alloc")
@(objc_is_class_method=true)
Cursor_alloc :: proc "c" () -> ^Cursor {…}

Cursor_arrowCursor #

Source 
@(objc_type=Cursor)
@(objc_name="arrowCursor")
@(objc_is_class_method=true)
Cursor_arrowCursor :: proc "c" () -> ^Cursor {…}

Cursor_currentCursor #

Source 
@(objc_type=Cursor)
@(objc_name="currentCursor")
@(objc_is_class_method=true)
Cursor_currentCursor :: proc "c" () -> ^Cursor {…}

Cursor_hide #

Source 
@(objc_type=Cursor)
@(objc_name="hide")
@(objc_is_class_method=true)
Cursor_hide :: proc() {…}

Cursor_IBeamCursor #

Source 
@(objc_type=Cursor)
@(objc_name="IBeamCursor")
@(objc_is_class_method=true)
Cursor_IBeamCursor :: proc "c" () -> ^Cursor {…}

Cursor_pointingHandCursor #

Source 
@(objc_type=Cursor)
@(objc_name="pointingHandCursor")
@(objc_is_class_method=true)
Cursor_pointingHandCursor :: proc "c" () -> ^Cursor {…}

Cursor_setHiddenUntilMouseMoves #

Source 
@(objc_type=Cursor)
@(objc_name="setHiddenUntilMouseMoves")
@(objc_is_class_method=true)
Cursor_setHiddenUntilMouseMoves :: proc(flag: bool) {…}

Cursor_unhide #

Source 
@(objc_type=Cursor)
@(objc_name="unhide")
@(objc_is_class_method=true)
Cursor_unhide :: proc() {…}

Data_alloc #

Source 
@(objc_type=Data)
@(objc_name="alloc")
@(objc_is_class_method=true)
Data_alloc :: proc "c" () -> ^Data {…}

Data_initWithBytes #

Source 
@(objc_type=Data)
@(objc_name="initWithBytes")
Data_initWithBytes :: proc "c" (self: ^Data, bytes: []u8) -> ^Data {…}

Data_initWithBytesNoCopy #

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

Data_mutableBytes #

Source 
@(objc_type=Data)
@(objc_name="mutableBytes")
Data_mutableBytes :: proc "c" (self: ^Data) -> rawptr {…}

Date_alloc #

Source 
@(objc_type=Date)
@(objc_name="alloc")
@(objc_is_class_method=true)
Date_alloc :: proc "c" () -> ^Date {…}

Date_dateWithTimeIntervalSinceNow #

Source 
@(objc_type=Date)
@(objc_name="dateWithTimeIntervalSinceNow")
Date_dateWithTimeIntervalSinceNow :: proc "c" (secs: TimeInterval) -> ^Date {…}

Date_distantFuture #

Source 
@(objc_type=Date)
@(objc_name="distantFuture")
@(objc_is_class_method=true)
Date_distantFuture :: proc "c" () -> ^Date {…}

Date_distantPast #

Source 
@(objc_type=Date)
@(objc_name="distantPast")
@(objc_is_class_method=true)
Date_distantPast :: proc "c" () -> ^Date {…}

Date_timeIntervalSince1970 #

Source 
@(objc_type=Date)
@(objc_name="timeIntervalSince1970")
Date_timeIntervalSince1970 :: proc "c" (self: ^Date) -> f64 {…}

DeallocateObject #

Source 
DeallocateObject :: proc "c" (object: ^objc_object) ---

debugDescription #

Source 
@(objc_type=Object)
@(objc_name="debugDescription")
debugDescription :: proc "c" (self: ^Object) -> ^String {…}

Dictionary_alloc #

Source 
@(objc_type=Dictionary)
@(objc_name="alloc")
@(objc_is_class_method=true)
Dictionary_alloc :: proc "c" () -> ^Dictionary {…}

Dictionary_dictionary #

Source 
@(objc_type=Dictionary)
@(objc_name="dictionary")
@(objc_is_class_method=true)
Dictionary_dictionary :: proc "c" () -> ^Dictionary {…}

Dictionary_dictionaryWithObject #

Source 
@(objc_type=Dictionary)
@(objc_name="dictionaryWithObject")
@(objc_is_class_method=true)
Dictionary_dictionaryWithObject :: proc "c" (object: ^Object, forKey: ^Object) -> ^Dictionary {…}

Dictionary_dictionaryWithObjects #

Source 
@(objc_type=Dictionary)
@(objc_name="dictionaryWithObjects")
@(objc_is_class_method=true)
Dictionary_dictionaryWithObjects :: proc "c" (objects: [^]^Object, forKeys: [^]^Object, count: UInteger) -> ^Dictionary {…}

Dictionary_keyEnumerator #

Source 
@(objc_type=Dictionary)
@(objc_name="keyEnumerator")
Dictionary_keyEnumerator :: proc "c" (self: ^Dictionary, $KeyType: typeid) -> (enumerator: ^Enumerator($T=typeid)) {…}

Enumerator_iterator #

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

Error_alloc #

Source 
@(objc_type=Error)
@(objc_name="alloc")
@(objc_is_class_method=true)
Error_alloc :: proc "c" () -> ^Error {…}

Error_errorWithDomain #

Source 
@(objc_type=Error)
@(objc_name="errorWithDomain")
@(objc_is_class_method=true)
Error_errorWithDomain :: proc "c" (domain: ^String, code: Integer, userInfo: ^Dictionary) -> ^Error {…}

Error_localizedDescription #

Source 
@(objc_type=Error)
@(objc_name="localizedDescription")
Error_localizedDescription :: proc "c" (self: ^Error) -> ^String {…}

Error_localizedFailureReason #

Source 
@(objc_type=Error)
@(objc_name="localizedFailureReason")
Error_localizedFailureReason :: proc "c" (self: ^Error) -> ^String {…}

Error_localizedRecoveryOptions #

Source 
@(objc_type=Error)
@(objc_name="localizedRecoveryOptions")
Error_localizedRecoveryOptions :: proc "c" (self: ^Error) -> (options: ^Array) {…}

Error_localizedRecoverySuggestion #

Source 
@(objc_type=Error)
@(objc_name="localizedRecoverySuggestion")
Error_localizedRecoverySuggestion :: proc "c" (self: ^Error) -> ^String {…}

Event_absolute #

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

Event_buttonNumber #

Source 
@(objc_type=Event)
@(objc_name="buttonNumber")
Event_buttonNumber :: proc "c" (self: ^Event) -> Integer {…}

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

Event_capabilityMask #

Source 
@(objc_type=Event)
@(objc_name="capabilityMask")
Event_capabilityMask :: proc "c" (self: ^Event) -> UInteger {…}

Event_characters #

Source 
@(objc_type=Event)
@(objc_name="characters")
Event_characters :: proc "c" (self: ^Event) -> ^String {…}

Event_charactersIgnoringModifiers #

Source 
@(objc_type=Event)
@(objc_name="charactersIgnoringModifiers")
Event_charactersIgnoringModifiers :: proc "c" (self: ^Event) -> ^String {…}

Event_clickCount #

Source 
@(objc_type=Event)
@(objc_name="clickCount")
Event_clickCount :: proc "c" (self: ^Event) -> Integer {…}

Event_eventNumber #

Source 
@(objc_type=Event)
@(objc_name="eventNumber")
Event_eventNumber :: proc "c" (self: ^Event) -> Integer {…}

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

Event_hasPreciseScrollingDeltas #

Source 
@(objc_type=Event)
@(objc_name="hasPreciseScrollingDeltas")
Event_hasPreciseScrollingDeltas :: proc "c" (self: ^Event) -> bool {…}

Event_isARepeat #

Source 
@(objc_type=Event)
@(objc_name="isARepeat")
Event_isARepeat :: proc "c" (self: ^Event) -> bool {…}

Event_isDirectionInvertedFromDevice #

Source 
@(objc_type=Event)
@(objc_name="isDirectionInvertedFromDevice")
Event_isDirectionInvertedFromDevice :: proc "c" (self: ^Event) -> bool {…}

Event_isEnteringProximity #

Source 
@(objc_type=Event)
@(objc_name="isEnteringProximity")
Event_isEnteringProximity :: proc "c" (self: ^Event) -> bool {…}

Event_isSwipeTrackingFromScrollEventsEnabled #

Source 
@(objc_type=Event)
@(objc_name="isSwipeTrackingFromScrollEventsEnabled")
Event_isSwipeTrackingFromScrollEventsEnabled :: proc "c" (self: ^Event) -> bool {…}

Event_keyCode #

Source 
@(objc_type=Event)
@(objc_name="keyCode")
Event_keyCode :: proc "c" (self: ^Event) -> u16 {…}

Event_locationInWindow #

Source 
@(objc_type=Event)
@(objc_name="locationInWindow")
Event_locationInWindow :: proc "c" (self: ^Event) -> CGPoint {…}

-locationInWindow is valid for all mouse-related events

Event_mouseLocation #

Source 
@(objc_type=Event)
@(objc_name="mouseLocation")
@(objc_is_class_method=true)
Event_mouseLocation :: proc "c" () -> CGPoint {…}

Event_pointingDeviceID #

Source 
@(objc_type=Event)
@(objc_name="pointingDeviceID")
Event_pointingDeviceID :: proc "c" (self: ^Event) -> UInteger {…}

Event_pointingDeviceSerialNumber #

Source 
@(objc_type=Event)
@(objc_name="pointingDeviceSerialNumber")
Event_pointingDeviceSerialNumber :: proc "c" (self: ^Event) -> UInteger {…}

Event_pressure #

Source 
@(objc_type=Event)
@(objc_name="pressure")
Event_pressure :: proc "c" (self: ^Event) -> f32 {…}

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

Event_scrollingDelta #

Source 
@(objc_type=Event)
@(objc_name="scrollingDelta")
Event_scrollingDelta :: proc "c" (self: ^Event) -> (x, y: CGFloat) {…}

Event_scrollingDeltaX #

Source 
@(objc_type=Event)
@(objc_name="scrollingDeltaX")
Event_scrollingDeltaX :: proc "c" (self: ^Event) -> CGFloat {…}

Event_scrollingDeltaY #

Source 
@(objc_type=Event)
@(objc_name="scrollingDeltaY")
Event_scrollingDeltaY :: proc "c" (self: ^Event) -> CGFloat {…}

Event_subtype #

Source 
@(objc_type=Event)
@(objc_name="subtype")
Event_subtype :: proc "c" (self: ^Event) -> i16 {…}

Event_systemTabletID #

Source 
@(objc_type=Event)
@(objc_name="systemTabletID")
Event_systemTabletID :: proc "c" (self: ^Event) -> UInteger {…}

Event_tangentialPressure #

Source 
@(objc_type=Event)
@(objc_name="tangentialPressure")
Event_tangentialPressure :: proc "c" (self: ^Event) -> f32 {…}

Event_uniqueID #

Source 
@(objc_type=Event)
@(objc_name="uniqueID")
Event_uniqueID :: proc "c" (self: ^Event) -> u64 {…}

Event_vendorDefined #

Source 
@(objc_type=Event)
@(objc_name="vendorDefined")
Event_vendorDefined :: proc "c" (self: ^Event) -> ^objc_object {…}

Event_vendorPointingDeviceType #

Source 
@(objc_type=Event)
@(objc_name="vendorPointingDeviceType")
Event_vendorPointingDeviceType :: proc "c" (self: ^Event) -> UInteger {…}

Event_windowNumber #

Source 
@(objc_type=Event)
@(objc_name="windowNumber")
Event_windowNumber :: proc "c" (self: ^Event) -> UInteger {…}

FastEnumeration_alloc #

Source 
@(objc_type=FastEnumeration)
@(objc_name="alloc")
@(objc_is_class_method=true)
FastEnumeration_alloc :: proc "c" () -> ^FastEnumeration {…}

Image_addRepresentation #

Source 
@(objc_type=Image)
@(objc_name="addRepresentation")
Image_addRepresentation :: proc(self: ^Image, rep: ^ImageRep) {…}

Image_alloc #

Source 
@(objc_type=Image)
@(objc_name="alloc")
@(objc_is_class_method=true)
Image_alloc :: proc "c" () -> ^Image {…}

Image_initWithSize #

Source 
@(objc_type=Image)
@(objc_name="initWithSize")
Image_initWithSize :: proc "c" (self: ^Image, size: CGSize) -> ^Image {…}

init #

Source 
@(objc_type=Object)
@(objc_name="init")
init :: proc "c" (self: ^$T) -> $$deferred_return {…}

Layer_addSublayer #

Source 
@(objc_type=Layer)
@(objc_name="addSublayer")
Layer_addSublayer :: proc "c" (self: ^Layer, layer: ^Layer) {…}

Layer_contents #

Source 
@(objc_type=Layer)
@(objc_name="contents")
Layer_contents :: proc "c" (self: ^Layer) -> rawptr {…}

Layer_contentsScale #

Source 
@(objc_type=Layer)
@(objc_name="contentsScale")
Layer_contentsScale :: proc "c" (self: ^Layer) -> CGFloat {…}

Layer_setContents #

Source 
@(objc_type=Layer)
@(objc_name="setContents")
Layer_setContents :: proc "c" (self: ^Layer, contents: rawptr) {…}

Layer_setContentsScale #

Source 
@(objc_type=Layer)
@(objc_name="setContentsScale")
Layer_setContentsScale :: proc "c" (self: ^Layer, scale: CGFloat) {…}

Layer_setPosition #

Source 
@(objc_type=Layer)
@(objc_name="setPosition")
Layer_setPosition :: proc "c" (self: ^Layer, position: CGPoint) {…}

MakeConstantString #

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

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

Menu_accessInstanceVariablesDirectly #

Source 
@(objc_type=Menu)
@(objc_name="accessInstanceVariablesDirectly")
@(objc_is_class_method=true)
Menu_accessInstanceVariablesDirectly :: proc "c" () -> bool {…}

Menu_addItemWithTitle #

Source 
@(objc_type=Menu)
@(objc_name="addItemWithTitle")
Menu_addItemWithTitle :: proc "c" (self: ^Menu, string: ^String, selector: ^objc_selector, charCode: ^String) -> ^MenuItem {…}

Menu_alloc #

Source 
@(objc_type=Menu)
@(objc_name="alloc")
@(objc_is_class_method=true)
Menu_alloc :: proc "c" () -> ^Menu {…}

Menu_allocWithZone #

Source 
@(objc_type=Menu)
@(objc_name="allocWithZone")
@(objc_is_class_method=true)
Menu_allocWithZone :: proc "c" (zone: ^Zone) -> ^Menu {…}

Menu_allowsContextMenuPlugIns #

Source 
@(objc_type=Menu)
@(objc_name="allowsContextMenuPlugIns")
Menu_allowsContextMenuPlugIns :: proc "c" (self: ^Menu) -> bool {…}

Menu_font :: #force_inline proc "c" (self: ^Menu) -> ^Font { return msgSend(^Font, self, "font") } Menu_setFont :: #force_inline proc "c" (self: ^Menu, font: ^Font) { msgSend(nil, self, "setFont:", font) }

Menu_attachedMenu #

Source 
@(objc_type=Menu)
@(objc_name="attachedMenu")
Menu_attachedMenu :: proc "c" (self: ^Menu) -> ^Menu {…}

Menu_autoenablesItems #

Source 
@(objc_type=Menu)
@(objc_name="autoenablesItems")
Menu_autoenablesItems :: proc "c" (self: ^Menu) -> bool {…}

Menu_automaticallyNotifiesObserversForKey #

Source 
@(objc_type=Menu)
@(objc_name="automaticallyNotifiesObserversForKey")
@(objc_is_class_method=true)
Menu_automaticallyNotifiesObserversForKey :: proc "c" (key: ^String) -> bool {…}

Menu_cancelPreviousPerformRequestsWithTarget_ #

Source 
@(objc_type=Menu)
@(objc_name="cancelPreviousPerformRequestsWithTarget_")
@(objc_is_class_method=true)
Menu_cancelPreviousPerformRequestsWithTarget_ :: proc "c" (aTarget: ^objc_object) {…}

Menu_cancelPreviousPerformRequestsWithTarget_selector_object #

Source 
@(objc_type=Menu)
@(objc_name="cancelPreviousPerformRequestsWithTarget_selector_object")
@(objc_is_class_method=true)
Menu_cancelPreviousPerformRequestsWithTarget_selector_object :: proc "c" (aTarget: ^objc_object, aSelector: ^objc_selector, anArgument: ^objc_object) {…}

Menu_cancelTracking #

Source 
@(objc_type=Menu)
@(objc_name="cancelTracking")
Menu_cancelTracking :: proc "c" (self: ^Menu) {…}

Menu_cancelTrackingWithoutAnimation #

Source 
@(objc_type=Menu)
@(objc_name="cancelTrackingWithoutAnimation")
Menu_cancelTrackingWithoutAnimation :: proc "c" (self: ^Menu) {…}

Menu_class #

Source 
@(objc_type=Menu)
@(objc_name="class")
@(objc_is_class_method=true)
Menu_class :: proc "c" () -> ^objc_class {…}

Menu_classFallbacksForKeyedArchiver #

Source 
@(objc_type=Menu)
@(objc_name="classFallbacksForKeyedArchiver")
@(objc_is_class_method=true)
Menu_classFallbacksForKeyedArchiver :: proc "c" () -> ^Array {…}

Menu_classForKeyedUnarchiver #

Source 
@(objc_type=Menu)
@(objc_name="classForKeyedUnarchiver")
@(objc_is_class_method=true)
Menu_classForKeyedUnarchiver :: proc "c" () -> ^objc_class {…}

Menu_conformsToProtocol #

Source 
@(objc_type=Menu)
@(objc_name="conformsToProtocol")
@(objc_is_class_method=true)
Menu_conformsToProtocol :: proc "c" (protocol: ^Protocol) -> bool {…}

Menu_contextMenuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="contextMenuRepresentation")
Menu_contextMenuRepresentation :: proc "c" (self: ^Menu) -> ^objc_object {…}

Menu_copyWithZone #

Source 
@(objc_type=Menu)
@(objc_name="copyWithZone")
@(objc_is_class_method=true)
Menu_copyWithZone :: proc "c" (zone: ^Zone) -> ^objc_object {…}

Menu_debugDescription #

Source 
@(objc_type=Menu)
@(objc_name="debugDescription")
@(objc_is_class_method=true)
Menu_debugDescription :: proc "c" () -> ^String {…}

Menu_defaultPlaceholderForMarker #

Source 
@(objc_type=Menu)
@(objc_name="defaultPlaceholderForMarker")
@(objc_is_class_method=true)
Menu_defaultPlaceholderForMarker :: proc "c" (marker: ^objc_object, binding: ^String) -> ^objc_object {…}

Menu_description #

Source 
@(objc_type=Menu)
@(objc_name="description")
@(objc_is_class_method=true)
Menu_description :: proc "c" () -> ^String {…}

Menu_exposeBinding #

Source 
@(objc_type=Menu)
@(objc_name="exposeBinding")
@(objc_is_class_method=true)
Menu_exposeBinding :: proc "c" (binding: ^String) {…}

Menu_hash #

Source 
@(objc_type=Menu)
@(objc_name="hash")
@(objc_is_class_method=true)
Menu_hash :: proc "c" () -> UInteger {…}

Menu_helpRequested #

Source 
@(objc_type=Menu)
@(objc_name="helpRequested")
Menu_helpRequested :: proc "c" (self: ^Menu, eventPtr: ^Event) {…}

Menu_highlightedItem #

Source 
@(objc_type=Menu)
@(objc_name="highlightedItem")
Menu_highlightedItem :: proc "c" (self: ^Menu) -> ^MenuItem {…}

Menu_indexOfItemWithRepresentedObject #

Source 
@(objc_type=Menu)
@(objc_name="indexOfItemWithRepresentedObject")
Menu_indexOfItemWithRepresentedObject :: proc "c" (self: ^Menu, object: ^objc_object) -> Integer {…}

Menu_indexOfItemWithSubmenu #

Source 
@(objc_type=Menu)
@(objc_name="indexOfItemWithSubmenu")
Menu_indexOfItemWithSubmenu :: proc "c" (self: ^Menu, submenu: ^Menu) -> Integer {…}

Menu_indexOfItemWithTag #

Source 
@(objc_type=Menu)
@(objc_name="indexOfItemWithTag")
Menu_indexOfItemWithTag :: proc "c" (self: ^Menu, tag: Integer) -> Integer {…}

Menu_indexOfItemWithTarget #

Source 
@(objc_type=Menu)
@(objc_name="indexOfItemWithTarget")
Menu_indexOfItemWithTarget :: proc "c" (self: ^Menu, target: ^objc_object, actionSelector: ^objc_selector) -> Integer {…}

Menu_indexOfItemWithTitle #

Source 
@(objc_type=Menu)
@(objc_name="indexOfItemWithTitle")
Menu_indexOfItemWithTitle :: proc "c" (self: ^Menu, title: ^String) -> Integer {…}

Menu_initialize #

Source 
@(objc_type=Menu)
@(objc_name="initialize")
@(objc_is_class_method=true)
Menu_initialize :: proc "c" () {…}

Menu_initWithCoder #

Source 
@(objc_type=Menu)
@(objc_name="initWithCoder")
Menu_initWithCoder :: proc "c" (self: ^Menu, coder: ^Coder) -> ^Menu {…}

Menu_initWithTitle #

Source 
@(objc_type=Menu)
@(objc_name="initWithTitle")
Menu_initWithTitle :: proc "c" (self: ^Menu, title: ^String) -> ^Menu {…}

Menu_insertItemWithTitle #

Source 
@(objc_type=Menu)
@(objc_name="insertItemWithTitle")
Menu_insertItemWithTitle :: proc "c" (self: ^Menu, string: ^String, selector: ^objc_selector, charCode: ^String, index: Integer) -> ^MenuItem {…}

Menu_instanceMethodForSelector #

Source 
@(objc_type=Menu)
@(objc_name="instanceMethodForSelector")
@(objc_is_class_method=true)
Menu_instanceMethodForSelector :: proc "c" (aSelector: ^objc_selector) -> IMP {…}

Menu_instancesRespondToSelector #

Source 
@(objc_type=Menu)
@(objc_name="instancesRespondToSelector")
@(objc_is_class_method=true)
Menu_instancesRespondToSelector :: proc "c" (aSelector: ^objc_selector) -> bool {…}

Menu_isAttached #

Source 
@(objc_type=Menu)
@(objc_name="isAttached")
Menu_isAttached :: proc "c" (self: ^Menu) -> bool {…}

Menu_isSubclassOfClass #

Source 
@(objc_type=Menu)
@(objc_name="isSubclassOfClass")
@(objc_is_class_method=true)
Menu_isSubclassOfClass :: proc "c" (aClass: ^objc_class) -> bool {…}

Menu_instanceMethodSignatureForSelector :: #force_inline proc "c" (aSelector: SEL) -> ^MethodSignature { return msgSend(^MethodSignature, Menu, "instanceMethodSignatureForSelector:", aSelector) }

Menu_isTornOff #

Source 
@(objc_type=Menu)
@(objc_name="isTornOff")
Menu_isTornOff :: proc "c" (self: ^Menu) -> bool {…}

Menu_itemArray #

Source 
@(objc_type=Menu)
@(objc_name="itemArray")
Menu_itemArray :: proc "c" (self: ^Menu) -> ^Array {…}

Menu_itemChanged #

Source 
@(objc_type=Menu)
@(objc_name="itemChanged")
Menu_itemChanged :: proc "c" (self: ^Menu, item: ^MenuItem) {…}

Menu_keyPathsForValuesAffectingValueForKey #

Source 
@(objc_type=Menu)
@(objc_name="keyPathsForValuesAffectingValueForKey")
@(objc_is_class_method=true)
Menu_keyPathsForValuesAffectingValueForKey :: proc "c" (key: ^String) -> ^Set {…}

Menu_load #

Source 
@(objc_type=Menu)
@(objc_name="load")
@(objc_is_class_method=true)
Menu_load :: proc "c" () {…}

Menu_locationForSubmenu #

Source 
@(objc_type=Menu)
@(objc_name="locationForSubmenu")
Menu_locationForSubmenu :: proc "c" (self: ^Menu, submenu: ^Menu) -> CGPoint {…}

Menu_menuBarHeight #

Source 
@(objc_type=Menu)
@(objc_name="menuBarHeight")
Menu_menuBarHeight :: proc "c" (self: ^Menu) -> CGFloat {…}

Menu_menuBarVisible #

Source 
@(objc_type=Menu)
@(objc_name="menuBarVisible")
@(objc_is_class_method=true)
Menu_menuBarVisible :: proc "c" () -> bool {…}

Menu_menuChangedMessagesEnabled #

Source 
@(objc_type=Menu)
@(objc_name="menuChangedMessagesEnabled")
Menu_menuChangedMessagesEnabled :: proc "c" (self: ^Menu) -> bool {…}

Menu_menuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="menuRepresentation")
Menu_menuRepresentation :: proc "c" (self: ^Menu) -> ^objc_object {…}

Menu_menuZone #

Source 
@(objc_type=Menu)
@(objc_name="menuZone")
@(objc_is_class_method=true)
Menu_menuZone :: proc "c" () -> ^Zone {…}

Menu_minimumWidth #

Source 
@(objc_type=Menu)
@(objc_name="minimumWidth")
Menu_minimumWidth :: proc "c" (self: ^Menu) -> CGFloat {…}

Menu_mutableCopyWithZone #

Source 
@(objc_type=Menu)
@(objc_name="mutableCopyWithZone")
@(objc_is_class_method=true)
Menu_mutableCopyWithZone :: proc "c" (zone: ^Zone) -> ^objc_object {…}

Menu_new #

Source 
@(objc_type=Menu)
@(objc_name="new")
@(objc_is_class_method=true)
Menu_new :: proc "c" () -> ^Menu {…}

Menu_numberOfItems #

Source 
@(objc_type=Menu)
@(objc_name="numberOfItems")
Menu_numberOfItems :: proc "c" (self: ^Menu) -> Integer {…}

Menu_paletteMenuWithColors_titles_selectionHandler #

Source 
@(objc_type=Menu)
@(objc_name="paletteMenuWithColors_titles_selectionHandler")
@(objc_is_class_method=true)
Menu_paletteMenuWithColors_titles_selectionHandler :: proc "c" (colors: ^Array, itemTitles: ^Array, onSelectionChange: proc "c" (_arg_0: ^Menu)) -> ^Menu {…}

Menu_performActionForItemAtIndex #

Source 
@(objc_type=Menu)
@(objc_name="performActionForItemAtIndex")
Menu_performActionForItemAtIndex :: proc "c" (self: ^Menu, index: Integer) {…}

Menu_performKeyEquivalent #

Source 
@(objc_type=Menu)
@(objc_name="performKeyEquivalent")
Menu_performKeyEquivalent :: proc "c" (self: ^Menu, event: ^Event) -> bool {…}

Menu_popUpContextMenu_withEvent_forView #

Source 
@(objc_type=Menu)
@(objc_name="popUpContextMenu_withEvent_forView")
@(objc_is_class_method=true)
Menu_popUpContextMenu_withEvent_forView :: proc "c" (menu: ^Menu, event: ^Event, view: ^View) {…}

Menu_popUpMenuPositioningItem #

Source 
@(objc_type=Menu)
@(objc_name="popUpMenuPositioningItem")
Menu_popUpMenuPositioningItem :: proc "c" (self: ^Menu, item: ^MenuItem, location: CGPoint, view: ^View) -> bool {…}

Menu_popUpContextMenu_withEvent_forView_withFont :: #force_inline proc "c" (menu: ^Menu, event: ^Event, view: ^View, font: ^Font) { msgSend(nil, Menu, "popUpContextMenu:withEvent:forView:withFont:", menu, event, view, font) }

Menu_poseAsClass #

Source 
@(objc_type=Menu)
@(objc_name="poseAsClass")
@(objc_is_class_method=true)
Menu_poseAsClass :: proc "c" (aClass: ^objc_class) {…}

Menu_presentationStyle #

Source 
@(objc_type=Menu)
@(objc_name="presentationStyle")
Menu_presentationStyle :: proc "c" (self: ^Menu) -> MenuPresentationStyle {…}

Menu_paletteMenuWithColors_titles_templateImage_selectionHandler :: #force_inline proc "c" (colors: ^Array, itemTitles: ^Array, image: ^Image, onSelectionChange: proc "c" (_arg_0: ^Menu)) -> ^Menu { return msgSend(^Menu, Menu, "paletteMenuWithColors:titles:templateImage:selectionHandler:", colors, itemTitles, image, onSelectionChange) }

Menu_removeAllItems #

Source 
@(objc_type=Menu)
@(objc_name="removeAllItems")
Menu_removeAllItems :: proc "c" (self: ^Menu) {…}

Menu_removeItem #

Source 
@(objc_type=Menu)
@(objc_name="removeItem")
Menu_removeItem :: proc "c" (self: ^Menu, item: ^MenuItem) {…}

Menu_removeItemAtIndex #

Source 
@(objc_type=Menu)
@(objc_name="removeItemAtIndex")
Menu_removeItemAtIndex :: proc "c" (self: ^Menu, index: Integer) {…}

Menu_resolveClassMethod #

Source 
@(objc_type=Menu)
@(objc_name="resolveClassMethod")
@(objc_is_class_method=true)
Menu_resolveClassMethod :: proc "c" (sel: ^objc_selector) -> bool {…}

Menu_resolveInstanceMethod #

Source 
@(objc_type=Menu)
@(objc_name="resolveInstanceMethod")
@(objc_is_class_method=true)
Menu_resolveInstanceMethod :: proc "c" (sel: ^objc_selector) -> bool {…}

Menu_selectedItems #

Source 
@(objc_type=Menu)
@(objc_name="selectedItems")
Menu_selectedItems :: proc "c" (self: ^Menu) -> ^Array {…}

Menu_setAllowsContextMenuPlugIns #

Source 
@(objc_type=Menu)
@(objc_name="setAllowsContextMenuPlugIns")
Menu_setAllowsContextMenuPlugIns :: proc "c" (self: ^Menu, allowsContextMenuPlugIns: bool) {…}

Menu_setAutoenablesItems #

Source 
@(objc_type=Menu)
@(objc_name="setAutoenablesItems")
Menu_setAutoenablesItems :: proc "c" (self: ^Menu, autoenablesItems: bool) {…}

Menu_setContextMenuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="setContextMenuRepresentation")
Menu_setContextMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^objc_object) {…}

Menu_setDefaultPlaceholder #

Source 
@(objc_type=Menu)
@(objc_name="setDefaultPlaceholder")
@(objc_is_class_method=true)
Menu_setDefaultPlaceholder :: proc "c" (placeholder: ^objc_object, marker: ^objc_object, binding: ^String) {…}

Menu_setItemArray #

Source 
@(objc_type=Menu)
@(objc_name="setItemArray")
Menu_setItemArray :: proc "c" (self: ^Menu, itemArray: ^Array) {…}

Menu_setKeys #

Source 
@(objc_type=Menu)
@(objc_name="setKeys")
@(objc_is_class_method=true)
Menu_setKeys :: proc "c" (keys: ^Array, dependentKey: ^String) {…}

Menu_setMenuBarVisible #

Source 
@(objc_type=Menu)
@(objc_name="setMenuBarVisible")
@(objc_is_class_method=true)
Menu_setMenuBarVisible :: proc "c" (visible: bool) {…}

Menu_setMenuChangedMessagesEnabled #

Source 
@(objc_type=Menu)
@(objc_name="setMenuChangedMessagesEnabled")
Menu_setMenuChangedMessagesEnabled :: proc "c" (self: ^Menu, menuChangedMessagesEnabled: bool) {…}

Menu_setMenuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="setMenuRepresentation")
Menu_setMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^objc_object) {…}

Menu_setMenuZone #

Source 
@(objc_type=Menu)
@(objc_name="setMenuZone")
@(objc_is_class_method=true)
Menu_setMenuZone :: proc "c" (zone: ^Zone) {…}

Menu_setMinimumWidth #

Source 
@(objc_type=Menu)
@(objc_name="setMinimumWidth")
Menu_setMinimumWidth :: proc "c" (self: ^Menu, minimumWidth: CGFloat) {…}

Menu_setSelectedItems #

Source 
@(objc_type=Menu)
@(objc_name="setSelectedItems")
Menu_setSelectedItems :: proc "c" (self: ^Menu, selectedItems: ^Array) {…}

Menu_setShowsStateColumn #

Source 
@(objc_type=Menu)
@(objc_name="setShowsStateColumn")
Menu_setShowsStateColumn :: proc "c" (self: ^Menu, showsStateColumn: bool) {…}

Menu_setSupermenu #

Source 
@(objc_type=Menu)
@(objc_name="setSupermenu")
Menu_setSupermenu :: proc "c" (self: ^Menu, supermenu: ^Menu) {…}

Menu_setTearOffMenuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="setTearOffMenuRepresentation")
Menu_setTearOffMenuRepresentation :: proc "c" (self: ^Menu, menuRep: ^objc_object) {…}

Menu_setTitle #

Source 
@(objc_type=Menu)
@(objc_name="setTitle")
Menu_setTitle :: proc "c" (self: ^Menu, title: ^String) {…}

Menu_setUserInterfaceLayoutDirection #

Source 
@(objc_type=Menu)
@(objc_name="setUserInterfaceLayoutDirection")
Menu_setUserInterfaceLayoutDirection :: proc "c" (self: ^Menu, userInterfaceLayoutDirection: UserInterfaceLayoutDirection) {…}

Menu_setVersion #

Source 
@(objc_type=Menu)
@(objc_name="setVersion")
@(objc_is_class_method=true)
Menu_setVersion :: proc "c" (aVersion: Integer) {…}

Menu_showsStateColumn #

Source 
@(objc_type=Menu)
@(objc_name="showsStateColumn")
Menu_showsStateColumn :: proc "c" (self: ^Menu) -> bool {…}

Menu_sizeToFit #

Source 
@(objc_type=Menu)
@(objc_name="sizeToFit")
Menu_sizeToFit :: proc "c" (self: ^Menu) {…}

Menu_submenuAction #

Source 
@(objc_type=Menu)
@(objc_name="submenuAction")
Menu_submenuAction :: proc "c" (self: ^Menu, sender: ^objc_object) {…}

Menu_superclass #

Source 
@(objc_type=Menu)
@(objc_name="superclass")
@(objc_is_class_method=true)
Menu_superclass :: proc "c" () -> ^objc_class {…}

Menu_supermenu #

Source 
@(objc_type=Menu)
@(objc_name="supermenu")
Menu_supermenu :: proc "c" (self: ^Menu) -> ^Menu {…}

Menu_tearOffMenuRepresentation #

Source 
@(objc_type=Menu)
@(objc_name="tearOffMenuRepresentation")
Menu_tearOffMenuRepresentation :: proc "c" (self: ^Menu) -> ^objc_object {…}

Menu_update #

Source 
@(objc_type=Menu)
@(objc_name="update")
Menu_update :: proc "c" (self: ^Menu) {…}

Menu_useStoredAccessor #

Source 
@(objc_type=Menu)
@(objc_name="useStoredAccessor")
@(objc_is_class_method=true)
Menu_useStoredAccessor :: proc "c" () -> bool {…}

Menu_version #

Source 
@(objc_type=Menu)
@(objc_name="version")
@(objc_is_class_method=true)
Menu_version :: proc "c" () -> Integer {…}

MenuDelegate_confinementRectForMenu #

Source 
@(objc_type=MenuDelegate)
@(objc_name="confinementRectForMenu")
MenuDelegate_confinementRectForMenu :: proc "c" (self: ^MenuDelegate, menu: ^Menu, screen: ^Screen) -> CGRect {…}

MenuDelegate_menu_updateItem_atIndex_shouldCancel #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menu_updateItem_atIndex_shouldCancel")
MenuDelegate_menu_updateItem_atIndex_shouldCancel :: proc "c" (self: ^MenuDelegate, menu: ^Menu, item: ^MenuItem, index: Integer, shouldCancel: bool) -> bool {…}

MenuDelegate_menu_willHighlightItem #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menu_willHighlightItem")
MenuDelegate_menu_willHighlightItem :: proc "c" (self: ^MenuDelegate, menu: ^Menu, item: ^MenuItem) {…}

MenuDelegate_menuDidClose #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menuDidClose")
MenuDelegate_menuDidClose :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}

MenuDelegate_menuHasKeyEquivalent #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menuHasKeyEquivalent")
MenuDelegate_menuHasKeyEquivalent :: proc "c" (self: ^MenuDelegate, menu: ^Menu, event: ^Event, target: ^^objc_object, action: ^^objc_selector) -> bool {…}

MenuDelegate_menuNeedsUpdate #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menuNeedsUpdate")
MenuDelegate_menuNeedsUpdate :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}

MenuDelegate_menuWillOpen #

Source 
@(objc_type=MenuDelegate)
@(objc_name="menuWillOpen")
MenuDelegate_menuWillOpen :: proc "c" (self: ^MenuDelegate, menu: ^Menu) {…}

MenuDelegate_numberOfItemsInMenu #

Source 
@(objc_type=MenuDelegate)
@(objc_name="numberOfItemsInMenu")
MenuDelegate_numberOfItemsInMenu :: proc "c" (self: ^MenuDelegate, menu: ^Menu) -> Integer {…}

MenuItem_accessInstanceVariablesDirectly #

Source 
@(objc_type=MenuItem)
@(objc_name="accessInstanceVariablesDirectly")
@(objc_is_class_method=true)
MenuItem_accessInstanceVariablesDirectly :: proc "c" () -> bool {…}

MenuItem_action #

Source 
@(objc_type=MenuItem)
@(objc_name="action")
MenuItem_action :: proc "c" (self: ^MenuItem) -> ^objc_selector {…}

MenuItem_alloc #

Source 
@(objc_type=MenuItem)
@(objc_name="alloc")
@(objc_is_class_method=true)
MenuItem_alloc :: proc "c" () -> ^MenuItem {…}

MenuItem_allocWithZone #

Source 
@(objc_type=MenuItem)
@(objc_name="allocWithZone")
@(objc_is_class_method=true)
MenuItem_allocWithZone :: proc "c" (zone: ^Zone) -> ^MenuItem {…}

MenuItem_allowsAutomaticKeyEquivalentLocalization #

Source 
@(objc_type=MenuItem)
@(objc_name="allowsAutomaticKeyEquivalentLocalization")
MenuItem_allowsAutomaticKeyEquivalentLocalization :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_allowsAutomaticKeyEquivalentMirroring #

Source 
@(objc_type=MenuItem)
@(objc_name="allowsAutomaticKeyEquivalentMirroring")
MenuItem_allowsAutomaticKeyEquivalentMirroring :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_allowsKeyEquivalentWhenHidden #

Source 
@(objc_type=MenuItem)
@(objc_name="allowsKeyEquivalentWhenHidden")
MenuItem_allowsKeyEquivalentWhenHidden :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_automaticallyNotifiesObserversForKey #

Source 
@(objc_type=MenuItem)
@(objc_name="automaticallyNotifiesObserversForKey")
@(objc_is_class_method=true)
MenuItem_automaticallyNotifiesObserversForKey :: proc "c" (key: ^String) -> bool {…}

MenuItem_cancelPreviousPerformRequestsWithTarget_ #

Source 
@(objc_type=MenuItem)
@(objc_name="cancelPreviousPerformRequestsWithTarget_")
@(objc_is_class_method=true)
MenuItem_cancelPreviousPerformRequestsWithTarget_ :: proc "c" (aTarget: ^objc_object) {…}

MenuItem_cancelPreviousPerformRequestsWithTarget_selector_object #

Source 
@(objc_type=MenuItem)
@(objc_name="cancelPreviousPerformRequestsWithTarget_selector_object")
@(objc_is_class_method=true)
MenuItem_cancelPreviousPerformRequestsWithTarget_selector_object :: proc "c" (aTarget: ^objc_object, aSelector: ^objc_selector, anArgument: ^objc_object) {…}

MenuItem_class #

Source 
@(objc_type=MenuItem)
@(objc_name="class")
@(objc_is_class_method=true)
MenuItem_class :: proc "c" () -> ^objc_class {…}

MenuItem_classFallbacksForKeyedArchiver #

Source 
@(objc_type=MenuItem)
@(objc_name="classFallbacksForKeyedArchiver")
@(objc_is_class_method=true)
MenuItem_classFallbacksForKeyedArchiver :: proc "c" () -> ^Array {…}

MenuItem_classForKeyedUnarchiver #

Source 
@(objc_type=MenuItem)
@(objc_name="classForKeyedUnarchiver")
@(objc_is_class_method=true)
MenuItem_classForKeyedUnarchiver :: proc "c" () -> ^objc_class {…}

MenuItem_conformsToProtocol #

Source 
@(objc_type=MenuItem)
@(objc_name="conformsToProtocol")
@(objc_is_class_method=true)
MenuItem_conformsToProtocol :: proc "c" (protocol: ^Protocol) -> bool {…}

MenuItem_copyWithZone #

Source 
@(objc_type=MenuItem)
@(objc_name="copyWithZone")
@(objc_is_class_method=true)
MenuItem_copyWithZone :: proc "c" (zone: ^Zone) -> ^objc_object {…}

MenuItem_debugDescription #

Source 
@(objc_type=MenuItem)
@(objc_name="debugDescription")
@(objc_is_class_method=true)
MenuItem_debugDescription :: proc "c" () -> ^String {…}

MenuItem_defaultPlaceholderForMarker #

Source 
@(objc_type=MenuItem)
@(objc_name="defaultPlaceholderForMarker")
@(objc_is_class_method=true)
MenuItem_defaultPlaceholderForMarker :: proc "c" (marker: ^objc_object, binding: ^String) -> ^objc_object {…}

MenuItem_description #

Source 
@(objc_type=MenuItem)
@(objc_name="description")
@(objc_is_class_method=true)
MenuItem_description :: proc "c" () -> ^String {…}

MenuItem_exposeBinding #

Source 
@(objc_type=MenuItem)
@(objc_name="exposeBinding")
@(objc_is_class_method=true)
MenuItem_exposeBinding :: proc "c" (binding: ^String) {…}

MenuItem_hash #

Source 
@(objc_type=MenuItem)
@(objc_name="hash")
@(objc_is_class_method=true)
MenuItem_hash :: proc "c" () -> UInteger {…}

MenuItem_hasSubmenu #

Source 
@(objc_type=MenuItem)
@(objc_name="hasSubmenu")
MenuItem_hasSubmenu :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_indentationLevel #

Source 
@(objc_type=MenuItem)
@(objc_name="indentationLevel")
MenuItem_indentationLevel :: proc "c" (self: ^MenuItem) -> Integer {…}

MenuItem_initialize #

Source 
@(objc_type=MenuItem)
@(objc_name="initialize")
@(objc_is_class_method=true)
MenuItem_initialize :: proc "c" () {…}

MenuItem_initWithTitle #

Source 
@(objc_type=MenuItem)
@(objc_name="initWithTitle")
MenuItem_initWithTitle :: proc "c" (self: ^MenuItem, string: ^String, selector: ^objc_selector, charCode: ^String) -> ^MenuItem {…}

MenuItem_instanceMethodForSelector #

Source 
@(objc_type=MenuItem)
@(objc_name="instanceMethodForSelector")
@(objc_is_class_method=true)
MenuItem_instanceMethodForSelector :: proc "c" (aSelector: ^objc_selector) -> IMP {…}

MenuItem_instancesRespondToSelector #

Source 
@(objc_type=MenuItem)
@(objc_name="instancesRespondToSelector")
@(objc_is_class_method=true)
MenuItem_instancesRespondToSelector :: proc "c" (aSelector: ^objc_selector) -> bool {…}

MenuItem_isAlternate #

Source 
@(objc_type=MenuItem)
@(objc_name="isAlternate")
MenuItem_isAlternate :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isEnabled #

Source 
@(objc_type=MenuItem)
@(objc_name="isEnabled")
MenuItem_isEnabled :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_image :: #force_inline proc "c" (self: ^MenuItem) -> ^Image { return msgSend(^Image, self, "image") } MenuItem_setImage :: #force_inline proc "c" (self: ^MenuItem, image: ^Image) { msgSend(nil, self, "setImage:", image) } MenuItem_state :: #force_inline proc "c" (self: ^MenuItem) -> ControlStateValue { return msgSend(ControlStateValue, self, "state") } MenuItem_setState :: #force_inline proc "c" (self: ^MenuItem, state: ControlStateValue) { msgSend(nil, self, "setState:", state) } MenuItem_onStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image { return msgSend(^Image, self, "onStateImage") } MenuItem_setOnStateImage :: #force_inline proc "c" (self: ^MenuItem, onStateImage: ^Image) { msgSend(nil, self, "setOnStateImage:", onStateImage) } MenuItem_offStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image { return msgSend(^Image, self, "offStateImage") } MenuItem_setOffStateImage :: #force_inline proc "c" (self: ^MenuItem, offStateImage: ^Image) { msgSend(nil, self, "setOffStateImage:", offStateImage) } MenuItem_mixedStateImage :: #force_inline proc "c" (self: ^MenuItem) -> ^Image { return msgSend(^Image, self, "mixedStateImage") } MenuItem_setMixedStateImage :: #force_inline proc "c" (self: ^MenuItem, mixedStateImage: ^Image) { msgSend(nil, self, "setMixedStateImage:", mixedStateImage) }

MenuItem_isHidden #

Source 
@(objc_type=MenuItem)
@(objc_name="isHidden")
MenuItem_isHidden :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isHiddenOrHasHiddenAncestor #

Source 
@(objc_type=MenuItem)
@(objc_name="isHiddenOrHasHiddenAncestor")
MenuItem_isHiddenOrHasHiddenAncestor :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isHighlighted #

Source 
@(objc_type=MenuItem)
@(objc_name="isHighlighted")
MenuItem_isHighlighted :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isSectionHeader #

Source 
@(objc_type=MenuItem)
@(objc_name="isSectionHeader")
MenuItem_isSectionHeader :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isSeparatorItem #

Source 
@(objc_type=MenuItem)
@(objc_name="isSeparatorItem")
MenuItem_isSeparatorItem :: proc "c" (self: ^MenuItem) -> bool {…}

MenuItem_isSubclassOfClass #

Source 
@(objc_type=MenuItem)
@(objc_name="isSubclassOfClass")
@(objc_is_class_method=true)
MenuItem_isSubclassOfClass :: proc "c" (aClass: ^objc_class) -> bool {…}

MenuItem_instanceMethodSignatureForSelector :: #force_inline proc "c" (aSelector: SEL) -> ^MethodSignature { return msgSend(^MethodSignature, MenuItem, "instanceMethodSignatureForSelector:", aSelector) }

MenuItem_keyEquivalent #

Source 
@(objc_type=MenuItem)
@(objc_name="keyEquivalent")
MenuItem_keyEquivalent :: proc "c" (self: ^MenuItem) -> ^String {…}

MenuItem_keyEquivalentModifierMask #

Source 
@(objc_type=MenuItem)
@(objc_name="keyEquivalentModifierMask")
MenuItem_keyEquivalentModifierMask :: proc "c" (self: ^MenuItem) -> EventModifierFlags {…}

MenuItem_keyPathsForValuesAffectingValueForKey #

Source 
@(objc_type=MenuItem)
@(objc_name="keyPathsForValuesAffectingValueForKey")
@(objc_is_class_method=true)
MenuItem_keyPathsForValuesAffectingValueForKey :: proc "c" (key: ^String) -> ^Set {…}

MenuItem_load #

Source 
@(objc_type=MenuItem)
@(objc_name="load")
@(objc_is_class_method=true)
MenuItem_load :: proc "c" () {…}

MenuItem_mnemonicLocation #

Source 
@(objc_type=MenuItem)
@(objc_name="mnemonicLocation")
MenuItem_mnemonicLocation :: proc "c" (self: ^MenuItem) -> UInteger {…}

MenuItem_mutableCopyWithZone #

Source 
@(objc_type=MenuItem)
@(objc_name="mutableCopyWithZone")
@(objc_is_class_method=true)
MenuItem_mutableCopyWithZone :: proc "c" (zone: ^Zone) -> ^objc_object {…}

MenuItem_new #

Source 
@(objc_type=MenuItem)
@(objc_name="new")
@(objc_is_class_method=true)
MenuItem_new :: proc "c" () -> ^MenuItem {…}

MenuItem_poseAsClass #

Source 
@(objc_type=MenuItem)
@(objc_name="poseAsClass")
@(objc_is_class_method=true)
MenuItem_poseAsClass :: proc "c" (aClass: ^objc_class) {…}

MenuItem_registerActionCallback #

Source 
@(objc_type=MenuItem)
@(objc_name="registerActionCallback")
@(objc_is_class_method=true)
MenuItem_registerActionCallback :: proc "c" (name: cstring, callback: MenuItemCallback) -> ^objc_selector {…}

MenuItem_representedObject #

Source 
@(objc_type=MenuItem)
@(objc_name="representedObject")
MenuItem_representedObject :: proc "c" (self: ^MenuItem) -> ^objc_object {…}

MenuItem_resolveClassMethod #

Source 
@(objc_type=MenuItem)
@(objc_name="resolveClassMethod")
@(objc_is_class_method=true)
MenuItem_resolveClassMethod :: proc "c" (sel: ^objc_selector) -> bool {…}

MenuItem_resolveInstanceMethod #

Source 
@(objc_type=MenuItem)
@(objc_name="resolveInstanceMethod")
@(objc_is_class_method=true)
MenuItem_resolveInstanceMethod :: proc "c" (sel: ^objc_selector) -> bool {…}

MenuItem_sectionHeaderWithTitle #

Source 
@(objc_type=MenuItem)
@(objc_name="sectionHeaderWithTitle")
@(objc_is_class_method=true)
MenuItem_sectionHeaderWithTitle :: proc "c" (title: ^String) -> ^MenuItem {…}

MenuItem_separatorItem #

Source 
@(objc_type=MenuItem)
@(objc_name="separatorItem")
@(objc_is_class_method=true)
MenuItem_separatorItem :: proc "c" () -> ^MenuItem {…}

MenuItem_setAction #

Source 
@(objc_type=MenuItem)
@(objc_name="setAction")
MenuItem_setAction :: proc "c" (self: ^MenuItem, action: ^objc_selector) {…}

MenuItem_setAllowsAutomaticKeyEquivalentLocalization #

Source 
@(objc_type=MenuItem)
@(objc_name="setAllowsAutomaticKeyEquivalentLocalization")
MenuItem_setAllowsAutomaticKeyEquivalentLocalization :: proc "c" (self: ^MenuItem, allowsAutomaticKeyEquivalentLocalization: bool) {…}

MenuItem_setAllowsAutomaticKeyEquivalentMirroring #

Source 
@(objc_type=MenuItem)
@(objc_name="setAllowsAutomaticKeyEquivalentMirroring")
MenuItem_setAllowsAutomaticKeyEquivalentMirroring :: proc "c" (self: ^MenuItem, allowsAutomaticKeyEquivalentMirroring: bool) {…}

MenuItem_setAllowsKeyEquivalentWhenHidden #

Source 
@(objc_type=MenuItem)
@(objc_name="setAllowsKeyEquivalentWhenHidden")
MenuItem_setAllowsKeyEquivalentWhenHidden :: proc "c" (self: ^MenuItem, allowsKeyEquivalentWhenHidden: bool) {…}

MenuItem_setAlternate #

Source 
@(objc_type=MenuItem)
@(objc_name="setAlternate")
MenuItem_setAlternate :: proc "c" (self: ^MenuItem, alternate: bool) {…}

MenuItem_setDefaultPlaceholder #

Source 
@(objc_type=MenuItem)
@(objc_name="setDefaultPlaceholder")
@(objc_is_class_method=true)
MenuItem_setDefaultPlaceholder :: proc "c" (placeholder: ^objc_object, marker: ^objc_object, binding: ^String) {…}

MenuItem_setEnabled #

Source 
@(objc_type=MenuItem)
@(objc_name="setEnabled")
MenuItem_setEnabled :: proc "c" (self: ^MenuItem, enabled: bool) {…}

MenuItem_setHidden #

Source 
@(objc_type=MenuItem)
@(objc_name="setHidden")
MenuItem_setHidden :: proc "c" (self: ^MenuItem, hidden: bool) {…}

MenuItem_setIndentationLevel #

Source 
@(objc_type=MenuItem)
@(objc_name="setIndentationLevel")
MenuItem_setIndentationLevel :: proc "c" (self: ^MenuItem, indentationLevel: Integer) {…}

MenuItem_setKeyEquivalent #

Source 
@(objc_type=MenuItem)
@(objc_name="setKeyEquivalent")
MenuItem_setKeyEquivalent :: proc "c" (self: ^MenuItem, keyEquivalent: ^String) {…}

MenuItem_setKeyEquivalentModifierMask #

Source 
@(objc_type=MenuItem)
@(objc_name="setKeyEquivalentModifierMask")
MenuItem_setKeyEquivalentModifierMask :: proc "c" (self: ^MenuItem, keyEquivalentModifierMask: EventModifierFlags) {…}

MenuItem_setKeys #

Source 
@(objc_type=MenuItem)
@(objc_name="setKeys")
@(objc_is_class_method=true)
MenuItem_setKeys :: proc "c" (keys: ^Array, dependentKey: ^String) {…}

MenuItem_setMenu #

Source 
@(objc_type=MenuItem)
@(objc_name="setMenu")
MenuItem_setMenu :: proc "c" (self: ^MenuItem, menu: ^Menu) {…}

MenuItem_setMnemonicLocation #

Source 
@(objc_type=MenuItem)
@(objc_name="setMnemonicLocation")
MenuItem_setMnemonicLocation :: proc "c" (self: ^MenuItem, location: UInteger) {…}

MenuItem_badge :: #force_inline proc "c" (self: ^MenuItem) -> ^MenuItemBadge { return msgSend(^MenuItemBadge, self, "badge") } MenuItem_setBadge :: #force_inline proc "c" (self: ^MenuItem, badge: ^MenuItemBadge) { msgSend(nil, self, "setBadge:", badge) }

MenuItem_setRepresentedObject #

Source 
@(objc_type=MenuItem)
@(objc_name="setRepresentedObject")
MenuItem_setRepresentedObject :: proc "c" (self: ^MenuItem, representedObject: ^objc_object) {…}

MenuItem_setSubmenu #

Source 
@(objc_type=MenuItem)
@(objc_name="setSubmenu")
MenuItem_setSubmenu :: proc "c" (self: ^MenuItem, submenu: ^Menu) {…}

MenuItem_setSubtitle #

Source 
@(objc_type=MenuItem)
@(objc_name="setSubtitle")
MenuItem_setSubtitle :: proc "c" (self: ^MenuItem, subtitle: ^String) {…}

MenuItem_setTarget #

Source 
@(objc_type=MenuItem)
@(objc_name="setTarget")
MenuItem_setTarget :: proc "c" (self: ^MenuItem, target: ^objc_object) {…}

MenuItem_setTitle #

Source 
@(objc_type=MenuItem)
@(objc_name="setTitle")
MenuItem_setTitle :: proc "c" (self: ^MenuItem, title: ^String) {…}

MenuItem_setTitleWithMnemonic #

Source 
@(objc_type=MenuItem)
@(objc_name="setTitleWithMnemonic")
MenuItem_setTitleWithMnemonic :: proc "c" (self: ^MenuItem, stringWithAmpersand: ^String) {…}

MenuItem_setToolTip #

Source 
@(objc_type=MenuItem)
@(objc_name="setToolTip")
MenuItem_setToolTip :: proc "c" (self: ^MenuItem, toolTip: ^String) {…}

MenuItem_setUsesUserKeyEquivalents #

Source 
@(objc_type=MenuItem)
@(objc_name="setUsesUserKeyEquivalents")
@(objc_is_class_method=true)
MenuItem_setUsesUserKeyEquivalents :: proc "c" (usesUserKeyEquivalents: bool) {…}

MenuItem_setVersion #

Source 
@(objc_type=MenuItem)
@(objc_name="setVersion")
@(objc_is_class_method=true)
MenuItem_setVersion :: proc "c" (aVersion: Integer) {…}

MenuItem_setView #

Source 
@(objc_type=MenuItem)
@(objc_name="setView")
MenuItem_setView :: proc "c" (self: ^MenuItem, view: ^View) {…}

MenuItem_submenu #

Source 
@(objc_type=MenuItem)
@(objc_name="submenu")
MenuItem_submenu :: proc "c" (self: ^MenuItem) -> ^Menu {…}

MenuItem_subtitle #

Source 
@(objc_type=MenuItem)
@(objc_name="subtitle")
MenuItem_subtitle :: proc "c" (self: ^MenuItem) -> ^String {…}

MenuItem_attributedTitle :: #force_inline proc "c" (self: ^MenuItem) -> ^AttributedString { return msgSend(^AttributedString, self, "attributedTitle") } MenuItem_setAttributedTitle :: #force_inline proc "c" (self: ^MenuItem, attributedTitle: ^AttributedString) { msgSend(nil, self, "setAttributedTitle:", attributedTitle) }

MenuItem_superclass #

Source 
@(objc_type=MenuItem)
@(objc_name="superclass")
@(objc_is_class_method=true)
MenuItem_superclass :: proc "c" () -> ^objc_class {…}

MenuItem_target #

Source 
@(objc_type=MenuItem)
@(objc_name="target")
MenuItem_target :: proc "c" (self: ^MenuItem) -> ^objc_object {…}

MenuItem_userKeyEquivalent #

Source 
@(objc_type=MenuItem)
@(objc_name="userKeyEquivalent")
MenuItem_userKeyEquivalent :: proc "c" (self: ^MenuItem) -> ^String {…}

MenuItem_useStoredAccessor #

Source 
@(objc_type=MenuItem)
@(objc_name="useStoredAccessor")
@(objc_is_class_method=true)
MenuItem_useStoredAccessor :: proc "c" () -> bool {…}

MenuItem_usesUserKeyEquivalents #

Source 
@(objc_type=MenuItem)
@(objc_name="usesUserKeyEquivalents")
@(objc_is_class_method=true)
MenuItem_usesUserKeyEquivalents :: proc "c" () -> bool {…}

MenuItem_version #

Source 
@(objc_type=MenuItem)
@(objc_name="version")
@(objc_is_class_method=true)
MenuItem_version :: proc "c" () -> Integer {…}

methodSignatureForSelector #

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

MutableArray_alloc #

Source 
@(objc_type=MutableArray)
@(objc_name="alloc")
@(objc_is_class_method=true)
MutableArray_alloc :: proc "c" () -> ^MutableArray {…}

MutableArray_exchangeObjectAtIndex #

Source 
@(objc_type=MutableArray)
@(objc_name="exchangeObjectAtIndex")
MutableArray_exchangeObjectAtIndex :: proc "c" (self: ^MutableArray, idx1, idx2: UInteger) {…}

Notification_alloc #

Source 
@(objc_type=Notification)
@(objc_name="alloc")
@(objc_is_class_method=true)
Notification_alloc :: proc "c" () -> ^Notification {…}

NotificationCenter_addObserver #

Source 
@(objc_type=NotificationCenter)
@(objc_name="addObserver")
NotificationCenter_addObserver :: proc "c" (self: ^NotificationCenter, observer: ^Object, selector: ^objc_selector, name: ^String, object: ^Object) {…}

NotificationCenter_alloc #

Source 
@(objc_type=NotificationCenter)
@(objc_name="alloc")
@(objc_is_class_method=true)
NotificationCenter_alloc :: proc "c" () -> ^NotificationCenter {…}

NotificationCenter_defaultCenter #

Source 
@(objc_type=NotificationCenter)
@(objc_name="defaultCenter")
@(objc_is_class_method=true)
NotificationCenter_defaultCenter :: proc "c" () -> ^NotificationCenter {…}

NotificationCenter_removeObserver #

Source 
@(objc_type=NotificationCenter)
@(objc_name="removeObserver")
NotificationCenter_removeObserver :: proc "c" (self: ^NotificationCenter, pObserver: ^Object) {…}

NSWindow_setFrameAutosaveName #

Source 
@(objc_type=Window)
@(objc_name="setFrameAutosaveName")
NSWindow_setFrameAutosaveName :: proc "c" (self: ^Window, name: ^String) {…}

Number_alloc #

Source 
@(objc_type=Number)
@(objc_name="alloc")
@(objc_is_class_method=true)
Number_alloc :: proc "c" () -> ^Number {…}

Number_boolValue #

Source 
@(objc_type=Number)
@(objc_name="boolValue")
Number_boolValue :: proc "c" (self: ^Number) -> bool {…}

Number_descriptionWithLocale #

Source 
@(objc_type=Number)
@(objc_name="descriptionWithLocale")
Number_descriptionWithLocale :: proc "c" (self: ^Number, locale: ^Object) -> ^String {…}

Number_f32Value #

Source 
@(objc_type=Number)
@(objc_name="f32Value")
Number_f32Value :: proc "c" (self: ^Number) -> f32 {…}

Number_f64Value #

Source 
@(objc_type=Number)
@(objc_name="f64Value")
Number_f64Value :: proc "c" (self: ^Number) -> f64 {…}

Number_i16Value #

Source 
@(objc_type=Number)
@(objc_name="i16Value")
Number_i16Value :: proc "c" (self: ^Number) -> i16 {…}

Number_i32Value #

Source 
@(objc_type=Number)
@(objc_name="i32Value")
Number_i32Value :: proc "c" (self: ^Number) -> i32 {…}

Number_i64Value #

Source 
@(objc_type=Number)
@(objc_name="i64Value")
Number_i64Value :: proc "c" (self: ^Number) -> i64 {…}

Number_i8Value #

Source 
@(objc_type=Number)
@(objc_name="i8Value")
Number_i8Value :: proc "c" (self: ^Number) -> i8 {…}

Number_initWithBool #

Source 
@(objc_type=Number)
@(objc_name="initWithBool")
Number_initWithBool :: proc "c" (self: ^Number, value: bool) -> ^Number {…}

Number_initWithF32 #

Source 
@(objc_type=Number)
@(objc_name="initWithF32")
Number_initWithF32 :: proc "c" (self: ^Number, value: f32) -> ^Number {…}

Number_initWithF64 #

Source 
@(objc_type=Number)
@(objc_name="initWithF64")
Number_initWithF64 :: proc "c" (self: ^Number, value: f64) -> ^Number {…}

Number_initWithI16 #

Source 
@(objc_type=Number)
@(objc_name="initWithI16")
Number_initWithI16 :: proc "c" (self: ^Number, value: i16) -> ^Number {…}

Number_initWithI32 #

Source 
@(objc_type=Number)
@(objc_name="initWithI32")
Number_initWithI32 :: proc "c" (self: ^Number, value: i32) -> ^Number {…}

Number_initWithI64 #

Source 
@(objc_type=Number)
@(objc_name="initWithI64")
Number_initWithI64 :: proc "c" (self: ^Number, value: i64) -> ^Number {…}

Number_initWithI8 #

Source 
@(objc_type=Number)
@(objc_name="initWithI8")
Number_initWithI8 :: proc "c" (self: ^Number, value: i8) -> ^Number {…}

Number_initWithInt #

Source 
@(objc_type=Number)
@(objc_name="initWithInt")
Number_initWithInt :: proc "c" (self: ^Number, value: int) -> ^Number {…}

Number_initWithU16 #

Source 
@(objc_type=Number)
@(objc_name="initWithU16")
Number_initWithU16 :: proc "c" (self: ^Number, value: u16) -> ^Number {…}

Number_initWithU32 #

Source 
@(objc_type=Number)
@(objc_name="initWithU32")
Number_initWithU32 :: proc "c" (self: ^Number, value: u32) -> ^Number {…}

Number_initWithU64 #

Source 
@(objc_type=Number)
@(objc_name="initWithU64")
Number_initWithU64 :: proc "c" (self: ^Number, value: u64) -> ^Number {…}

Number_initWithU8 #

Source 
@(objc_type=Number)
@(objc_name="initWithU8")
Number_initWithU8 :: proc "c" (self: ^Number, value: u8) -> ^Number {…}

Number_initWithUint #

Source 
@(objc_type=Number)
@(objc_name="initWithUint")
Number_initWithUint :: proc "c" (self: ^Number, value: uint) -> ^Number {…}

Number_integerValue #

Source 
@(objc_type=Number)
@(objc_name="integerValue")
Number_integerValue :: proc "c" (self: ^Number) -> Integer {…}

Number_intValue #

Source 
@(objc_type=Number)
@(objc_name="intValue")
Number_intValue :: proc "c" (self: ^Number) -> int {…}

Number_isEqualToNumber #

Source 
@(objc_type=Number)
@(objc_name="isEqualToNumber")
Number_isEqualToNumber :: proc "c" (self, other: ^Number) -> bool {…}

Number_numberWithBool #

Source 
@(objc_type=Number)
@(objc_name="numberWithBool")
@(objc_is_class_method=true)
Number_numberWithBool :: proc "c" (value: bool) -> ^Number {…}

Number_numberWithF32 #

Source 
@(objc_type=Number)
@(objc_name="numberWithF32")
@(objc_is_class_method=true)
Number_numberWithF32 :: proc "c" (value: f32) -> ^Number {…}

Number_numberWithF64 #

Source 
@(objc_type=Number)
@(objc_name="numberWithF64")
@(objc_is_class_method=true)
Number_numberWithF64 :: proc "c" (value: f64) -> ^Number {…}

Number_numberWithI16 #

Source 
@(objc_type=Number)
@(objc_name="numberWithI16")
@(objc_is_class_method=true)
Number_numberWithI16 :: proc "c" (value: i16) -> ^Number {…}

Number_numberWithI32 #

Source 
@(objc_type=Number)
@(objc_name="numberWithI32")
@(objc_is_class_method=true)
Number_numberWithI32 :: proc "c" (value: i32) -> ^Number {…}

Number_numberWithI64 #

Source 
@(objc_type=Number)
@(objc_name="numberWithI64")
@(objc_is_class_method=true)
Number_numberWithI64 :: proc "c" (value: i64) -> ^Number {…}

Number_numberWithI8 #

Source 
@(objc_type=Number)
@(objc_name="numberWithI8")
@(objc_is_class_method=true)
Number_numberWithI8 :: proc "c" (value: i8) -> ^Number {…}

Number_numberWithInt #

Source 
@(objc_type=Number)
@(objc_name="numberWithInt")
@(objc_is_class_method=true)
Number_numberWithInt :: proc "c" (value: int) -> ^Number {…}

Number_numberWithU16 #

Source 
@(objc_type=Number)
@(objc_name="numberWithU16")
@(objc_is_class_method=true)
Number_numberWithU16 :: proc "c" (value: u16) -> ^Number {…}

Number_numberWithU32 #

Source 
@(objc_type=Number)
@(objc_name="numberWithU32")
@(objc_is_class_method=true)
Number_numberWithU32 :: proc "c" (value: u32) -> ^Number {…}

Number_numberWithU64 #

Source 
@(objc_type=Number)
@(objc_name="numberWithU64")
@(objc_is_class_method=true)
Number_numberWithU64 :: proc "c" (value: u64) -> ^Number {…}

Number_numberWithU8 #

Source 
@(objc_type=Number)
@(objc_name="numberWithU8")
@(objc_is_class_method=true)
Number_numberWithU8 :: proc "c" (value: u8) -> ^Number {…}

Number_numberWithUint #

Source 
@(objc_type=Number)
@(objc_name="numberWithUint")
@(objc_is_class_method=true)
Number_numberWithUint :: proc "c" (value: uint) -> ^Number {…}

Number_stringValue #

Source 
@(objc_type=Number)
@(objc_name="stringValue")
Number_stringValue :: proc "c" (self: ^Number) -> ^String {…}

Number_u16Value #

Source 
@(objc_type=Number)
@(objc_name="u16Value")
Number_u16Value :: proc "c" (self: ^Number) -> u16 {…}

Number_u32Value #

Source 
@(objc_type=Number)
@(objc_name="u32Value")
Number_u32Value :: proc "c" (self: ^Number) -> u32 {…}

Number_u64Value #

Source 
@(objc_type=Number)
@(objc_name="u64Value")
Number_u64Value :: proc "c" (self: ^Number) -> u64 {…}

Number_u8Value #

Source 
@(objc_type=Number)
@(objc_name="u8Value")
Number_u8Value :: proc "c" (self: ^Number) -> u8 {…}

Number_uintegerValue #

Source 
@(objc_type=Number)
@(objc_name="uintegerValue")
Number_uintegerValue :: proc "c" (self: ^Number) -> UInteger {…}

Number_uintValue #

Source 
@(objc_type=Number)
@(objc_name="uintValue")
Number_uintValue :: proc "c" (self: ^Number) -> uint {…}

objc_allocateClassPair #

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

objc_constructInstance #

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

objc_copyClassList #

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

objc_disposeClassPair #

Source 
objc_disposeClassPair :: proc "c" (cls: ^objc_class) ---

objc_duplicateClass #

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

objc_getAssociatedObject #

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

objc_getClassList #

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

objc_registerClassPair #

Source 
objc_registerClassPair :: proc "c" (cls: ^objc_class) ---

objc_removeAssociatedObjects #

Source 
objc_removeAssociatedObjects :: proc "c" (object: ^objc_object) ---

object_copy #

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

object_dispose #

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

object_getClass #

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

object_getIndexedIvars #

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

object_setClass #

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

OpenPanel_openPanel #

Source 
@(objc_type=OpenPanel)
@(objc_name="openPanel")
@(objc_is_class_method=true)
OpenPanel_openPanel :: proc "c" () -> ^OpenPanel {…}

OpenPanel_setAllowedFileTypes #

Source 
@(objc_type=OpenPanel)
@(objc_name="setAllowedFileTypes")
OpenPanel_setAllowedFileTypes :: proc "c" (self: ^OpenPanel, types: ^Array) {…}

OpenPanel_setAllowsMultipleSelection #

Source 
@(objc_type=OpenPanel)
@(objc_name="setAllowsMultipleSelection")
OpenPanel_setAllowsMultipleSelection :: proc "c" (self: ^OpenPanel, setting: bool) {…}

OpenPanel_setCanChooseDirectories #

Source 
@(objc_type=OpenPanel)
@(objc_name="setCanChooseDirectories")
OpenPanel_setCanChooseDirectories :: proc "c" (self: ^OpenPanel, setting: bool) {…}

OpenPanel_setCanChooseFiles #

Source 
@(objc_type=OpenPanel)
@(objc_name="setCanChooseFiles")
OpenPanel_setCanChooseFiles :: proc "c" (self: ^OpenPanel, setting: bool) {…}

OpenPanel_setResolvesAliases #

Source 
@(objc_type=OpenPanel)
@(objc_name="setResolvesAliases")
OpenPanel_setResolvesAliases :: proc "c" (self: ^OpenPanel, setting: bool) {…}

performSelectorOnMainThread #

Source 
@(objc_type=Object)
@(objc_name="performSelectorOnMainThread")
performSelectorOnMainThread :: proc "c" (self: ^Object, aSelector: ^objc_selector, arg: ^objc_object, wait: bool) {…}

ProcessInfo_activeProcessorCount #

Source 
@(objc_type=ProcessInfo)
@(objc_name="activeProcessorCount")
ProcessInfo_activeProcessorCount :: proc "c" (self: ^ProcessInfo) -> UInteger {…}

ProcessInfo_arguments #

Source 
@(objc_type=ProcessInfo)
@(objc_name="arguments")
ProcessInfo_arguments :: proc "c" (self: ^ProcessInfo) -> ^Array {…}

ProcessInfo_automaticTerminationSupportEnabled #

Source 
@(objc_type=ProcessInfo)
@(objc_name="automaticTerminationSupportEnabled")
ProcessInfo_automaticTerminationSupportEnabled :: proc "c" (self: ^ProcessInfo) -> bool {…}

ProcessInfo_disableAutomaticTermination #

Source 
@(objc_type=ProcessInfo)
@(objc_name="disableAutomaticTermination")
ProcessInfo_disableAutomaticTermination :: proc "c" (self: ^ProcessInfo, reason: ^String) {…}

ProcessInfo_disableSuddenTermination #

Source 
@(objc_type=ProcessInfo)
@(objc_name="disableSuddenTermination")
ProcessInfo_disableSuddenTermination :: proc "c" (self: ^ProcessInfo) {…}

ProcessInfo_enableAutomaticTermination #

Source 
@(objc_type=ProcessInfo)
@(objc_name="enableAutomaticTermination")
ProcessInfo_enableAutomaticTermination :: proc "c" (self: ^ProcessInfo, reason: ^String) {…}

ProcessInfo_enableSuddenTermination #

Source 
@(objc_type=ProcessInfo)
@(objc_name="enableSuddenTermination")
ProcessInfo_enableSuddenTermination :: proc "c" (self: ^ProcessInfo) {…}

ProcessInfo_fullUserName #

Source 
@(objc_type=ProcessInfo)
@(objc_name="fullUserName")
ProcessInfo_fullUserName :: proc "c" (self: ^ProcessInfo) -> ^String {…}

ProcessInfo_globallyUniqueString #

Source 
@(objc_type=ProcessInfo)
@(objc_name="globallyUniqueString")
ProcessInfo_globallyUniqueString :: proc "c" (self: ^ProcessInfo) -> ^String {…}

ProcessInfo_isiOSAppOnMac #

Source 
@(objc_type=ProcessInfo)
@(objc_name="isiOSAppOnMac")
ProcessInfo_isiOSAppOnMac :: proc "c" (self: ^ProcessInfo) -> bool {…}

ProcessInfo_isLowPowerModeEnabled #

Source 
@(objc_type=ProcessInfo)
@(objc_name="isLowPowerModeEnabled")
ProcessInfo_isLowPowerModeEnabled :: proc "c" (self: ^ProcessInfo) -> bool {…}

ProcessInfo_isMacCatalystApp #

Source 
@(objc_type=ProcessInfo)
@(objc_name="isMacCatalystApp")
ProcessInfo_isMacCatalystApp :: proc "c" (self: ^ProcessInfo) -> bool {…}

ProcessInfo_operatingSystemVersionString #

Source 
@(objc_type=ProcessInfo)
@(objc_name="operatingSystemVersionString")
ProcessInfo_operatingSystemVersionString :: proc "c" (self: ^ProcessInfo) -> ^String {…}

ProcessInfo_performActivityWithOptions #

Source 
@(objc_type=ProcessInfo)
@(objc_name="performActivityWithOptions")
ProcessInfo_performActivityWithOptions :: proc "c" (self: ^ProcessInfo, options: bit_set[ActivityOptionsBits], reason: ^String, block: proc "c" ()) {…}

ProcessInfo_performExpiringActivityWithReason #

Source 
@(objc_type=ProcessInfo)
@(objc_name="performExpiringActivityWithReason")
ProcessInfo_performExpiringActivityWithReason :: proc "c" (self: ^ProcessInfo, reason: ^String, block: proc "c" (expired: bool)) {…}

ProcessInfo_physicalMemory #

Source 
@(objc_type=ProcessInfo)
@(objc_name="physicalMemory")
ProcessInfo_physicalMemory :: proc "c" (self: ^ProcessInfo) -> u64 {…}

ProcessInfo_processIdentifier #

Source 
@(objc_type=ProcessInfo)
@(objc_name="processIdentifier")
ProcessInfo_processIdentifier :: proc "c" (self: ^ProcessInfo) -> i32 {…}

ProcessInfo_processInfo #

Source 
@(objc_type=ProcessInfo)
@(objc_name="processInfo")
@(objc_is_class_method=true)
ProcessInfo_processInfo :: proc "c" () -> ^ProcessInfo {…}

ProcessInfo_processName #

Source 
@(objc_type=ProcessInfo)
@(objc_name="processName")
ProcessInfo_processName :: proc "c" (self: ^ProcessInfo) -> ^String {…}

ProcessInfo_processorCount #

Source 
@(objc_type=ProcessInfo)
@(objc_name="processorCount")
ProcessInfo_processorCount :: proc "c" (self: ^ProcessInfo) -> UInteger {…}

ProcessInfo_setAutomaticTerminationSupportEnabled #

Source 
@(objc_type=ProcessInfo)
@(objc_name="setAutomaticTerminationSupportEnabled")
ProcessInfo_setAutomaticTerminationSupportEnabled :: proc "c" (self: ^ProcessInfo, automaticTerminationSupportEnabled: bool) {…}

register_subclass #

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

release #

Source 
@(objc_type=Object)
@(objc_name="release")
release :: proc "c" (self: ^Object) {…}

RunLoop_addTimerForMode #

Source 
@(objc_type=RunLoop)
@(objc_name="addTimerForMode")
RunLoop_addTimerForMode :: proc(self: ^RunLoop, timer: ^Timer, forMode: ^String) {…}

RunLoop_mainRunLoop #

Source 
@(objc_type=RunLoop)
@(objc_name="mainRunLoop")
@(objc_is_class_method=true)
RunLoop_mainRunLoop :: proc() -> ^RunLoop {…}

RunningApplication_currentApplication #

Source 
@(objc_type=RunningApplication)
@(objc_name="currentApplication")
@(objc_is_class_method=true)
RunningApplication_currentApplication :: proc "c" () -> ^RunningApplication {…}

RunningApplication_finishedLaunching #

Source 
@(objc_type=RunningApplication)
@(objc_name="finishedLaunching")
RunningApplication_finishedLaunching :: proc "c" (self: ^RunningApplication) -> bool {…}

RunningApplication_localizedName #

Source 
@(objc_type=RunningApplication)
@(objc_name="localizedName")
RunningApplication_localizedName :: proc "c" (self: ^RunningApplication) -> ^String {…}

SavePanel_savePanel #

Source 
@(objc_type=SavePanel)
@(objc_name="savePanel")
@(objc_is_class_method=true)
SavePanel_savePanel :: proc "c" () -> ^SavePanel {…}

Screen_backingScaleFactor #

Source 
@(objc_type=Screen)
@(objc_name="backingScaleFactor")
Screen_backingScaleFactor :: proc "c" (self: ^Screen) -> CGFloat {…}

Screen_deepestScreen #

Source 
@(objc_type=Screen)
@(objc_name="deepestScreen")
@(objc_is_class_method=true)
Screen_deepestScreen :: proc "c" () -> ^Screen {…}

Screen_mainScreen #

Source 
@(objc_type=Screen)
@(objc_name="mainScreen")
@(objc_is_class_method=true)
Screen_mainScreen :: proc "c" () -> ^Screen {…}

Screen_screens #

Source 
@(objc_type=Screen)
@(objc_name="screens")
@(objc_is_class_method=true)
Screen_screens :: proc "c" () -> ^Array {…}

Screen_screensHaveSeparateSpaces #

Source 
@(objc_type=Screen)
@(objc_name="screensHaveSeparateSpaces")
@(objc_is_class_method=true)
Screen_screensHaveSeparateSpaces :: proc "c" () -> bool {…}

Screen_visibleFrame #

Source 
@(objc_type=Screen)
@(objc_name="visibleFrame")
Screen_visibleFrame :: proc "c" (self: ^Screen) -> CGRect {…}

Set_alloc #

Source 
@(objc_type=Set)
@(objc_name="alloc")
@(objc_is_class_method=true)
Set_alloc :: proc "c" () -> ^Set {…}

Set_init #

Source 
@(objc_type=Set)
@(objc_name="init")
Set_init :: proc "c" (self: ^Set) -> ^Set {…}

Set_initWithCoder #

Source 
@(objc_type=Set)
@(objc_name="initWithCoder")
Set_initWithCoder :: proc "c" (self: ^Set, coder: ^Coder) -> ^Set {…}

Set_initWithObjects #

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

String_alloc #

Source 
@(objc_type=String)
@(objc_name="alloc")
@(objc_is_class_method=true)
String_alloc :: proc "c" () -> ^String {…}

String_initWithOdinString #

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

String_initWithString #

Source 
@(objc_type=String)
@(objc_name="initWithString")
String_initWithString :: proc "c" (self: ^String, other: ^String) -> ^String {…}

String_isEqualToString #

Source 
@(objc_type=String)
@(objc_name="isEqualToString")
String_isEqualToString :: proc "c" (self: ^String, other: ^String) -> bool {…}

String_lengthOfBytesUsingEncoding #

Source 
@(objc_type=String)
@(objc_name="lengthOfBytesUsingEncoding")
String_lengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_maximumLengthOfBytesUsingEncoding #

Source 
@(objc_type=String)
@(objc_name="maximumLengthOfBytesUsingEncoding")
String_maximumLengthOfBytesUsingEncoding :: proc "c" (self: ^String, encoding: StringEncoding) -> UInteger {…}

String_odinString #

Source 
@(objc_type=String)
@(objc_name="odinString")
String_odinString :: proc "c" (self: ^String) -> string {…}

String_stringByAppendingString #

Source 
@(objc_type=String)
@(objc_name="stringByAppendingString")
String_stringByAppendingString :: proc "c" (self: ^String, other: ^String) -> ^String {…}

String_UTF8String #

Source 
@(objc_type=String)
@(objc_name="UTF8String")
String_UTF8String :: proc "c" (self: ^String) -> cstring {…}

StringFromSelector #

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

Timer_scheduledTimerWithTimeIntervalRepeatsBlock #

Source 
@(objc_type=Timer)
@(objc_name="scheduledTimerWithTimeIntervalRepeatsBlock")
@(objc_is_class_method=true)
Timer_scheduledTimerWithTimeIntervalRepeatsBlock :: proc(interval: TimeInterval, repeats: bool, block: ^Block) -> ^Timer {…}

Timer_scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat #

Source 
@(objc_type=Timer)
@(objc_name="scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat")
@(objc_is_class_method=true)
Timer_scheduledTimerWithTimeIntervalTargetSelectorUserInfoRepeat :: proc(interval: TimeInterval, aTarget: ^objc_object, aSelector: ^objc_selector, userInfo: ^objc_object, repeats: bool) -> ^Timer {…}

Toolbar_alloc #

Source 
@(objc_type=Toolbar)
@(objc_name="alloc")
@(objc_is_class_method=true)
Toolbar_alloc :: proc "c" () -> ^Toolbar {…}

URL_alloc #

Source 
@(objc_type=URL)
@(objc_name="alloc")
@(objc_is_class_method=true)
URL_alloc :: proc "c" () -> ^URL {…}

URL_fileSystemRepresentation #

Source 
@(objc_type=URL)
@(objc_name="fileSystemRepresentation")
URL_fileSystemRepresentation :: proc "c" (self: ^URL) -> cstring {…}

URL_init #

Source 
@(objc_type=URL)
@(objc_name="init")
URL_init :: proc "c" (self: ^URL) -> ^URL {…}

URL_initFileURLWithPath #

Source 
@(objc_type=URL)
@(objc_name="initFileURLWithPath")
URL_initFileURLWithPath :: proc "c" (self: ^URL, path: ^String) -> ^URL {…}

URL_initWithString #

Source 
@(objc_type=URL)
@(objc_name="initWithString")
URL_initWithString :: proc "c" (self: ^URL, value: ^String) -> ^URL {…}

URL_relativePath #

Source 
@(objc_type=URL)
@(objc_name="relativePath")
URL_relativePath :: proc "c" (self: ^URL) -> ^String {…}

URLRequest_alloc #

Source 
@(objc_type=URLRequest)
@(objc_name="alloc")
@(objc_is_class_method=true)
URLRequest_alloc :: proc "c" () -> ^URLRequest {…}

URLRequest_requestWithURL #

Source 
@(objc_type=URLRequest)
@(objc_name="requestWithURL")
@(objc_is_class_method=true)
URLRequest_requestWithURL :: proc "c" (url: ^URL) -> ^URLRequest {…}

URLResponse_alloc #

Source 
@(objc_type=URLResponse)
@(objc_name="alloc")
@(objc_is_class_method=true)
URLResponse_alloc :: proc "c" () -> ^URLResponse {…}

UserDefaults_setBoolForKey #

Source 
@(objc_type=UserDefaults)
@(objc_name="setBoolForKey")
UserDefaults_setBoolForKey :: proc "c" (self: ^UserDefaults, value: bool, name: ^String) {…}

UserDefaults_standardUserDefaults #

Source 
@(objc_type=UserDefaults)
@(objc_name="standardUserDefaults")
@(objc_is_class_method=true)
UserDefaults_standardUserDefaults :: proc "c" () -> ^UserDefaults {…}

Value_alloc #

Source 
@(objc_type=Value)
@(objc_name="alloc")
@(objc_is_class_method=true)
Value_alloc :: proc "c" () -> ^Value {…}

Value_initWithCoder #

Source 
@(objc_type=Value)
@(objc_name="initWithCoder")
Value_initWithCoder :: proc "c" (self: ^Value, coder: ^Coder) -> ^Value {…}

Value_isEqualToValue #

Source 
@(objc_type=Value)
@(objc_name="isEqualToValue")
Value_isEqualToValue :: proc "c" (self, other: ^Value) -> bool {…}

Value_pointerValue #

Source 
@(objc_type=Value)
@(objc_name="pointerValue")
Value_pointerValue :: proc "c" (self: ^Value) -> rawptr {…}

Value_valueWithBytes #

Source 
@(objc_type=Value)
@(objc_name="valueWithBytes")
@(objc_is_class_method=true)
Value_valueWithBytes :: proc "c" (value: rawptr, type: cstring) -> ^Value {…}

Value_valueWithPointer #

Source 
@(objc_type=Value)
@(objc_name="valueWithPointer")
@(objc_is_class_method=true)
Value_valueWithPointer :: proc "c" (pointer: rawptr) -> ^Value {…}

View_addSubview #

Source 
@(objc_type=View)
@(objc_name="addSubview")
View_addSubview :: proc "c" (self: ^View, view: ^View) {…}

View_alloc #

Source 
@(objc_type=View)
@(objc_name="alloc")
@(objc_is_class_method=true)
View_alloc :: proc "c" () -> ^View {…}

View_convertPointFromView #

Source 
@(objc_type=View)
@(objc_name="convertPointFromView")
View_convertPointFromView :: proc "c" (self: ^View, point: CGPoint, view: ^View) -> CGPoint {…}

View_initWithFrame #

Source 
@(objc_type=View)
@(objc_name="initWithFrame")
View_initWithFrame :: proc "c" (self: ^View, frame: CGRect) -> ^View {…}

View_isFlipped #

Source 
@(objc_type=View)
@(objc_name="isFlipped")
View_isFlipped :: proc "c" (self: ^View) -> bool {…}

View_setIsFlipped #

Source 
@(objc_type=View)
@(objc_name="setIsFlipped")
View_setIsFlipped :: proc "c" (self: ^View, flipped: bool) {…}

View_setLayer #

Source 
@(objc_type=View)
@(objc_name="setLayer")
View_setLayer :: proc "c" (self: ^View, layer: ^Layer) {…}

View_setWantsLayer #

Source 
@(objc_type=View)
@(objc_name="setWantsLayer")
View_setWantsLayer :: proc "c" (self: ^View, wantsLayer: bool) {…}

View_wantsLayer #

Source 
@(objc_type=View)
@(objc_name="wantsLayer")
View_wantsLayer :: proc "c" (self: ^View) -> bool {…}

Window_alloc #

Source 
@(objc_type=Window)
@(objc_name="alloc")
@(objc_is_class_method=true)
Window_alloc :: proc "c" () -> ^Window {…}

Window_backgroundColor #

Source 
@(objc_type=Window)
@(objc_name="backgroundColor")
Window_backgroundColor :: proc "c" (self: ^Window) -> ^Color {…}

Window_backingScaleFactor #

Source 
@(objc_type=Window)
@(objc_name="backingScaleFactor")
Window_backingScaleFactor :: proc "c" (self: ^Window) -> CGFloat {…}

Window_center #

Source 
@(objc_type=Window)
@(objc_name="center")
Window_center :: proc "c" (self: ^Window) {…}

Window_close #

Source 
@(objc_type=Window)
@(objc_name="close")
Window_close :: proc "c" (self: ^Window) {…}

Window_contentLayoutRect #

Source 
@(objc_type=Window)
@(objc_name="contentLayoutRect")
Window_contentLayoutRect :: proc "c" (self: ^Window) -> CGRect {…}

Window_contentRectForFrameRectInstance #

Source 
@(objc_type=Window)
@(objc_name="contentRectForFrameRect")
Window_contentRectForFrameRectInstance :: proc "c" (self: ^Window, frameRect: CGRect) -> CGRect {…}

Window_contentRectForFrameRectType #

Source 
@(objc_type=Window)
@(objc_name="contentRectForFrameRect")
@(objc_is_class_method=true)
Window_contentRectForFrameRectType :: proc "c" (frameRect: CGRect, styleMask: WindowStyleMask) -> CGRect {…}

Window_contentView #

Source 
@(objc_type=Window)
@(objc_name="contentView")
Window_contentView :: proc "c" (self: ^Window) -> ^View {…}

Window_convertPointFromBacking #

Source 
@(objc_type=Window)
@(objc_name="convertPointFromBacking")
Window_convertPointFromBacking :: proc "c" (self: ^Window, point: CGPoint) -> CGPoint {…}

Window_convertPointFromScreen #

Source 
@(objc_type=Window)
@(objc_name="convertPointFromScreen")
Window_convertPointFromScreen :: proc "c" (self: ^Window, point: CGPoint) -> CGPoint {…}

Window_convertPointToBacking #

Source 
@(objc_type=Window)
@(objc_name="convertPointToBacking")
Window_convertPointToBacking :: proc "c" (self: ^Window, point: CGPoint) -> CGPoint {…}

Window_convertPointToScreen #

Source 
@(objc_type=Window)
@(objc_name="convertPointToScreen")
Window_convertPointToScreen :: proc "c" (self: ^Window, point: CGPoint) -> CGPoint {…}

Window_convertRectFromBacking #

Source 
@(objc_type=Window)
@(objc_name="convertRectFromBacking")
Window_convertRectFromBacking :: proc "c" (self: ^Window, rect: CGRect) -> CGRect {…}

Window_convertRectFromScreen #

Source 
@(objc_type=Window)
@(objc_name="convertRectFromScreen")
Window_convertRectFromScreen :: proc "c" (self: ^Window, rect: CGRect) -> CGRect {…}

Window_convertRectToBacking #

Source 
@(objc_type=Window)
@(objc_name="convertRectToBacking")
Window_convertRectToBacking :: proc "c" (self: ^Window, rect: CGRect) -> CGRect {…}

Window_convertRectToScreen #

Source 
@(objc_type=Window)
@(objc_name="convertRectToScreen")
Window_convertRectToScreen :: proc "c" (self: ^Window, rect: CGRect) -> CGRect {…}

Window_frameRectForContentRectInstance #

Source 
@(objc_type=Window)
@(objc_name="frameRectForContentRect")
Window_frameRectForContentRectInstance :: proc "c" (self: ^Window, contentRect: CGRect) -> CGRect {…}

Window_frameRectForContentRectType #

Source 
@(objc_type=Window)
@(objc_name="frameRectForContentRect")
@(objc_is_class_method=true)
Window_frameRectForContentRectType :: proc "c" (contentRect: CGRect, styleMask: WindowStyleMask) -> CGRect {…}

Window_hasCloseBox #

Source 
@(objc_type=Window)
@(objc_name="hasCloseBox")
Window_hasCloseBox :: proc "c" (self: ^Window) -> bool {…}

Window_hasTitleBar #

Source 
@(objc_type=Window)
@(objc_name="hasTitleBar")
Window_hasTitleBar :: proc "c" (self: ^Window) -> bool {…}

Window_isFloatingPanel #

Source 
@(objc_type=Window)
@(objc_name="isFloatingPanel")
Window_isFloatingPanel :: proc "c" (self: ^Window) -> bool {…}

Window_isMiniaturizable #

Source 
@(objc_type=Window)
@(objc_name="isMiniaturizable")
Window_isMiniaturizable :: proc "c" (self: ^Window) -> bool {…}

Window_isModalPanel #

Source 
@(objc_type=Window)
@(objc_name="isModalPanel")
Window_isModalPanel :: proc "c" (self: ^Window) -> bool {…}

Window_isResizable #

Source 
@(objc_type=Window)
@(objc_name="isResizable")
Window_isResizable :: proc "c" (self: ^Window) -> bool {…}

Window_isZoomable #

Source 
@(objc_type=Window)
@(objc_name="isZoomable")
Window_isZoomable :: proc "c" (self: ^Window) -> bool {…}

Window_keyWindow #

Source 
@(objc_type=Window)
@(objc_name="keyWindow")
Window_keyWindow :: proc "c" (self: ^Window) -> bool {…}

Window_mainWindow #

Source 
@(objc_type=Window)
@(objc_name="mainWindow")
Window_mainWindow :: proc "c" (self: ^Window) -> bool {…}

Window_makeFirstResponder #

Source 
@(objc_type=Window)
@(objc_name="makeFirstResponder")
Window_makeFirstResponder :: proc "c" (self: ^Window, responder: ^Responder) -> bool {…}

Window_makeKeyAndOrderFront #

Source 
@(objc_type=Window)
@(objc_name="makeKeyAndOrderFront")
Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^Object) {…}

Window_minFrameWidthWithTitle #

Source 
@(objc_type=Window)
@(objc_name="minFrameWidthWithTitle")
@(objc_is_class_method=true)
Window_minFrameWidthWithTitle :: proc "c" (title: ^String, styleMask: WindowStyleMask) -> CGFloat {…}

Window_opaque #

Source 
@(objc_type=Window)
@(objc_name="opaque")
Window_opaque :: proc "c" (self: ^Window) -> bool {…}

Window_orderedIndex #

Source 
@(objc_type=Window)
@(objc_name="orderedIndex")
Window_orderedIndex :: proc "c" (self: ^Window) -> Integer {…}

Window_orderFront #

Source 
@(objc_type=Window)
@(objc_name="orderFront")
Window_orderFront :: proc "c" (self: ^Window, sender: ^objc_object) {…}

Window_orderOut #

Source 
@(objc_type=Window)
@(objc_name="orderOut")
Window_orderOut :: proc "c" (self: ^Window, sender: ^objc_object) {…}

Window_parentWindow #

Source 
@(objc_type=Window)
@(objc_name="parentWindow")
Window_parentWindow :: proc "c" (self: ^Window) -> ^Window {…}

Window_performClose #

Source 
@(objc_type=Window)
@(objc_name="performClose")
Window_performClose :: proc "c" (self: ^Window, sender: ^objc_object) {…}

Window_performWindowDragWithEvent #

Source 
@(objc_type=Window)
@(objc_name="performWindowDragWithEvent")
Window_performWindowDragWithEvent :: proc "c" (self: ^Window, event: ^Event) {…}

Window_performZoom #

Source 
@(objc_type=Window)
@(objc_name="performZoom")
Window_performZoom :: proc "c" (self: ^Window) {…}

Window_setAcceptsMouseMovedEvents #

Source 
@(objc_type=Window)
@(objc_name="setAcceptsMouseMovedEvents")
Window_setAcceptsMouseMovedEvents :: proc "c" (self: ^Window, ok: bool) {…}

Window_setBackgroundColor #

Source 
@(objc_type=Window)
@(objc_name="setBackgroundColor")
Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^Color) {…}

Window_setContentView #

Source 
@(objc_type=Window)
@(objc_name="setContentView")
Window_setContentView :: proc "c" (self: ^Window, content_view: ^View) {…}

Window_setFrameOrigin #

Source 
@(objc_type=Window)
@(objc_name="setFrameOrigin")
Window_setFrameOrigin :: proc "c" (self: ^Window, origin: CGPoint) {…}

Window_setIsMiniaturized #

Source 
@(objc_type=Window)
@(objc_name="setIsMiniaturized")
Window_setIsMiniaturized :: proc "c" (self: ^Window, ok: bool) {…}

Window_setIsVisible #

Source 
@(objc_type=Window)
@(objc_name="setIsVisible")
Window_setIsVisible :: proc "c" (self: ^Window, ok: bool) {…}

Window_setIsZoomed #

Source 
@(objc_type=Window)
@(objc_name="setIsZoomed")
Window_setIsZoomed :: proc "c" (self: ^Window, ok: bool) {…}

Window_setMinSize #

Source 
@(objc_type=Window)
@(objc_name="setMinSize")
Window_setMinSize :: proc "c" (self: ^Window, size: CGSize) {…}

Window_setMovable #

Source 
@(objc_type=Window)
@(objc_name="setMovable")
Window_setMovable :: proc "c" (self: ^Window, ok: bool) {…}

Window_setMovableByWindowBackground #

Source 
@(objc_type=Window)
@(objc_name="setMovableByWindowBackground")
Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: bool) {…}

Window_setOpaque #

Source 
@(objc_type=Window)
@(objc_name="setOpaque")
Window_setOpaque :: proc "c" (self: ^Window, ok: bool) {…}

Window_setReleasedWhenClosed #

Source 
@(objc_type=Window)
@(objc_name="setReleasedWhenClosed")
Window_setReleasedWhenClosed :: proc "c" (self: ^Window, flag: bool) {…}

Window_setRestorable #

Source 
@(objc_type=Window)
@(objc_name="setRestorable")
Window_setRestorable :: proc "c" (self: ^Window, flag: bool) {…}

Window_setTitle #

Source 
@(objc_type=Window)
@(objc_name="setTitle")
Window_setTitle :: proc "c" (self: ^Window, title: ^String) {…}

Window_setTitlebarAppearsTransparent #

Source 
@(objc_type=Window)
@(objc_name="setTitlebarAppearsTransparent")
Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: bool) {…}

Window_setToolbar #

Source 
@(objc_type=Window)
@(objc_name="setToolbar")
Window_setToolbar :: proc "c" (self: ^Window, toolbar: ^Toolbar) {…}

Window_setWantsLayer #

Source 
@(objc_type=Window)
@(objc_name="setWantsLayer")
Window_setWantsLayer :: proc "c" (self: ^Window, ok: bool) {…}

Window_toggleFullScreen #

Source 
@(objc_type=Window)
@(objc_name="toggleFullScreen")
Window_toggleFullScreen :: proc "c" (self: ^Window, sender: ^objc_object) {…}

Procedure Groups

8

Variables

22

KeyEventModifierFlagDeviceIndependentFlagsMask #

Source 
KeyEventModifierFlagDeviceIndependentFlagsMask: EventModifierFlags = transmute(KeyEquivalentModifierMask)_KeyEventModifierFlagDeviceIndependentFlagsMask

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

LocalizedRecoveryOptionsErrorKey #

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

LocalizedRecoverySuggestionErrorKey #

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