From 1d25522a3b6b7e236f10273cacd25e2a713f8659 Mon Sep 17 00:00:00 2001 From: gingerBill Date: Thu, 24 Aug 2023 16:43:13 +0100 Subject: [PATCH] Update `vendor:darwin/Foundation` to implement `Event`, `Color`, `Screen`, and other fixes --- vendor/darwin/Foundation/NSApplication.odin | 33 ++- vendor/darwin/Foundation/NSColor.odin | 149 ++++++++++ vendor/darwin/Foundation/NSEvent.odin | 304 +++++++++++++++++++- vendor/darwin/Foundation/NSScreen.odin | 30 +- vendor/darwin/Foundation/NSWindow.odin | 49 ++-- 5 files changed, 541 insertions(+), 24 deletions(-) create mode 100644 vendor/darwin/Foundation/NSColor.odin diff --git a/vendor/darwin/Foundation/NSApplication.odin b/vendor/darwin/Foundation/NSApplication.odin index 48682aef7..7dfb0a879 100644 --- a/vendor/darwin/Foundation/NSApplication.odin +++ b/vendor/darwin/Foundation/NSApplication.odin @@ -1,9 +1,22 @@ package objc_Foundation +foreign import "system:Foundation.framework" + import "core:intrinsics" import "core:runtime" import "core:strings" +RunLoopMode :: ^String + +@(link_prefix="NS") +foreign Foundation { + CommonRunLoopMode: RunLoopMode + DefaultRunLoopMode: RunLoopMode + EventTrackingRunLoopMode: RunLoopMode + ModalPanelRunLoopMode: RunLoopMode + TrackingRunLoopMode: RunLoopMode +} + ActivationPolicy :: enum UInteger { Regular = 0, Accessory = 1, @@ -87,12 +100,30 @@ Application_run :: proc "c" (self: ^Application) { msgSend(nil, self, "run") } - @(objc_type=Application, objc_name="terminate") Application_terminate :: proc "c" (self: ^Application, sender: ^Object) { msgSend(nil, self, "terminate:", sender) } +@(objc_type=Application, objc_name="isRunning") +Application_isRunning :: proc "c" (self: ^Application) -> BOOL { + return msgSend(BOOL, self, "isRunning") +} + +@(objc_type=Application, objc_name="currentEvent") +Application_currentEvent :: proc "c" (self: ^Application) -> ^Event { + return msgSend(^Event, self, "currentEvent") +} + +@(objc_type=Application, objc_name="nextEventMatchingMask") +Application_nextEventMatchingMask :: proc "c" (self: ^Application, mask: EventMask, expiration: ^Date, in_mode: RunLoopMode, dequeue: BOOL) -> ^Event { + return msgSend(^Event, self, "nextEventMatchingMask:untilDate:inMode:dequeue:", mask, expiration, in_mode, dequeue) +} + +@(objc_type=Application, objc_name="sendEvent") +Application_sendEvent :: proc "c" (self: ^Application, event: ^Event) { + msgSend(Event, self, "sendEvent:", event) +} @(objc_class="NSRunningApplication") diff --git a/vendor/darwin/Foundation/NSColor.odin b/vendor/darwin/Foundation/NSColor.odin new file mode 100644 index 000000000..453b33144 --- /dev/null +++ b/vendor/darwin/Foundation/NSColor.odin @@ -0,0 +1,149 @@ +package objc_Foundation + +@(objc_class="NSColorSpace") +ColorSpace :: struct {using _: Object} + +@(objc_class="NSColor") +Color :: struct {using _: Object} + +@(objc_type=Color, objc_name="colorWithSRGBRed", objc_is_class_method=true) +Color_colorWithSRGBRed :: proc "c" (red, green, blue, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithSRGBRed:green:blue:alpha:", red, green, blue, alpha) +} + +@(objc_type=Color, objc_name="colorWithCalibratedHue", objc_is_class_method=true) +Color_colorWithCalibratedHue :: proc "c" (hue, saturation, brightness, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithCalibratedHue:hue:saturation:brightness:alpha:", hue, saturation, brightness, alpha) +} +@(objc_type=Color, objc_name="colorWithCalibratedRed", objc_is_class_method=true) +Color_colorWithCalibratedRed :: proc "c" (red, green, blue, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithCalibratedRed:green:blue:alpha:", red, green, blue, alpha) +} +@(objc_type=Color, objc_name="colorWithCalibratedWhite", objc_is_class_method=true) +Color_colorWithCalibratedWhite :: proc "c" (white, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithCalibratedWhite:alpha:", white, alpha) +} + +@(objc_type=Color, objc_name="colorWithDeviceCyan", objc_is_class_method=true) +Color_colorWithDeviceCyan :: proc "c" (cyan, magenta, yellow, black, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithDeviceCyan:magenta:yellow:black:", cyan, magenta, yellow, black) +} +@(objc_type=Color, objc_name="colorWithDeviceHue", objc_is_class_method=true) +Color_colorWithDeviceHue :: proc "c" (hue, saturation, brightness, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithDeviceHue:hue:saturation:brightness:alpha:", hue, saturation, brightness, alpha) +} +@(objc_type=Color, objc_name="colorWithDeviceRed", objc_is_class_method=true) +Color_colorWithDeviceRed :: proc "c" (red, green, blue, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithDeviceRed:green:blue:alpha:", red, green, blue, alpha) +} +@(objc_type=Color, objc_name="colorWithDeviceWhite", objc_is_class_method=true) +Color_colorWithDeviceWhite :: proc "c" (white, alpha: Float) -> ^Color { + return msgSend(^Color, Color, "colorWithDeviceWhite:alpha:", white, alpha) +} + + +@(objc_type=Color, objc_name="blackColor", objc_is_class_method=true) +Color_blackColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "blackColor") +} + +@(objc_type=Color, objc_name="whiteColor", objc_is_class_method=true) +Color_whiteColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "whiteColor") +} + +@(objc_type=Color, objc_name="redColor", objc_is_class_method=true) +Color_redColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "redColor") +} + +@(objc_type=Color, objc_name="greenColor", objc_is_class_method=true) +Color_greenColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "greenColor") +} + +@(objc_type=Color, objc_name="orangeColor", objc_is_class_method=true) +Color_orangeColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "orangeColor") +} + +@(objc_type=Color, objc_name="purpleColor", objc_is_class_method=true) +Color_purpleColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "purpleColor") +} + +@(objc_type=Color, objc_name="cyanColor", objc_is_class_method=true) +Color_cyanColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "cyanColor") +} + +@(objc_type=Color, objc_name="blueColor", objc_is_class_method=true) +Color_blueColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "blueColor") +} + +@(objc_type=Color, objc_name="magentaColor", objc_is_class_method=true) +Color_magentaColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "magentaColor") +} + +@(objc_type=Color, objc_name="yellowColor", objc_is_class_method=true) +Color_yellowColor :: proc "c" () -> ^Color { + return msgSend(^Color, Color, "yellowColor") +} + + +@(objc_type=Color, objc_name="getCMYKA") +Color_getCMYKA :: proc "c" (self: ^Color) -> (cyan, magenta, yellow, black, alpha: Float) { + msgSend(nil, Color, "getCyan:magenta:yellow:black:alpha:", &cyan, &magenta, &yellow, &black, &alpha) + return +} +@(objc_type=Color, objc_name="getHSBA") +Color_getHSBA :: proc "c" (self: ^Color) -> (hue, saturation, brightness, alpha: Float) { + msgSend(nil, Color, "getHue:saturation:brightness:alpha:", &hue, &saturation, &brightness, &alpha) + return +} +@(objc_type=Color, objc_name="getRGBA") +Color_getRGBA :: proc "c" (self: ^Color) -> (red, green, blue, alpha: Float) { + msgSend(nil, Color, "getRed:green:blue:alpha:", &red, &green, &blue, &alpha) + return +} +@(objc_type=Color, objc_name="getWhiteAlpha") +Color_getWhiteAlpha :: proc "c" (self: ^Color) -> (white, alpha: Float) { + msgSend(nil, Color, "getWhite:alpha:", &white, &alpha) + return +} + + +@(objc_type=Color, objc_name="colorWithColorSpace", objc_is_class_method=true) +Color_colorWithColorSpace :: proc "c" (space: ^ColorSpace, components: []Float) -> ^Color { + return msgSend(^Color, Color, "colorWithColorSpace:components:count", space, raw_data(components), Integer(len(components))) +} + + +@(objc_type=Color, objc_name="colorSpaceName") +Color_colorSpaceName :: proc "c" (self: ^Color) -> ^String { + return msgSend(^String, self, "colorSpaceName") +} + +@(objc_type=Color, objc_name="colorSpace") +Color_colorSpace :: proc "c" (self: ^Color) -> ^ColorSpace { + return msgSend(^ColorSpace, self, "colorSpace") +} + +@(objc_type=Color, objc_name="colorUsingColorSpaceName") +Color_colorUsingColorSpaceName :: proc "c" (self: ^Color, colorSpace: ^String, device: ^Dictionary = nil) -> ^Color { + if device != nil { + return msgSend(^Color, self, "colorUsingColorSpaceName:device:", colorSpace, device) + } + return msgSend(^Color, self, "colorUsingColorSpaceName:", colorSpace) +} + +@(objc_type=Color, objc_name="numberOfComponents") +Color_numberOfComponents :: proc "c" (self: ^Color) -> Integer { + return msgSend(Integer, self, "numberOfComponents") +} +@(objc_type=Color, objc_name="getComponents") +Color_getComponents :: proc "c" (self: ^Color, components: [^]Float) { + msgSend(nil, self, "getComponents:", components) +} \ No newline at end of file diff --git a/vendor/darwin/Foundation/NSEvent.odin b/vendor/darwin/Foundation/NSEvent.odin index 900f05a6c..d604575bb 100644 --- a/vendor/darwin/Foundation/NSEvent.odin +++ b/vendor/darwin/Foundation/NSEvent.odin @@ -2,4 +2,306 @@ package objc_Foundation @(objc_class="NSEvent") Event :: struct {using _: Object} -// TODO: implement NSEvent + + + +EventMask :: distinct bit_set[EventType; UInteger] +EventMaskAny :: ~EventMask{} + +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, +} + +EventPhase :: distinct bit_set[EventPhaseFlag; UInteger] +EventPhaseFlag :: enum UInteger { + Began = 0, + Stationary = 1, + Changed = 2, + Ended = 3, + Cancelled = 4, + MayBegin = 5, +} +EventPhaseNone :: EventPhase{} +EventPhaseBegan :: EventPhase{.Began} +EventPhaseStationary :: EventPhase{.Stationary} +EventPhaseChanged :: EventPhase{.Changed} +EventPhaseEnded :: EventPhase{.Ended} +EventPhaseCancelled :: EventPhase{.Cancelled} +EventPhaseMayBegin :: EventPhase{.MayBegin} + +/* pointer types for NSTabletProximity events or mouse events with subtype NSTabletProximityEventSubtype*/ +PointingDeviceType :: enum UInteger { + Unknown = 0, + Pen = 1, + Cursor = 2, + Eraser = 3, +} + +/* these messages are valid for all events */ + +@(objc_type=Event, objc_name="type") +Event_type :: proc "c" (self: ^Event) -> EventType { + return msgSend(EventType, self, "type") +} +@(objc_type=Event, objc_name="modifierFlags") +Event_modifierFlags :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "modifierFlags") +} +@(objc_type=Event, objc_name="timestamp") +Event_timestamp :: proc "c" (self: ^Event) -> TimeInterval { + return msgSend(TimeInterval, self, "timestamp") +} +@(objc_type=Event, objc_name="window") +Event_window :: proc "c" (self: ^Event) -> ^Window { + return msgSend(^Window, self, "window") +} +@(objc_type=Event, objc_name="windowNumber") +Event_windowNumber :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "windowNumber") +} + +/* these messages are valid for all mouse down/up/drag events */ + +@(objc_type=Event, objc_name="clickCount") +Event_clickCount :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "clickCount") +} + +// for NSOtherMouse events, but will return valid constants for NSLeftMouse and NSRightMouse +@(objc_type=Event, objc_name="buttonNumber") +Event_buttonNumber :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "buttonNumber") +} + +/* these messages are valid for all mouse down/up/drag and enter/exit events */ +@(objc_type=Event, objc_name="eventNumber") +Event_eventNumber :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "eventNumber") +} + +/* -pressure is valid for all mouse down/up/drag events, and is also valid for NSTabletPoint events on 10.4 or later */ +@(objc_type=Event, objc_name="pressure") +Event_pressure :: proc "c" (self: ^Event) -> f32 { + return msgSend(f32, self, "pressure") +} + +/* -locationInWindow is valid for all mouse-related events */ +@(objc_type=Event, objc_name="locationInWindow") +Event_locationInWindow :: proc "c" (self: ^Event) -> Point { + return msgSend(Point, self, "locationInWindow") +} + + +@(objc_type=Event, objc_name="deltaX") +Event_deltaX :: proc "c" (self: ^Event) -> Float { + return msgSend(Float, self, "deltaX") +} +@(objc_type=Event, objc_name="deltaY") +Event_deltaY :: proc "c" (self: ^Event) -> Float { + return msgSend(Float, self, "deltaY") +} +@(objc_type=Event, objc_name="deltaZ") +Event_deltaZ :: proc "c" (self: ^Event) -> Float { + return msgSend(Float, self, "deltaZ") +} +@(objc_type=Event, objc_name="delta") +Event_delta :: proc "c" (self: ^Event) -> (x, y, z: Float) { + x = self->deltaX() + y = self->deltaY() + z = self->deltaZ() + return +} + +@(objc_type=Event, objc_name="hasPreciseScrollingDeltas") +Event_hasPreciseScrollingDeltas :: proc "c" (self: ^Event) -> BOOL { + return msgSend(BOOL, self, "hasPreciseScrollingDeltas") +} + + +@(objc_type=Event, objc_name="scrollingDeltaX") +Event_scrollingDeltaX :: proc "c" (self: ^Event) -> Float { + return msgSend(Float, self, "scrollingDeltaX") +} +@(objc_type=Event, objc_name="scrollingDeltaY") +Event_scrollingDeltaY :: proc "c" (self: ^Event) -> Float { + return msgSend(Float, self, "scrollingDeltaY") +} +@(objc_type=Event, objc_name="scrollingDelta") +Event_scrollingDelta :: proc "c" (self: ^Event) -> (x, y: Float) { + x = self->scrollingDeltaX() + y = self->scrollingDeltaY() + return +} + + + +@(objc_type=Event, objc_name="momentumPhase") +Event_momentumPhase :: proc "c" (self: ^Event) -> EventPhase { + return msgSend(EventPhase, self, "momentumPhase") +} +@(objc_type=Event, objc_name="phase") +Event_phase :: proc "c" (self: ^Event) -> EventPhase { + return msgSend(EventPhase, self, "phase") +} + + +@(objc_type=Event, objc_name="isDirectionInvertedFromDevice") +Event_isDirectionInvertedFromDevice :: proc "c" (self: ^Event) -> BOOL { + return msgSend(BOOL, self, "isDirectionInvertedFromDevice") +} + +@(objc_type=Event, objc_name="characters") +Event_characters :: proc "c" (self: ^Event) -> ^String { + return msgSend(^String, self, "characters") +} +@(objc_type=Event, objc_name="charactersIgnoringModifiers") +Event_charactersIgnoringModifiers :: proc "c" (self: ^Event) -> ^String { + return msgSend(^String, self, "charactersIgnoringModifiers") +} +@(objc_type=Event, objc_name="isARepeat") +Event_isARepeat :: proc "c" (self: ^Event) -> BOOL { + return msgSend(BOOL, self, "isARepeat") +} + +@(objc_type=Event, objc_name="keyCode") +Event_keyCode :: proc "c" (self: ^Event) -> u16 { + return msgSend(u16, self, "keyCode") +} + +@(objc_type=Event, objc_name="subtype") +Event_subtype :: proc "c" (self: ^Event) -> i16 { + return msgSend(i16, self, "subtype") +} + +@(objc_type=Event, objc_name="data1") +Event_data1 :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "data1") +} +@(objc_type=Event, objc_name="data2") +Event_data2 :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "data2") +} + + +@(objc_type=Event, objc_name="absoluteX") +Event_absoluteX :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "absoluteX") +} +@(objc_type=Event, objc_name="absoluteY") +Event_absoluteY :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "absoluteY") +} +@(objc_type=Event, objc_name="absoluteZ") +Event_absoluteZ :: proc "c" (self: ^Event) -> Integer { + return msgSend(Integer, self, "absoluteZ") +} + +@(objc_type=Event, objc_name="absolute") +Event_absolute :: proc "c" (self: ^Event) -> (x, y, z: Integer) { + x = self->absoluteX() + y = self->absoluteY() + z = self->absoluteZ() + return +} + + +@(objc_type=Event, objc_name="buttonMask") +Event_buttonMask :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "buttonMask") +} + +@(objc_type=Event, objc_name="tilt") +tilt :: proc "c" (self: ^Event) -> Point { + return msgSend(Point, self, "tilt") +} + +@(objc_type=Event, objc_name="tangentialPressure") +Event_tangentialPressure :: proc "c" (self: ^Event) -> f32 { + return msgSend(f32, self, "tangentialPressure") +} + +@(objc_type=Event, objc_name="vendorDefined") +Event_vendorDefined :: proc "c" (self: ^Event) -> id { + return msgSend(id, self, "vendorDefined") +} + + +@(objc_type=Event, objc_name="vendorID") +Event_vendorID :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "vendorID") +} +@(objc_type=Event, objc_name="tabletID") +Event_tabletID :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "tabletID") +} +@(objc_type=Event, objc_name="pointingDeviceID") +Event_pointingDeviceID :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "pointingDeviceID") +} +@(objc_type=Event, objc_name="systemTabletID") +Event_systemTabletID :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "systemTabletID") +} +@(objc_type=Event, objc_name="vendorPointingDeviceType") +Event_vendorPointingDeviceType :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "vendorPointingDeviceType") +} +@(objc_type=Event, objc_name="pointingDeviceSerialNumber") +Event_pointingDeviceSerialNumber :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "pointingDeviceSerialNumber") +} +@(objc_type=Event, objc_name="uniqueID") +Event_uniqueID :: proc "c" (self: ^Event) -> u64 { + return msgSend(u64, self, "uniqueID") +} +@(objc_type=Event, objc_name="capabilityMask") +Event_capabilityMask :: proc "c" (self: ^Event) -> UInteger { + return msgSend(UInteger, self, "capabilityMask") +} +@(objc_type=Event, objc_name="pointingDeviceType") +Event_pointingDeviceType :: proc "c" (self: ^Event) -> PointingDeviceType { + return msgSend(PointingDeviceType, self, "pointingDeviceType") +} +@(objc_type=Event, objc_name="isEnteringProximity") +Event_isEnteringProximity :: proc "c" (self: ^Event) -> BOOL { + return msgSend(BOOL, self, "isEnteringProximity") +} + + +@(objc_type=Event, objc_name="isSwipeTrackingFromScrollEventsEnabled") +Event_isSwipeTrackingFromScrollEventsEnabled :: proc "c" (self: ^Event) -> BOOL { + return msgSend(BOOL, self, "isSwipeTrackingFromScrollEventsEnabled") +} diff --git a/vendor/darwin/Foundation/NSScreen.odin b/vendor/darwin/Foundation/NSScreen.odin index f1f7b84b8..a8fe44aa5 100644 --- a/vendor/darwin/Foundation/NSScreen.odin +++ b/vendor/darwin/Foundation/NSScreen.odin @@ -2,4 +2,32 @@ package objc_Foundation @(objc_class="NSScreen") Screen :: struct {using _: Object} -// TODO: implement NSScreen + +@(objc_type=Screen, objc_name="mainScreen") +Screen_mainScreen :: proc "c" () -> ^Screen { + return msgSend(^Screen, Screen, "mainScreen") +} +@(objc_type=Screen, objc_name="deepestScreen") +Screen_deepestScreen :: proc "c" () -> ^Screen { + return msgSend(^Screen, Screen, "deepestScreen") +} +@(objc_type=Screen, objc_name="screens") +Screen_screens :: proc "c" () -> ^Array { + return msgSend(^Array, Screen, "screens") +} +@(objc_type=Screen, objc_name="frame") +Screen_frame :: proc "c" (self: ^Screen) -> Rect { + return msgSend(Rect, self, "frame") +} +@(objc_type=Screen, objc_name="depth") +Screen_depth :: proc "c" (self: ^Screen) -> Depth { + return msgSend(Depth, self, "depth") +} +@(objc_type=Screen, objc_name="visibleFrame") +Screen_visibleFrame :: proc "c" (self: ^Screen) -> Rect { + return msgSend(Rect, self, "visibleFrame") +} +@(objc_type=Screen, objc_name="colorSpace") +Screen_colorSpace :: proc "c" (self: ^Screen) -> ^ColorSpace { + return msgSend(^ColorSpace, self, "colorSpace") +} diff --git a/vendor/darwin/Foundation/NSWindow.odin b/vendor/darwin/Foundation/NSWindow.odin index 0a7382921..bf95b8751 100644 --- a/vendor/darwin/Foundation/NSWindow.odin +++ b/vendor/darwin/Foundation/NSWindow.odin @@ -3,20 +3,25 @@ package objc_Foundation import "core:strings" import "core:runtime" import "core:intrinsics" -import NS "vendor:darwin/Foundation" Rect :: struct { using origin: Point, using size: Size, } +Depth :: enum UInteger { + onehundredtwentyeightBitRGB = 544, + sixtyfourBitRGB = 528, + twentyfourBitRGB = 520, +} + when size_of(Float) == 8 { _RECT_ENCODING :: "{CGRect="+_POINT_ENCODING+_SIZE_ENCODING+"}" } else { _RECT_ENCODING :: "{NSRect="+_POINT_ENCODING+_SIZE_ENCODING+"}" } -WindowStyleFlag :: enum NS.UInteger { +WindowStyleFlag :: enum UInteger { Titled = 0, Closable = 1, Miniaturizable = 2, @@ -30,7 +35,7 @@ WindowStyleFlag :: enum NS.UInteger { NonactivatingPanel = 7, HUDWindow = 13, } -WindowStyleMask :: distinct bit_set[WindowStyleFlag; NS.UInteger] +WindowStyleMask :: distinct bit_set[WindowStyleFlag; UInteger] WindowStyleMaskBorderless :: WindowStyleMask{} WindowStyleMaskTitled :: WindowStyleMask{.Titled} WindowStyleMaskClosable :: WindowStyleMask{.Closable} @@ -45,7 +50,7 @@ WindowStyleMaskDocModalWindow :: WindowStyleMask{.DocModalWindow} WindowStyleMaskNonactivatingPanel :: WindowStyleMask{.NonactivatingPanel} WindowStyleMaskHUDWindow :: WindowStyleMask{.HUDWindow} -BackingStoreType :: enum NS.UInteger { +BackingStoreType :: enum UInteger { Retained = 0, Nonretained = 1, Buffered = 2, @@ -124,7 +129,8 @@ WindowDelegateTemplate :: struct { windowDidExitVersionBrowser: proc(notification: ^Notification), } -WindowDelegate :: struct { using _: Object } + +WindowDelegate :: struct { using _: Object } // This is not the same as NSWindowDelegate _WindowDelegateInternal :: struct { using _: WindowDelegateTemplate, _context: runtime.Context, @@ -555,11 +561,8 @@ window_delegate_register_and_alloc :: proc(template: WindowDelegateTemplate, cla return cast(^WindowDelegate)del } -@(objc_class="NSColor") -Color :: struct {using _: Object} - @(objc_class="CALayer") -Layer :: struct { using _: NS.Object } +Layer :: struct { using _: Object } @(objc_type=Layer, objc_name="contentsScale") Layer_contentsScale :: proc "c" (self: ^Layer) -> Float { @@ -589,6 +592,10 @@ View :: struct {using _: Responder} View_initWithFrame :: proc "c" (self: ^View, frame: Rect) -> ^View { return msgSend(^View, self, "initWithFrame:", frame) } +@(objc_type=View, objc_name="bounds") +View_bounds :: proc "c" (self: ^View) -> Rect { + return msgSend(Rect, self, "bounds") +} @(objc_type=View, objc_name="layer") View_layer :: proc "c" (self: ^View) -> ^Layer { return msgSend(^Layer, self, "layer") @@ -615,7 +622,7 @@ Window_alloc :: proc "c" () -> ^Window { } @(objc_type=Window, objc_name="initWithContentRect") -Window_initWithContentRect :: proc (self: ^Window, contentRect: Rect, styleMask: WindowStyleMask, backing: BackingStoreType, doDefer: bool) -> ^Window { +Window_initWithContentRect :: proc (self: ^Window, contentRect: Rect, styleMask: WindowStyleMask, backing: BackingStoreType, doDefer: BOOL) -> ^Window { self := self // HACK: due to a compiler bug, the generated calling code does not // currently work for this message. Has to do with passing a struct along @@ -650,39 +657,39 @@ Window_setFrame :: proc "c" (self: ^Window, frame: Rect) { msgSend(nil, self, "setFrame:", frame) } @(objc_type=Window, objc_name="opaque") -Window_opaque :: proc "c" (self: ^Window) -> NS.BOOL { - return msgSend(NS.BOOL, self, "opaque") +Window_opaque :: proc "c" (self: ^Window) -> BOOL { + return msgSend(BOOL, self, "opaque") } @(objc_type=Window, objc_name="setOpaque") -Window_setOpaque :: proc "c" (self: ^Window, ok: NS.BOOL) { +Window_setOpaque :: proc "c" (self: ^Window, ok: BOOL) { msgSend(nil, self, "setOpaque:", ok) } @(objc_type=Window, objc_name="backgroundColor") -Window_backgroundColor :: proc "c" (self: ^Window) -> ^NS.Color { - return msgSend(^NS.Color, self, "backgroundColor") +Window_backgroundColor :: proc "c" (self: ^Window) -> ^Color { + return msgSend(^Color, self, "backgroundColor") } @(objc_type=Window, objc_name="setBackgroundColor") -Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^NS.Color) { +Window_setBackgroundColor :: proc "c" (self: ^Window, color: ^Color) { msgSend(nil, self, "setBackgroundColor:", color) } @(objc_type=Window, objc_name="makeKeyAndOrderFront") -Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^NS.Object) { +Window_makeKeyAndOrderFront :: proc "c" (self: ^Window, key: ^Object) { msgSend(nil, self, "makeKeyAndOrderFront:", key) } @(objc_type=Window, objc_name="setTitle") -Window_setTitle :: proc "c" (self: ^Window, title: ^NS.String) { +Window_setTitle :: proc "c" (self: ^Window, title: ^String) { msgSend(nil, self, "setTitle:", title) } @(objc_type=Window, objc_name="setTitlebarAppearsTransparent") -Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: NS.BOOL) { +Window_setTitlebarAppearsTransparent :: proc "c" (self: ^Window, ok: BOOL) { msgSend(nil, self, "setTitlebarAppearsTransparent:", ok) } @(objc_type=Window, objc_name="setMovable") -Window_setMovable :: proc "c" (self: ^Window, ok: NS.BOOL) { +Window_setMovable :: proc "c" (self: ^Window, ok: BOOL) { msgSend(nil, self, "setMovable:", ok) } @(objc_type=Window, objc_name="setMovableByWindowBackground") -Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: NS.BOOL) { +Window_setMovableByWindowBackground :: proc "c" (self: ^Window, ok: BOOL) { msgSend(nil, self, "setMovableByWindowBackground:", ok) } @(objc_type=Window, objc_name="setStyleMask")