package core:sys/darwin/Foundation
Source

Warning: This was generated for -target:darwin_arm64 and might not represent every target this package supports.

⌘K
Ctrl+K
or
/

    Index

    Types (111)
    Constants (50)
    Procedures (491)
    Procedure Groups (1)

    Types

    ActivationPolicy ¶
    Source

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

    ActivityOptions ¶
    Source

    ActivityOptions :: bit_set[ActivityOptionsBits; u64]

    ActivityOptionsBits ¶
    Source

    ActivityOptionsBits :: enum u64 {
	IdleDisplaySleepDisabled             = 40, // Require the screen to stay powered on.
	IdleSystemSleepDisabled              = 20, // Prevent idle sleep.
	SuddenTerminationDisabled            = 14, // Prevent sudden termination.
	AutomaticTerminationDisabled         = 15, // Prevent automatic termination.
	AnimationTrackingEnabled             = 45, // Track activity with an animation signpost interval.
	TrackingEnabled                      = 46, // Track activity with a signpost interval.
	UserInitiated                        = 23, // Performing a user-requested action.
	UserInitiatedAllowingIdleSystemSleep = 23, // Performing a user-requested action, but the system can sleep on idle.
	Background                           = 7,  // Initiated some kind of work, but not as the direct result of a user request.
	LatencyCritical                      = 39, // Requires the highest amount of timer and I/O precision available.
	UserInteractive                      = 39, // Responding to user interaction.
}

    Application ¶
    Source

    Application :: struct {
	using _: Object,
}

    ApplicationDelegate ¶
    Source

    ApplicationDelegate :: struct {
	using _: Object,
}
    Related Procedures With Parameters
    Related Procedures With Returns
    Procedures Through `using` From Object
    Procedures Through `using` From objc_object

    ApplicationDelegateTemplate ¶
    Source

    ApplicationDelegateTemplate :: struct {
	// Launching Applications
	applicationWillFinishLaunching:                              proc(notification: ^Notification),
	applicationDidFinishLaunching:                               proc(notification: ^Notification),
	// Managing Active Status
	applicationWillBecomeActive:                                 proc(notification: ^Notification),
	applicationDidBecomeActive:                                  proc(notification: ^Notification),
	applicationWillResignActive:                                 proc(notification: ^Notification),
	applicationDidResignActive:                                  proc(notification: ^Notification),
	// Terminating Applications
	applicationShouldTerminate:                                  proc(sender: ^Application) -> ApplicationTerminateReply,
	applicationShouldTerminateAfterLastWindowClosed:             proc(sender: ^Application) -> bool,
	applicationWillTerminate:                                    proc(notification: ^Notification),
	// Hiding Applications
	applicationWillHide:                                         proc(notification: ^Notification),
	applicationDidHide:                                          proc(notification: ^Notification),
	applicationWillUnhide:                                       proc(notification: ^Notification),
	applicationDidUnhide:                                        proc(notification: ^Notification),
	// Managing Windows
	applicationWillUpdate:                                       proc(notification: ^Notification),
	applicationDidUpdate:                                        proc(notification: ^Notification),
	applicationShouldHandleReopenHasVisibleWindows:              proc(sender: ^Application, flag: bool) -> bool,
	// Managing the Dock Menu
	applicationDockMenu:                                         proc(sender: ^Application) -> ^Menu,
	// Localizing Keyboard Shortcuts
	applicationShouldAutomaticallyLocalizeKeyEquivalents:        proc(application: ^Application) -> bool,
	// Displaying Errors
	applicationWillPresentError:                                 proc(application: ^Application, error: ^Error) -> ^Error,
	// Managing the Screen
	applicationDidChangeScreenParameters:                        proc(notification: ^Notification),
	// Continuing User Activities
	applicationWillContinueUserActivityWithType:                 proc(application: ^Application, userActivityType: ^String) -> bool,
	applicationContinueUserActivityRestorationHandler:           proc(application: ^Application, userActivity: ^UserActivity, restorationHandler: ^Block) -> bool,
	applicationDidFailToContinueUserActivityWithTypeError:       proc(application: ^Application, userActivityType: ^String, error: ^Error),
	applicationDidUpdateUserActivity:                            proc(application: ^Application, userActivity: ^UserActivity),
	// Handling Push Notifications
	applicationDidRegisterForRemoteNotificationsWithDeviceToken: proc(application: ^Application, deviceToken: ^Data),
	applicationDidFailToRegisterForRemoteNotificationsWithError: proc(application: ^Application, error: ^Error),
	applicationDidReceiveRemoteNotification:                     proc(application: ^Application, userInfo: ^Dictionary),
	// Handling CloudKit Invitations
	// TODO: if/when we have cloud kit bindings implement
	// applicationUserDidAcceptCloudKitShareWithMetadata:        proc(application: ^Application, metadata: ^CKShareMetadata),
	// Handling SiriKit Intents
	// TODO: if/when we have siri kit bindings implement
	// applicationHandlerForIntent:                              proc(application: ^Application, intent: ^INIntent) -> id,
	// Opening Files
	applicationOpenURLs:                                         proc(application: ^Application, urls: ^Array),
	applicationOpenFile:                                         proc(sender: ^Application, filename: ^String) -> bool,
	applicationOpenFileWithoutUI:                                proc(sender: ^.objc_object, filename: ^String) -> bool,
	applicationOpenTempFile:                                     proc(sender: ^Application, filename: ^String) -> bool,
	applicationOpenFiles:                                        proc(sender: ^Application, filenames: ^Array),
	applicationShouldOpenUntitledFile:                           proc(sender: ^Application) -> bool,
	applicationOpenUntitledFile:                                 proc(sender: ^Application) -> bool,
	// Printing
	applicationPrintFile:                                        proc(sender: ^Application, filename: ^String) -> bool,
	applicationPrintFilesWithSettingsShowPrintPanels:            proc(application: ^Application, fileNames: ^Array, printSettings: ^Dictionary, showPrintPanels: bool) -> ApplicationPrintReply,
	// Restoring Application State
	applicationSupportsSecureRestorableState:                    proc(app: ^Application) -> bool,
	applicationProtectedDataDidBecomeAvailable:                  proc(notification: ^Notification),
	applicationProtectedDataWillBecomeUnavailable:               proc(notification: ^Notification),
	applicationWillEncodeRestorableState:                        proc(app: ^Application, coder: ^Coder),
	applicationDidDecodeRestorableState:                         proc(app: ^Application, coder: ^Coder),
	// Handling Changes to the Occlusion State
	applicationDidChangeOcclusionState:                          proc(notification: ^Notification),
	// Scripting Your App
	applicationDelegateHandlesKey:                               proc(sender: ^Application, key: ^String) -> bool,
}
    Related Procedures With Parameters

    ApplicationPresentationOptionFlag ¶
    Source

    ApplicationPresentationOptionFlag :: enum UInteger {
	AutoHideDock                    = 0, 
	HideDock                        = 1, 
	AutoHideMenuBar                 = 2, 
	HideMenuBar                     = 3, 
	DisableAppleMenu                = 4, 
	DisableProcessSwitching         = 5, 
	DisableForceQuit                = 6, 
	DisableSessionTermination       = 7, 
	DisableHideApplication          = 8, 
	DisableMenuBarTransparency      = 9, 
	FullScreen                      = 10, 
	AutoHideToolbar                 = 11, 
	DisableCursorLocationAssistance = 12, 
}

    ApplicationPresentationOptions ¶
    Source

    ApplicationPresentationOptions :: distinct bit_set[ApplicationPresentationOptionFlag; UInteger]
    Related Constants

    ApplicationPrintReply ¶
    Source

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

    ApplicationTerminateReply ¶
    Source

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

    Array ¶
    Source

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

    AutoreleasePool ¶
    Source

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

    BOOL ¶
    Source

    BOOL :: bool
     

    TODO(bill): should this be distinct?

    BackingStoreType ¶
    Source

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

    Block ¶
    Source

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

    Bundle ¶
    Source

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

    Class ¶
    Source

    Class :: ^.objc_class

    Coder ¶
    Source

    Coder :: struct {
	using _: Object,
}

    Color ¶
    Source

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

    ColorSpace ¶
    Source

    ColorSpace :: struct {
	using _: Object,
}

    ComparisonResult ¶
    Source

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

    Condition ¶
    Source

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

    Copying ¶
    Source

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

    Data ¶
    Source

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

    Date ¶
    Source

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

    Depth ¶
    Source

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

    Dictionary ¶
    Source

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

    Enumerator ¶
    Source

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

    Error ¶
    Source

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

    ErrorDomain ¶
    Source

    ErrorDomain :: ^String

    ErrorUserInfoKey ¶
    Source

    ErrorUserInfoKey :: ^String

    Event ¶
    Source

    Event :: struct {
	using _: Object,
}

    EventMask ¶
    Source

    EventMask :: distinct bit_set[EventType; UInteger]
    Related Procedures With Parameters
    Related Constants

    EventModifierFlag ¶
    Source

    EventModifierFlag :: enum UInteger {
	CapsLock   = 16, 
	Shift      = 17, 
	Control    = 18, 
	Option     = 19, 
	Command    = 20, 
	NumericPad = 21, 
	Help       = 22, 
	Function   = 23, 
}

    EventModifierFlags ¶
    Source

    EventModifierFlags :: distinct bit_set[EventModifierFlag; UInteger]
    Related Procedures With Returns
    Related Constants

    EventPhase ¶
    Source

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

    EventPhaseFlag ¶
    Source

    EventPhaseFlag :: enum UInteger {
	Began      = 0, 
	Stationary = 1, 
	Changed    = 2, 
	Ended      = 3, 
	Cancelled  = 4, 
	MayBegin   = 5, 
}

    EventType ¶
    Source

    EventType :: enum UInteger {
	LeftMouseDown      = 1, 
	LeftMouseUp        = 2, 
	RightMouseDown     = 3, 
	RightMouseUp       = 4, 
	MouseMoved         = 5, 
	LeftMouseDragged   = 6, 
	RightMouseDragged  = 7, 
	MouseEntered       = 8, 
	MouseExited        = 9, 
	KeyDown            = 10, 
	KeyUp              = 11, 
	FlagsChanged       = 12, 
	AppKitDefined      = 13, 
	SystemDefined      = 14, 
	ApplicationDefined = 15, 
	Periodic           = 16, 
	CursorUpdate       = 17, 
	Rotate             = 18, 
	BeginGesture       = 19, 
	EndGesture         = 20, 
	ScrollWheel        = 22, 
	TabletPoint        = 23, 
	TabletProximity    = 24, 
	OtherMouseDown     = 25, 
	OtherMouseUp       = 26, 
	OtherMouseDragged  = 27, 
	Gesture            = 29, 
	Magnify            = 30, 
	Swipe              = 31, 
	SmartMagnify       = 32, 
	QuickLook          = 33, 
	Pressure           = 34, 
	DirectTouch        = 37, 
	ChangeMode         = 38, 
}
    Related Procedures With Returns

    FastEnumeration ¶
    Source

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

    FastEnumerationState ¶
    Source

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

    Float ¶
    Source

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

    IMP ¶
    Source

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

    Integer ¶
    Source

    Integer :: distinct int
    Related Procedures With Parameters
    Related Procedures With Returns
    Related Constants

    Ivar ¶
    Source

    Ivar :: ^objc_ivar

    KeyEquivalentModifierFlag ¶
    Source

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

    KeyEquivalentModifierMask ¶
    Source

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

    Layer ¶
    Source

    Layer :: struct {
	using _: Object,
}

    Locking ¶
    Source

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

    Method ¶
    Source

    Method :: ^objc_method

    ModalResponse ¶
    Source

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

    Notification ¶
    Source

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

    NotificationCenter ¶
    Source

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

    NotificationName ¶
    Source

    NotificationName :: ^String

    Number ¶
    Source

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

    Object ¶
    Source

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

    ObjectProtocol ¶
    Source

    ObjectProtocol :: struct {
	using _: Object,
}

    OpenPanel ¶
    Source

    OpenPanel :: struct {
	using _: SavePanel,
}
    Bound Objective-C Methods
    Methods Inherited From SavePanel
    Methods Inherited From Window
    Methods Inherited From Object

    OperatingSystemVersion ¶
    Source

    OperatingSystemVersion :: struct #align (8) {
	majorVersion: Integer,
	minorVersion: Integer,
	patchVersion: Integer,
}
    Related Procedures With Parameters
    Related Procedures With Returns

    Panel ¶
    Source

    Panel :: struct {
	using _: Window,
}

    Pasteboard ¶
    Source

    Pasteboard :: struct {
	using _: Object,
}

    Point ¶
    Source

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

    PointingDeviceType ¶
    Source

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

    pointer types for NSTabletProximity events or mouse events with subtype NSTabletProximityEventSubtype

    Related Procedures With Returns

    ProcessInfo ¶
    Source

    ProcessInfo :: struct {
	using _: Object,
}

    ProcessInfoThermalState ¶
    Source

    ProcessInfoThermalState :: enum i32 {
	Nominal, 
	Fair, 
	Serious, 
	Critical, 
}
    Related Procedures With Returns

    Protocol ¶
    Source

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

    Range ¶
    Source

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

    Rect ¶
    Source

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

    Responder ¶
    Source

    Responder :: struct {
	using _: Object,
}

    RunLoopMode ¶
    Source

    RunLoopMode :: ^String

    RunningApplication ¶
    Source

    RunningApplication :: struct {
	using _: Object,
}

    SEL ¶
    Source

    SEL :: ^.objc_selector

    SavePanel ¶
    Source

    SavePanel :: struct {
	using _: Panel,
}

    Screen ¶
    Source

    Screen :: struct {
	using _: Object,
}

    Set ¶
    Source

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

    Size ¶
    Source

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

    String ¶
    Source

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

    StringCompareOption ¶
    Source

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

    StringCompareOptions ¶
    Source

    StringCompareOptions :: distinct bit_set[StringCompareOption; UInteger]
    Related Procedures With Parameters

    StringEncoding ¶
    Source

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

    TimeInterval ¶
    Source

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

    UInteger ¶
    Source

    UInteger :: distinct uint
    Related Procedures With Parameters
    Related Procedures With Returns
    Related Constants

    URL ¶
    Source

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

    UndoManager ¶
    Source

    UndoManager :: struct {
	using _: Object,
}

    UserActivity ¶
    Source

    UserActivity :: struct {
	using _: Object,
}

    UserDefaults ¶
    Source

    UserDefaults :: struct {
	using _: Object,
}

    Value ¶
    Source

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

    View ¶
    Source

    View :: struct {
	using _: Responder,
}

    Window ¶
    Source

    Window :: struct {
	using _: Responder,
}

    WindowDelegate ¶
    Source

    WindowDelegate :: struct {
	using _: Object,
}
     

    This is not the same as NSWindowDelegate

    Related Procedures With Parameters
    Related Procedures With Returns
    Procedures Through `using` From Object
    Procedures Through `using` From objc_object

    WindowDelegateTemplate ¶
    Source

    WindowDelegateTemplate :: struct {
	// Managing Sheets
	windowWillPositionSheetUsingRect:                                    proc(window: ^Window, sheet: ^Window, rect: Rect) -> Rect,
	windowWillBeginSheet:                                                proc(notification: ^Notification),
	windowDidEndSheet:                                                   proc(notification: ^Notification),
	// Sizing Windows
	windowWillResizeToSize:                                              proc(sender: ^Window, frameSize: Size) -> Size,
	windowDidResize:                                                     proc(notification: ^Notification),
	windowWillStartLiveResize:                                           proc(noitifcation: ^Notification),
	windowDidEndLiveResize:                                              proc(notification: ^Notification),
	// Minimizing Windows
	windowWillMiniaturize:                                               proc(notification: ^Notification),
	windowDidMiniaturize:                                                proc(notification: ^Notification),
	windowDidDeminiaturize:                                              proc(notification: ^Notification),
	// Zooming window
	windowWillUseStandardFrameDefaultFrame:                              proc(window: ^Window, newFrame: Rect) -> Rect,
	windowShouldZoomToFrame:                                             proc(window: ^Window, newFrame: Rect) -> bool,
	// Managing Full-Screen Presentation
	windowWillUseFullScreenContentSize:                                  proc(window: ^Window, proposedSize: Size) -> Size,
	windowWillUseFullScreenPresentationOptions:                          proc(window: ^Window, proposedOptions: ApplicationPresentationOptions) -> ApplicationPresentationOptions,
	windowWillEnterFullScreen:                                           proc(notification: ^Notification),
	windowDidEnterFullScreen:                                            proc(notification: ^Notification),
	windowWillExitFullScreen:                                            proc(notification: ^Notification),
	windowDidExitFullScreen:                                             proc(notification: ^Notification),
	// Custom Full-Screen Presentation Animations
	customWindowsToEnterFullScreenForWindow:                             proc(window: ^Window) -> ^Array,
	customWindowsToEnterFullScreenForWindowOnScreen:                     proc(window: ^Window, screen: ^Screen) -> ^Array,
	windowStartCustomAnimationToEnterFullScreenWithDuration:             proc(window: ^Window, duration: TimeInterval),
	windowStartCustomAnimationToEnterFullScreenOnScreenWithDuration:     proc(window: ^Window, screen: ^Screen, duration: TimeInterval),
	windowDidFailToEnterFullScreen:                                      proc(window: ^Window),
	customWindowsToExitFullScreenForWindow:                              proc(window: ^Window) -> ^Array,
	windowStartCustomAnimationToExitFullScreenWithDuration:              proc(window: ^Window, duration: TimeInterval),
	windowDidFailToExitFullScreen:                                       proc(window: ^Window),
	// Moving Windows
	windowWillMove:                                                      proc(notification: ^Notification),
	windowDidMove:                                                       proc(notification: ^Notification),
	windowDidChangeScreen:                                               proc(notification: ^Notification),
	windowDidChangeScreenProfile:                                        proc(notification: ^Notification),
	windowDidChangeBackingProperties:                                    proc(notification: ^Notification),
	// Closing Windows
	windowShouldClose:                                                   proc(sender: ^Window) -> bool,
	windowWillClose:                                                     proc(notification: ^Notification),
	// Managing Key Status
	windowDidBecomeKey:                                                  proc(notification: ^Notification),
	windowDidResignKey:                                                  proc(notification: ^Notification),
	// Managing Main Status
	windowDidBecomeMain:                                                 proc(notification: ^Notification),
	windowDidResignMain:                                                 proc(notification: ^Notification),
	// Managing Field Editors
	windowWillReturnFieldEditorToObject:                                 proc(sender: ^Window, client: ^.objc_object) -> ^.objc_object,
	// Updating Windows
	windowDidUpdate:                                                     proc(notification: ^Notification),
	// Exposing Windows
	windowDidExpose:                                                     proc(notification: ^Notification),
	// Managing Occlusion State
	windowDidChangeOcclusionState:                                       proc(notification: ^Notification),
	// Dragging Windows
	windowShouldDragDocumentWithEventFromWithPasteboard:                 proc(window: ^Window, event: ^Event, dragImageLocation: Point, pasteboard: ^Pasteboard) -> bool,
	// Getting the Undo Manager
	windowWillReturnUndoManager:                                         proc(window: ^Window) -> ^UndoManager,
	// Managing Titles
	windowShouldPopUpDocumentPathMenu:                                   proc(window: ^Window, menu: ^Menu) -> bool,
	// Managing Restorable State
	windowWillEncodeRestorableState:                                     proc(window: ^Window, state: ^Coder),
	windowDidEncodeRestorableState:                                      proc(window: ^Window, state: ^Coder),
	// Managing Presentation in Version Browsers
	windowWillResizeForVersionBrowserWithMaxPreferredSizeMaxAllowedSize: proc(window: ^Window, maxPreferredFrameSize: Size, maxAllowedFrameSize: Size) -> Size,
	windowWillEnterVersionBrowser:                                       proc(notification: ^Notification),
	windowDidEnterVersionBrowser:                                        proc(notification: ^Notification),
	windowWillExitVersionBrowser:                                        proc(notification: ^Notification),
	windowDidExitVersionBrowser:                                         proc(notification: ^Notification),
}
    Related Procedures With Parameters

    WindowStyleFlag ¶
    Source

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

    WindowStyleMask ¶
    Source

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

    Zone ¶
    Source

    Zone :: struct {
	using _: Object,
}

    id ¶
    Source

    id :: ^.objc_object

    kVK ¶
    Source

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

    Defined in Carbon.framework Events.h

    objc_AssociationPolicy ¶
    Source

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

    objc_cache ¶
    Source

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

    objc_class_internals ¶
    Source

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

    objc_ivar ¶
    Source

    objc_ivar :: struct {}
    Related Procedures With Parameters
    Related Procedures With Returns

    objc_ivar_list ¶
    Source

    objc_ivar_list :: struct {}

    objc_method ¶
    Source

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

    objc_method_list ¶
    Source

    objc_method_list :: struct {}

    objc_object_internals ¶
    Source

    objc_object_internals :: struct {
	isa: ^objc_class_internals,
}

    objc_property ¶
    Source

    objc_property :: struct {}
    Related Procedures With Parameters
    Related Procedures With Returns

    objc_property_attribute_t ¶
    Source

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

    objc_property_t ¶
    Source

    objc_property_t :: ^objc_property

    objc_protocol_list ¶
    Source

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

    unichar ¶
    Source

    unichar :: distinct u16
    Related Procedures With Returns

    Constants

    ApplicationPresentationOptionsAutoHideDock ¶
    Source

    ApplicationPresentationOptionsAutoHideDock :: ApplicationPresentationOptions{.AutoHideDock}

    ApplicationPresentationOptionsAutoHideMenuBar ¶
    Source

    ApplicationPresentationOptionsAutoHideMenuBar :: ApplicationPresentationOptions{.AutoHideMenuBar}

    ApplicationPresentationOptionsAutoHideToolbar ¶
    Source

    ApplicationPresentationOptionsAutoHideToolbar :: ApplicationPresentationOptions{.AutoHideToolbar}

    ApplicationPresentationOptionsDefault ¶
    Source

    ApplicationPresentationOptionsDefault :: ApplicationPresentationOptions{}

    ApplicationPresentationOptionsDisableAppleMenu ¶
    Source

    ApplicationPresentationOptionsDisableAppleMenu :: ApplicationPresentationOptions{.DisableAppleMenu}

    ApplicationPresentationOptionsDisableCursorLocationAssistance ¶
    Source

    ApplicationPresentationOptionsDisableCursorLocationAssistance :: ApplicationPresentationOptions{.DisableCursorLocationAssistance}

    ApplicationPresentationOptionsDisableForceQuit ¶
    Source

    ApplicationPresentationOptionsDisableForceQuit :: ApplicationPresentationOptions{.DisableForceQuit}

    ApplicationPresentationOptionsDisableHideApplication ¶
    Source

    ApplicationPresentationOptionsDisableHideApplication :: ApplicationPresentationOptions{.DisableHideApplication}

    ApplicationPresentationOptionsDisableMenuBarTransparency ¶
    Source

    ApplicationPresentationOptionsDisableMenuBarTransparency :: ApplicationPresentationOptions{.DisableMenuBarTransparency}

    ApplicationPresentationOptionsDisableProcessSwitching ¶
    Source

    ApplicationPresentationOptionsDisableProcessSwitching :: ApplicationPresentationOptions{.DisableProcessSwitching}

    ApplicationPresentationOptionsDisableSessionTermination ¶
    Source

    ApplicationPresentationOptionsDisableSessionTermination :: ApplicationPresentationOptions{.DisableSessionTermination}

    ApplicationPresentationOptionsFullScreen ¶
    Source

    ApplicationPresentationOptionsFullScreen :: ApplicationPresentationOptions{.FullScreen}

    ApplicationPresentationOptionsHideDock ¶
    Source

    ApplicationPresentationOptionsHideDock :: ApplicationPresentationOptions{.HideDock}

    ApplicationPresentationOptionsHideMenuBar ¶
    Source

    ApplicationPresentationOptionsHideMenuBar :: ApplicationPresentationOptions{.HideMenuBar}

    EventMaskAny ¶
    Source

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

    EventModifierFlagCapsLock ¶
    Source

    EventModifierFlagCapsLock :: EventModifierFlags{.CapsLock}

    EventModifierFlagCommand ¶
    Source

    EventModifierFlagCommand :: EventModifierFlags{.Command}

    EventModifierFlagControl ¶
    Source

    EventModifierFlagControl :: EventModifierFlags{.Control}

    EventModifierFlagDeviceIndependentFlagsMask ¶
    Source

    EventModifierFlagDeviceIndependentFlagsMask: UInteger : 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}

    EventPhaseBegan ¶
    Source

    EventPhaseBegan :: EventPhase{.Began}

    EventPhaseCancelled ¶
    Source

    EventPhaseCancelled :: EventPhase{.Cancelled}

    EventPhaseChanged ¶
    Source

    EventPhaseChanged :: EventPhase{.Changed}

    EventPhaseEnded ¶
    Source

    EventPhaseEnded :: EventPhase{.Ended}

    EventPhaseMayBegin ¶
    Source

    EventPhaseMayBegin :: EventPhase{.MayBegin}

    EventPhaseNone ¶
    Source

    EventPhaseNone :: EventPhase{}

    EventPhaseStationary ¶
    Source

    EventPhaseStationary :: EventPhase{.Stationary}

    IntegerMax ¶
    Source

    IntegerMax: Integer : max(Integer)

    Integermin ¶
    Source

    Integermin: Integer : min(Integer)

    NO ¶
    Source

    NO :: false

    NotFound ¶
    Source

    NotFound :: IntegerMax

    UIntegerMax ¶
    Source

    UIntegerMax: UInteger : max(UInteger)

    WindowStyleMaskBorderless ¶
    Source

    WindowStyleMaskBorderless :: WindowStyleMask{}

    WindowStyleMaskClosable ¶
    Source

    WindowStyleMaskClosable :: WindowStyleMask{.Closable}

    WindowStyleMaskDocModalWindow ¶
    Source

    WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow}

    WindowStyleMaskFullScreen ¶
    Source

    WindowStyleMaskFullScreen :: WindowStyleMask{.FullScreen}

    WindowStyleMaskFullSizeContentView ¶
    Source

    WindowStyleMaskFullSizeContentView :: WindowStyleMask{.FullSizeContentView}

    WindowStyleMaskHUDWindow ¶
    Source

    WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow}

    WindowStyleMaskMiniaturizable ¶
    Source

    WindowStyleMaskMiniaturizable :: WindowStyleMask{.Miniaturizable}

    WindowStyleMaskNonactivatingPanel ¶
    Source

    WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel}

    WindowStyleMaskResizable ¶
    Source

    WindowStyleMaskResizable :: WindowStyleMask{.Resizable}

    WindowStyleMaskTexturedBackground ¶
    Source

    WindowStyleMaskTexturedBackground :: WindowStyleMask{.TexturedBackground}

    WindowStyleMaskTitled ¶
    Source

    WindowStyleMaskTitled :: WindowStyleMask{.Titled}

    WindowStyleMaskUnifiedTitleAndToolbar ¶
    Source

    WindowStyleMaskUnifiedTitleAndToolbar :: WindowStyleMask{.UnifiedTitleAndToolbar}

    WindowStyleMaskUtilityWindow ¶
    Source

    WindowStyleMaskUtilityWindow :: WindowStyleMask{.UtilityWindow}

    YES ¶
    Source

    YES :: true

    Variables

    CocoaErrorDomain ¶
    Source

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

    DebugDescriptionErrorKey ¶
    Source

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

    DefaultRunLoopMode ¶
    Source

    DefaultRunLoopMode: ^String

    EventTrackingRunLoopMode ¶
    Source

    EventTrackingRunLoopMode: ^String

    FilePathErrorKey ¶
    Source

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

    HelpAnchorErrorKey ¶
    Source

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

    KeyEventModifierFlagDeviceIndependentFlagsMask ¶
    Source

    KeyEventModifierFlagDeviceIndependentFlagsMask: KeyEquivalentModifierMask = …
     

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

    LocalizedDescriptionKey ¶
    Source

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

    LocalizedFailureErrorKey ¶
    Source

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

    LocalizedFailureReasonErrorKey ¶
    Source

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

    LocalizedRecoveryOptionsErrorKey ¶
    Source

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

    LocalizedRecoverySuggestionErrorKey ¶
    Source

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

    MachErrorDomain ¶
    Source

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

    ModalPanelRunLoopMode ¶
    Source

    ModalPanelRunLoopMode: ^String

    OSStatusErrorDomain ¶
    Source

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

    POSIXErrorDomain ¶
    Source

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

    RecoveryAttempterErrorKey ¶
    Source

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

    RunLoopCommonModes ¶
    Source

    RunLoopCommonModes: ^String

    StringEncodingErrorKey ¶
    Source

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

    URLErrorKey ¶
    Source

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

    UnderlyingErrorKey ¶
    Source

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

    Procedures

    AT ¶
    Source

     

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

    AllocateObject ¶
    Source

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

    Application_activate ¶
    Source

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

    Application_activateIgnoringOtherApps ¶
    Source

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

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

    Application_currentEvent ¶
    Source

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

    Application_finishLaunching ¶
    Source

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

    Application_isRunning ¶
    Source

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

    Application_keyWindow ¶
    Source

    Application_keyWindow :: proc "c" (
	self: ^Application, 
) -> ^Window {…}
    Objective-C Method Information
    Syntax Usage
    res := self->keyWindow()

    Application_mainWindow ¶
    Source

    Application_mainWindow :: proc "c" (
	self: ^Application, 
) -> ^Window {…}
    Objective-C Method Information
    Syntax Usage
    res := self->mainWindow()

    Application_nextEventMatchingMask ¶
    Source

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

    Application_run ¶
    Source

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

    Application_sendEvent ¶
    Source

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

    Application_setActivationPolicy ¶
    Source

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

    Application_setDelegate ¶
    Source

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

    Application_setMainMenu ¶
    Source

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

    Application_setTitle ¶
    Source

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

    Application_sharedApplication ¶
    Source

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

    Application_terminate ¶
    Source

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

    Application_updateWindows ¶
    Source

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

    Application_windows ¶
    Source

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

    Array_alloc ¶
    Source

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

    Array_count ¶
    Source

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

    Array_init ¶
    Source

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

    Array_initWithCoder ¶
    Source

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

    Array_initWithObjects ¶
    Source

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

    Array_object ¶
    Source

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

    Array_objectAs ¶
    Source

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

    AutoreleasePool_addObject ¶
    Source

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

    AutoreleasePool_alloc ¶
    Source

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

    AutoreleasePool_drain ¶
    Source

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

    AutoreleasePool_init ¶
    Source

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

    AutoreleasePool_showPools ¶
    Source

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

    Block_createGlobal ¶
    Source

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

    Block_createGlobalWithParam ¶
    Source

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

    Block_createLocal ¶
    Source

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

    Block_createLocalWithParam ¶
    Source

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

    Bundle_PathForAuxiliaryExecutable ¶
    Source

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

    Bundle_URLForAuxiliaryExecutable ¶
    Source

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

    Bundle_allBundles ¶
    Source

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

    Bundle_allFrameworks ¶
    Source

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

    Bundle_alloc ¶
    Source

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

    Bundle_appStoreReceiptPath ¶
    Source

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

    Bundle_appStoreReceiptURL ¶
    Source

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

    Bundle_builtInPlugInsPath ¶
    Source

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

    Bundle_builtInPlugInsURL ¶
    Source

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

    Bundle_bundleIdentifier ¶
    Source

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

    Bundle_bundlePath ¶
    Source

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

    Bundle_bundleURL ¶
    Source

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

    Bundle_bundleWithPath ¶
    Source

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

    Bundle_bundleWithURL ¶
    Source

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

    Bundle_executablePath ¶
    Source

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

    Bundle_executableURL ¶
    Source

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

    Bundle_infoDictionary ¶
    Source

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

    Bundle_init ¶
    Source

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

    Bundle_initWithPath ¶
    Source

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

    Bundle_initWithURL ¶
    Source

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

    Bundle_isLoaded ¶
    Source

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

    Bundle_load ¶
    Source

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

    Bundle_loadAndReturnError ¶
    Source

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

    Bundle_localizedInfoDictionary ¶
    Source

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

    Bundle_localizedStringForKey ¶
    Source

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

    Bundle_mainBundle ¶
    Source

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

    Bundle_objectForInfoDictionaryKey ¶
    Source

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

    Bundle_preflightAndReturnError ¶
    Source

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

    Bundle_privateFrameworksPath ¶
    Source

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

    Bundle_privateFrameworksURL ¶
    Source

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

    Bundle_resourcePath ¶
    Source

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

    Bundle_resourceURL ¶
    Source

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

    Bundle_sharedFrameworksPath ¶
    Source

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

    Bundle_sharedFrameworksURL ¶
    Source

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

    Bundle_sharedSupportPath ¶
    Source

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

    Bundle_sharedSupportURL ¶
    Source

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

    Bundle_unload ¶
    Source

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

    ClassFromString ¶
    Source

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

    Color_blackColor ¶
    Source

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

    Color_blueColor ¶
    Source

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

    Color_colorSpace ¶
    Source

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

    Color_colorSpaceName ¶
    Source

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

    Color_colorUsingColorSpaceName ¶
    Source

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

    Color_colorWithCalibratedHue ¶
    Source

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

    Color_colorWithCalibratedRed ¶
    Source

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

    Color_colorWithCalibratedWhite ¶
    Source

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

    Color_colorWithColorSpace ¶
    Source

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

    Color_colorWithDeviceCyan ¶
    Source

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

    Color_colorWithDeviceHue ¶
    Source

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

    Color_colorWithDeviceRed ¶
    Source

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

    Color_colorWithDeviceWhite ¶
    Source

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

    Color_colorWithSRGBRed ¶
    Source

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

    Color_cyanColor ¶
    Source

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

    Color_getCMYKA ¶
    Source

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

    Color_getComponents ¶
    Source

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

    Color_getHSBA ¶
    Source

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

    Color_getRGBA ¶
    Source

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

    Color_getWhiteAlpha ¶
    Source

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

    Color_greenColor ¶
    Source

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

    Color_magentaColor ¶
    Source

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

    Color_numberOfComponents ¶
    Source

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

    Color_orangeColor ¶
    Source

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

    Color_purpleColor ¶
    Source

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

    Color_redColor ¶
    Source

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

    Color_whiteColor ¶
    Source

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

    Color_yellowColor ¶
    Source

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

    Condition_alloc ¶
    Source

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

    Condition_broadcast ¶
    Source

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

    Condition_init ¶
    Source

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

    Condition_lock ¶
    Source

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

    Condition_signal ¶
    Source

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

    Condition_unlock ¶
    Source

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

    Condition_wait ¶
    Source

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

    Condition_waitUntilDate ¶
    Source

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

    Data_alloc ¶
    Source

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

    Data_init ¶
    Source

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

    Data_length ¶
    Source

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

    Data_mutableBytes ¶
    Source

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

    Date_alloc ¶
    Source

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

    Date_dateWithTimeIntervalSinceNow ¶
    Source

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

    Date_distantFuture ¶
    Source

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

    Date_distantPast ¶
    Source

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

    Date_init ¶
    Source

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

    DeallocateObject ¶
    Source

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

    Dictionary_alloc ¶
    Source

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

    Dictionary_count ¶
    Source

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

    Dictionary_dictionary ¶
    Source

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

    Dictionary_dictionaryWithObject ¶
    Source

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

    Dictionary_dictionaryWithObjects ¶
    Source

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

    Dictionary_init ¶
    Source

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

    Dictionary_initWithObjects ¶
    Source

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

    Dictionary_keyEnumerator ¶
    Source

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

    Dictionary_objectForKey ¶
    Source

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

    Enumerator_allObjects ¶
    Source

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

    Enumerator_iterator ¶
    Source

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

    Enumerator_nextObject ¶
    Source

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

    Error_alloc ¶
    Source

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

    Error_code ¶
    Source

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

    Error_domain ¶
    Source

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

    Error_errorWithDomain ¶
    Source

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

    Error_init ¶
    Source

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

    Error_initWithDomain ¶
    Source

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

    Error_localizedDescription ¶
    Source

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

    Error_localizedFailureReason ¶
    Source

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

    Error_localizedRecoveryOptions ¶
    Source

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

    Error_localizedRecoverySuggestion ¶
    Source

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

    Error_userInfo ¶
    Source

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

    Event_absolute ¶
    Source

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

    Event_absoluteX ¶
    Source

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

    Event_absoluteY ¶
    Source

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

    Event_absoluteZ ¶
    Source

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

    Event_buttonMask ¶
    Source

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

    Event_buttonNumber ¶
    Source

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

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

    Event_capabilityMask ¶
    Source

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

    Event_characters ¶
    Source

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

    Event_charactersIgnoringModifiers ¶
    Source

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

    Event_clickCount ¶
    Source

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

    Event_data1 ¶
    Source

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

    Event_data2 ¶
    Source

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

    Event_delta ¶
    Source

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

    Event_deltaX ¶
    Source

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

    Event_deltaY ¶
    Source

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

    Event_deltaZ ¶
    Source

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

    Event_eventNumber ¶
    Source

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

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

    Event_hasPreciseScrollingDeltas ¶
    Source

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

    Event_isARepeat ¶
    Source

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

    Event_isDirectionInvertedFromDevice ¶
    Source

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

    Event_isEnteringProximity ¶
    Source

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

    Event_isSwipeTrackingFromScrollEventsEnabled ¶
    Source

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

    Event_keyCode ¶
    Source

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

    Event_locationInWindow ¶
    Source

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

    -locationInWindow is valid for all mouse-related events

    Event_modifierFlags ¶
    Source

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

    Event_momentumPhase ¶
    Source

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

    Event_phase ¶
    Source

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

    Event_pointingDeviceID ¶
    Source

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

    Event_pointingDeviceSerialNumber ¶
    Source

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

    Event_pointingDeviceType ¶
    Source

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

    Event_pressure ¶
    Source

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

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

    Event_scrollingDelta ¶
    Source

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

    Event_scrollingDeltaX ¶
    Source

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

    Event_scrollingDeltaY ¶
    Source

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

    Event_subtype ¶
    Source

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

    Event_systemTabletID ¶
    Source

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

    Event_tabletID ¶
    Source

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

    Event_tangentialPressure ¶
    Source

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

    Event_timestamp ¶
    Source

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

    Event_type ¶
    Source

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

    Event_uniqueID ¶
    Source

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

    Event_vendorDefined ¶
    Source

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

    Event_vendorID ¶
    Source

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

    Event_vendorPointingDeviceType ¶
    Source

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

    Event_window ¶
    Source

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

    Event_windowNumber ¶
    Source

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

    FastEnumeration_alloc ¶
    Source

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

    FastEnumeration_countByEnumerating ¶
    Source

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

    FastEnumeration_init ¶
    Source

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

    Layer_addSublayer ¶
    Source

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

    Layer_contentsScale ¶
    Source

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

    Layer_frame ¶
    Source

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

    Layer_setContentsScale ¶
    Source

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

    Locking_lock ¶
    Source

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

    Locking_unlock ¶
    Source

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

    MakeConstantString ¶
    Source

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

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

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

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

    MenuItem_keyEquivalentModifierMask :: proc "c" (
	self: ^MenuItem, 
) -> KeyEquivalentModifierMask {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: keyEquivalentModifierMask
    Syntax Usage
    res := self->keyEquivalentModifierMask()

    MenuItem_registerActionCallback :: proc "c" (
	name:     cstring, 
	callback: MenuItemCallback, 
) -> ^.objc_selector {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: registerActionCallback
    • Kind: Class Method
    Syntax Usage
    res := MenuItem.registerActionCallback(
	name,
	callback,
)

    MenuItem_setKeyEquivalentModifierMask :: proc "c" (
	self:         ^MenuItem, 
	modifierMask: KeyEquivalentModifierMask, 
) {…}
    Objective-C Method Information
    • Class: MenuItem
    • Name: setKeyEquivalentModifierMask
    Syntax Usage
    self->setKeyEquivalentModifierMask(modifierMask)

    MenuItem_setSubmenu :: proc "c" (
	self:    ^MenuItem, 
	submenu: ^Menu, 
) {…}
    Objective-C Method Information
    Syntax Usage
    self->setSubmenu(submenu)

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

    Menu_addItem :: proc "c" (
	self: ^Menu, 
	item: ^MenuItem, 
) {…}
    Objective-C Method Information
    • Class: Menu
    • Name: addItem
    Syntax Usage
    self->addItem(item)

    Menu_addItemWithTitle :: proc "c" (
	self:          ^Menu, 
	title:         ^String, 
	selector:      ^.objc_selector, 
	keyEquivalent: ^String, 
) -> ^MenuItem {…}
    Objective-C Method Information
    • Class: Menu
    • Name: addItemWithTitle
    Syntax Usage
    res := self->addItemWithTitle(
	title,
	selector,
	keyEquivalent,
)

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

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

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

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

    NotificationCenter_addObserverName ¶
    Source

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

    NotificationCenter_alloc ¶
    Source

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

    NotificationCenter_defaultCenter ¶
    Source

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

    NotificationCenter_init ¶
    Source

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

    NotificationCenter_removeObserver ¶
    Source

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

    Notification_alloc ¶
    Source

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

    Notification_init ¶
    Source

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

    Notification_name ¶
    Source

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

    Notification_object ¶
    Source

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

    Notification_userInfo ¶
    Source

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

    Number_alloc ¶
    Source

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

    Number_boolValue ¶
    Source

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

    Number_compare ¶
    Source

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

    Number_descriptionWithLocale ¶
    Source

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

    Number_f32Value ¶
    Source

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

    Number_f64Value ¶
    Source

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

    Number_i16Value ¶
    Source

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

    Number_i32Value ¶
    Source

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

    Number_i64Value ¶
    Source

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

    Number_i8Value ¶
    Source

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

    Number_init ¶
    Source

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

    Number_initWithBool ¶
    Source

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

    Number_initWithF32 ¶
    Source

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

    Number_initWithF64 ¶
    Source

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

    Number_initWithI16 ¶
    Source

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

    Number_initWithI32 ¶
    Source

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

    Number_initWithI64 ¶
    Source

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

    Number_initWithI8 ¶
    Source

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

    Number_initWithInt ¶
    Source

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

    Number_initWithU16 ¶
    Source

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

    Number_initWithU32 ¶
    Source

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

    Number_initWithU64 ¶
    Source

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

    Number_initWithU8 ¶
    Source

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

    Number_initWithUint ¶
    Source

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

    Number_intValue ¶
    Source

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

    Number_integerValue ¶
    Source

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

    Number_isEqualToNumber ¶
    Source

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

    Number_numberWithBool ¶
    Source

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

    Number_numberWithF32 ¶
    Source

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

    Number_numberWithF64 ¶
    Source

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

    Number_numberWithI16 ¶
    Source

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

    Number_numberWithI32 ¶
    Source

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

    Number_numberWithI64 ¶
    Source

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

    Number_numberWithI8 ¶
    Source

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

    Number_numberWithInt ¶
    Source

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

    Number_numberWithU16 ¶
    Source

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

    Number_numberWithU32 ¶
    Source

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

    Number_numberWithU64 ¶
    Source

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

    Number_numberWithU8 ¶
    Source

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

    Number_numberWithUint ¶
    Source

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

    Number_stringValue ¶
    Source

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

    Number_u16Value ¶
    Source

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

    Number_u32Value ¶
    Source

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

    Number_u64Value ¶
    Source

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

    Number_u8Value ¶
    Source

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

    Number_uintValue ¶
    Source

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

    Number_uintegerValue ¶
    Source

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

    OpenPanel_URLs ¶
    Source

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

    OpenPanel_openPanel ¶
    Source

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

    OpenPanel_setAllowedFileTypes ¶
    Source

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

    OpenPanel_setAllowsMultipleSelection ¶
    Source

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

    OpenPanel_setCanChooseDirectories ¶
    Source

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

    OpenPanel_setCanChooseFiles ¶
    Source

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

    OpenPanel_setResolvesAliases ¶
    Source

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

    ProcessInfo_activeProcessorCount ¶
    Source

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

    ProcessInfo_arguments ¶
    Source

    ProcessInfo_arguments :: proc "c" (
	self: ^ProcessInfo, 
) -> ^Array {…}
    Objective-C Method Information
    Syntax Usage
    res := self->arguments()

    ProcessInfo_automaticTerminationSupportEnabled ¶
    Source

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

    ProcessInfo_beginActivityWithOptions ¶
    Source

    ProcessInfo_beginActivityWithOptions :: proc "c" (
	self:    ^ProcessInfo, 
	options: bit_set[ActivityOptionsBits; u64], 
	reason:  ^String, 
) -> ^ObjectProtocol {…}
    Objective-C Method Information
    Syntax Usage
    res := self->beginActivityWithOptions(
	options,
	reason,
)

    ProcessInfo_disableAutomaticTermination ¶
    Source

    ProcessInfo_disableAutomaticTermination :: proc "c" (
	self:   ^ProcessInfo, 
	reason: ^String, 
) {…}
    Objective-C Method Information
    Syntax Usage
    self->disableAutomaticTermination(reason)

    ProcessInfo_disableSuddenTermination ¶
    Source

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

    ProcessInfo_enableAutomaticTermination ¶
    Source

    ProcessInfo_enableAutomaticTermination :: proc "c" (
	self:   ^ProcessInfo, 
	reason: ^String, 
) {…}
    Objective-C Method Information
    Syntax Usage
    self->enableAutomaticTermination(reason)

    ProcessInfo_enableSuddenTermination ¶
    Source

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

    ProcessInfo_endActivity ¶
    Source

    ProcessInfo_endActivity :: proc "c" (
	self:     ^ProcessInfo, 
	activity: ^ObjectProtocol, 
) {…}
    Objective-C Method Information
    Syntax Usage
    self->endActivity(activity)

    ProcessInfo_environment ¶
    Source

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

    ProcessInfo_fullUserName ¶
    Source

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

    ProcessInfo_globallyUniqueString ¶
    Source

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

    ProcessInfo_hostName ¶
    Source

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

    ProcessInfo_isLowPowerModeEnabled ¶
    Source

    ProcessInfo_isLowPowerModeEnabled :: proc "c" (
	self: ^ProcessInfo, 
) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->isLowPowerModeEnabled()

    ProcessInfo_isMacCatalystApp ¶
    Source

    ProcessInfo_isMacCatalystApp :: proc "c" (
	self: ^ProcessInfo, 
) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->isMacCatalystApp()

    ProcessInfo_isOperatingSystemAtLeastVersion ¶
    Source

    ProcessInfo_isOperatingSystemAtLeastVersion :: proc "c" (
	self:    ^ProcessInfo, 
	version: OperatingSystemVersion, 
) -> bool {…}
    Objective-C Method Information
    • Class: ProcessInfo
    • Name: isOperatingSystemAtLeastVersion
    Syntax Usage
    res := self->isOperatingSystemAtLeastVersion(version)

    ProcessInfo_isiOSAppOnMac ¶
    Source

    ProcessInfo_isiOSAppOnMac :: proc "c" (
	self: ^ProcessInfo, 
) -> bool {…}
    Objective-C Method Information
    Syntax Usage
    res := self->isiOSAppOnMac()

    ProcessInfo_operatingSystemVersion ¶
    Source

    ProcessInfo_operatingSystemVersion :: proc "c" (
	self: ^ProcessInfo, 
) -> OperatingSystemVersion {…}
    Objective-C Method Information
    Syntax Usage
    res := self->operatingSystemVersion()

    ProcessInfo_operatingSystemVersionString ¶
    Source

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

    ProcessInfo_performActivityWithOptions ¶
    Source

    ProcessInfo_performActivityWithOptions :: proc "c" (
	self:    ^ProcessInfo, 
	options: bit_set[ActivityOptionsBits; u64], 
	reason:  ^String, 
	block:   proc "c" (), 
) {…}
    Objective-C Method Information
    Syntax Usage
    self->performActivityWithOptions(
	options,
	reason,
	block,
)

    ProcessInfo_performExpiringActivityWithReason ¶
    Source

    ProcessInfo_performExpiringActivityWithReason :: proc "c" (
	self:   ^ProcessInfo, 
	reason: ^String, 
	block:  proc "c" (
	expired: bool, 
), 
) {…}
    Objective-C Method Information
    • Class: ProcessInfo
    • Name: performExpiringActivityWithReason
    Syntax Usage
    self->performExpiringActivityWithReason(
	reason,
	block,
)

    ProcessInfo_physicalMemory ¶
    Source

    ProcessInfo_physicalMemory :: proc "c" (
	self: ^ProcessInfo, 
) -> u64 {…}
    Objective-C Method Information
    Syntax Usage
    res := self->physicalMemory()

    ProcessInfo_processIdentifier ¶
    Source

    ProcessInfo_processIdentifier :: proc "c" (
	self: ^ProcessInfo, 
) -> i32 {…}
    Objective-C Method Information
    Syntax Usage
    res := self->processIdentifier()

    ProcessInfo_processInfo ¶
    Source

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

    ProcessInfo_processName ¶
    Source

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

    ProcessInfo_processorCount ¶
    Source

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

    ProcessInfo_setAutomaticTerminationSupportEnabled ¶
    Source

    ProcessInfo_setAutomaticTerminationSupportEnabled :: proc "c" (
	self:                               ^ProcessInfo, 
	automaticTerminationSupportEnabled: bool, 
) {…}
    Objective-C Method Information
    • Class: ProcessInfo
    • Name: setAutomaticTerminationSupportEnabled
    Syntax Usage
    self->setAutomaticTerminationSupportEnabled(automaticTerminationSupportEnabled)

    ProcessInfo_systemUptime ¶
    Source

    ProcessInfo_systemUptime :: proc "c" (
	self: ^ProcessInfo, 
) -> TimeInterval {…}
    Objective-C Method Information
    Syntax Usage
    res := self->systemUptime()

    ProcessInfo_thermalState ¶
    Source

    ProcessInfo_thermalState :: proc "c" (
	self: ^ProcessInfo, 
) -> ProcessInfoThermalState {…}
    Objective-C Method Information
    Syntax Usage
    res := self->thermalState()

    ProcessInfo_userName ¶
    Source

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

    Range_Equal ¶
    Source

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

    Range_LocationInRange ¶
    Source

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

    Range_Make ¶
    Source

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

    Range_Max ¶
    Source

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

    RunningApplication_currentApplication ¶
    Source

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

    RunningApplication_localizedName ¶
    Source

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

    SavePanel_runModal ¶
    Source

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

    Screen_backingScaleFactor ¶
    Source

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

    Screen_colorSpace ¶
    Source

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

    Screen_deepestScreen ¶
    Source

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

    Screen_depth ¶
    Source

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

    Screen_frame ¶
    Source

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

    Screen_mainScreen ¶
    Source

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

    Screen_screens ¶
    Source

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

    Screen_visibleFrame ¶
    Source

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

    SelectorFromString ¶
    Source

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

    Set_alloc ¶
    Source

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

    Set_init ¶
    Source

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

    Set_initWithCoder ¶
    Source

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

    Set_initWithObjects ¶
    Source

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

    StringFromClass ¶
    Source

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

    StringFromSelector ¶
    Source

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

    String_UTF8String ¶
    Source

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

    String_alloc ¶
    Source

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

    String_characterAtIndex ¶
    Source

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

    String_cstringUsingEncoding ¶
    Source

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

    String_init ¶
    Source

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

    String_initWithBytesNoCopy ¶
    Source

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

    String_initWithCString ¶
    Source

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

    String_initWithOdinString ¶
    Source

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

    String_initWithString ¶
    Source

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

    String_isEqualToString ¶
    Source

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

    String_length ¶
    Source

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

    String_lengthOfBytesUsingEncoding ¶
    Source

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

    String_maximumLengthOfBytesUsingEncoding ¶
    Source

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

    String_odinString ¶
    Source

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

    String_rangeOfString ¶
    Source

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

    URL_alloc ¶
    Source

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

    URL_fileSystemRepresentation ¶
    Source

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

    URL_init ¶
    Source

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

    URL_initFileURLWithPath ¶
    Source

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

    URL_initWithString ¶
    Source

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

    UserDefaults_setBoolForKey ¶
    Source

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

    UserDefaults_standardUserDefaults ¶
    Source

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

    Value_alloc ¶
    Source

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

    Value_getValue ¶
    Source

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

    Value_init ¶
    Source

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

    Value_initWithBytes ¶
    Source

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

    Value_initWithCoder ¶
    Source

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

    Value_isEqualToValue ¶
    Source

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

    Value_objCType ¶
    Source

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

    Value_pointerValue ¶
    Source

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

    Value_valueWithBytes ¶
    Source

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

    Value_valueWithPointer ¶
    Source

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

    View_bounds ¶
    Source

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

    View_convertPointFromView ¶
    Source

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

    View_initWithFrame ¶
    Source

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

    View_layer ¶
    Source

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

    View_setLayer ¶
    Source

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

    View_setWantsLayer ¶
    Source

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

    View_wantsLayer ¶
    Source

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

    Window_alloc ¶
    Source

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

    Window_backgroundColor ¶
    Source

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

    Window_backingScaleFactor ¶
    Source

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

    Window_close ¶
    Source

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

    Window_contentLayoutRect ¶
    Source

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

    Window_contentView ¶
    Source

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

    Window_frame ¶
    Source

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

    Window_hasCloseBox ¶
    Source

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

    Window_hasTitleBar ¶
    Source

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

    Window_initWithContentRect ¶
    Source

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

    Window_isFloatingPanel ¶
    Source

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

    Window_isMiniaturizable ¶
    Source

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

    Window_isModalPanel ¶
    Source

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

    Window_isResizable ¶
    Source

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

    Window_isZoomable ¶
    Source

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

    Window_mainMenu ¶
    Source

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

    Window_makeKeyAndOrderFront ¶
    Source

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

    Window_opaque ¶
    Source

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

    Window_orderedIndex ¶
    Source

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

    Window_setBackgroundColor ¶
    Source

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

    Window_setContentView ¶
    Source

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

    Window_setDelegate ¶
    Source

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

    Window_setFrame ¶
    Source

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

    Window_setIsMiniaturized ¶
    Source

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

    Window_setIsVisible ¶
    Source

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

    Window_setIsZoomed ¶
    Source

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

    Window_setMovable ¶
    Source

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

    Window_setMovableByWindowBackground ¶
    Source

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

    Window_setOpaque ¶
    Source

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

    Window_setStyleMask ¶
    Source

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

    Window_setTitle ¶
    Source

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

    Window_setTitlebarAppearsTransparent ¶
    Source

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

    Window_setWantsLayer ¶
    Source

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

    alloc ¶
    Source

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

    application_delegate_register_and_alloc ¶
    Source

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

    autorelease ¶
    Source

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

    bridgingCast ¶
    Source

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

    class ¶
    Source

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

    class_addIvar ¶
    Source

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

    class_addMethod ¶
    Source

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

    class_addProperty ¶
    Source

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

    class_addProtocol ¶
    Source

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

    class_conformsToProtocol ¶
    Source

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

    class_copyIvarList ¶
    Source

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

    class_copyMethodList ¶
    Source

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

    class_copyPropertyList ¶
    Source

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

    class_copyProtocolList ¶
    Source

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

    class_createInstance ¶
    Source

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

    class_getClassMethod ¶
    Source

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

    class_getClassVariable ¶
    Source

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

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

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

    class_getMethodImplementation ¶
    Source

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

    class_getName ¶
    Source

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

    class_getProperty ¶
    Source

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

    class_getSuperclass ¶
    Source

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

    class_getVersion ¶
    Source

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

    class_isMetaClass ¶
    Source

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

    class_replaceMethod ¶
    Source

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

    class_replaceProperty ¶
    Source

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

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

    copy ¶
    Source

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

    debugDescription ¶
    Source

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

    description ¶
    Source

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

    hash ¶
    Source

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

    init ¶
    Source

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

    isEqual ¶
    Source

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

    ivar_getName ¶
    Source

    ivar_getName :: proc "c" (
	v: ^objc_ivar, 
) -> cstring ---

    ivar_getOffset ¶
    Source

    ivar_getOffset :: proc "c" (
	v: ^objc_ivar, 
) -> c.ptrdiff_t ---

    ivar_getTypeEncoding ¶
    Source

    ivar_getTypeEncoding :: proc "c" (
	v: ^objc_ivar, 
) -> cstring ---

    methodSignatureForSelector ¶
    Source

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

    method_copyArgumentType ¶
    Source

    method_copyArgumentType :: proc "c" (
	m:     ^objc_method, 
	index: uint, 
) -> cstring ---

    method_getArgumentType ¶
    Source

    method_getArgumentType :: proc "c" (
	m:       ^objc_method, 
	index:   uint, 
	dst:     cstring, 
	dst_len: uint, 
) ---

    method_getImplementation ¶
    Source

    method_getImplementation :: proc "c" (
	m: ^objc_method, 
) -> IMP ---

    method_getNumberOfArguments ¶
    Source

    method_getNumberOfArguments :: proc "c" (
	m: ^objc_method, 
) -> uint ---

    method_getReturnType ¶
    Source

    method_getReturnType :: proc "c" (
	m:       ^objc_method, 
	dst:     cstring, 
	dst_len: uint, 
) ---

    method_setImplementation ¶
    Source

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

    msgSendSafeCheck ¶
    Source

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

    new ¶
    Source

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

    objc_allocateClassPair ¶
    Source

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

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

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

    objc_destructInstance ¶
    Source

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

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

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

    objc_getProtocol ¶
    Source

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

    objc_getRequiredClass ¶
    Source

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

    objc_lookUpClass ¶
    Source

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

    objc_registerClassPair ¶
    Source

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

    objc_removeAssociatedObjects ¶
    Source

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

    objc_setAssociatedObject ¶
    Source

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

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

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

    object_getIndexedIvars ¶
    Source

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

    object_getInstanceVariable ¶
    Source

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

    object_getIvar ¶
    Source

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

    object_setClass ¶
    Source

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

    object_setInstanceVariable ¶
    Source

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

    object_setIvar ¶
    Source

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

    property_copyAttributeList ¶
    Source

    property_copyAttributeList :: proc "c" (
	property: ^objc_property, 
	outCount: ^uint, 
) -> [^]objc_property_attribute_t ---

    property_copyAttributeValue ¶
    Source

    property_copyAttributeValue :: proc "c" (
	property:      ^objc_property, 
	attributeName: cstring, 
) -> cstring ---

    property_getAttributes ¶
    Source

    property_getAttributes :: proc "c" (
	property: ^objc_property, 
) -> cstring ---

    property_getName ¶
    Source

    property_getName :: proc "c" (
	property: ^objc_property, 
) -> cstring ---

    protocol_conformsToProtocol ¶
    Source

    protocol_conformsToProtocol :: proc "c" (
	proto: ^Protocol, 
	other: ^Protocol, 
) -> bool ---

    protocol_getName ¶
    Source

    protocol_getName :: proc "c" (
	proto: ^Protocol, 
) -> cstring ---

    protocol_isEqual ¶
    Source

    protocol_isEqual :: proc "c" (
	proto: ^Protocol, 
	other: ^Protocol, 
) -> bool ---

    release ¶
    Source

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

    respondsToSelector ¶
    Source

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

    retain ¶
    Source

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

    retainCount ¶
    Source

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

    scoped_autoreleasepool ¶
    Source

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

    sel_getName ¶
    Source

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

    sel_isEqual ¶
    Source

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

    sel_registerName ¶
    Source

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

    tilt ¶
    Source

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

    window_delegate_register_and_alloc ¶
    Source

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

    Procedure Groups

    Number_number ¶
    Source

    Number_number :: proc{
	Number_numberWithI8,
	Number_numberWithU8,
	Number_numberWithI16,
	Number_numberWithU16,
	Number_numberWithI32,
	Number_numberWithU32,
	Number_numberWithInt,
	Number_numberWithUint,
	Number_numberWithU64,
	Number_numberWithI64,
	Number_numberWithF32,
	Number_numberWithF64,
	Number_numberWithBool,
}
    Objective-C Method Information
    • Class: Number
    • Name: number
    • Kind: Class Method
    Syntax Usage
    res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)
res := Number.number(value)

    Source Files

    Generation Information

    Generated with odin version dev-2024-12 (vendor "odin") Windows_amd64 @ 2024-12-21 21:10:06.518352000 +0000 UTC