objc2_paravirtualized_graphics/generated/

PGDisplay.rs

//! This file has been automatically generated by `objc2`'s `header-translator`.
//! DO NOT EDIT
use core::ffi::*;
use core::ptr::NonNull;
#[cfg(feature = "dispatch2")]
use dispatch2::*;
use objc2::__framework_prelude::*;
#[cfg(feature = "objc2-app-kit")]
use objc2_app_kit::*;
use objc2_foundation::*;
#[cfg(feature = "objc2-metal")]
use objc2_metal::*;

use crate::*;

/// A struct for describing size of or offsets into a 2D array of pixels (used for size of display mode, size of cursor, and cursor hotSpot).
/// Field: x Represents horizontal pixel offset/size
/// Field: y Represents vertical pixel offset/size
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaycoord_t?language=objc)
#[repr(C)]
#[derive(Clone, Copy, Debug, PartialEq)]
pub struct PGDisplayCoord_t {
    pub x: u16,
    pub y: u16,
}

unsafe impl Encode for PGDisplayCoord_t {
    const ENCODING: Encoding = Encoding::Struct("?", &[<u16>::ENCODING, <u16>::ENCODING]);
}

unsafe impl RefEncode for PGDisplayCoord_t {
    const ENCODING_REF: Encoding = Encoding::Pointer(&Self::ENCODING);
}

/// A block that will be invoked at display mode change boundaries.
///
/// Parameter `sizeInPixels`: Size of upcoming frames.
///
/// Parameter `pixelFormat`: Pixel format of upcoming frames.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaymodechangehandler?language=objc)
#[cfg(feature = "block2")]
pub type PGDisplayModeChangeHandler = *mut block2::DynBlock<dyn Fn(PGDisplayCoord_t, OSType)>;

/// A block that will be invoked to notify client of availability of new Guest compositor frame to be further processed.
///
/// See encodeCurrentFrameToCommandBuffer:texture:region: below to get further processing underway.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaynewframeeventhandler?language=objc)
#[cfg(feature = "block2")]
pub type PGDisplayNewFrameEventHandler = *mut block2::DynBlock<dyn Fn()>;

/// A block that will be invoked to handle cursor glyph updates.
///
/// Parameter `glyph`: Cursor glyph to apply.
///
/// Parameter `hotSpot`: Top,left relative location of hotSpot.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaycursorglyphhandler?language=objc)
#[cfg(all(feature = "block2", feature = "objc2-app-kit"))]
pub type PGDisplayCursorGlyphHandler =
    *mut block2::DynBlock<dyn Fn(NonNull<NSBitmapImageRep>, PGDisplayCoord_t)>;

/// A block that will be invoked to handle cursor show/hide updates.
///
/// Parameter `show`: Flag indicating whether to show cursor glyph.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaycursorshowhandler?language=objc)
#[cfg(feature = "block2")]
pub type PGDisplayCursorShowHandler = *mut block2::DynBlock<dyn Fn(Bool)>;

/// A block that will be invoked to handle cursor movement.
///
/// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaycursormovehandler?language=objc)
#[cfg(feature = "block2")]
pub type PGDisplayCursorMoveHandler = *mut block2::DynBlock<dyn Fn()>;

extern_class!(
    /// Descriptor to facilitate creation of PGDisplay.
    ///
    /// See [PGDevice newDisplayWithDescriptor:port:serialNum]
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaydescriptor?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct PGDisplayDescriptor;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for PGDisplayDescriptor {}
);

impl PGDisplayDescriptor {
    extern_methods!(
        /// Client supplied name of display, as seen by guest.
        ///
        /// Truncates to 13 characters.  Defaults to "Apple Virtual".  Value provided here may be made visible via guest UI.
        #[unsafe(method(name))]
        #[unsafe(method_family = none)]
        pub unsafe fn name(&self) -> Option<Retained<NSString>>;

        /// Setter for [`name`][Self::name].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setName:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setName(&self, name: Option<&NSString>);

        /// Client supplied display size conveyed to guest compositor.
        ///
        /// Conveyed size contributes to guest compositor layout, but host-side VM app can scale to UI of its own choosing.
        #[unsafe(method(sizeInMillimeters))]
        #[unsafe(method_family = none)]
        pub unsafe fn sizeInMillimeters(&self) -> NSSize;

        /// Setter for [`sizeInMillimeters`][Self::sizeInMillimeters].
        #[unsafe(method(setSizeInMillimeters:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setSizeInMillimeters(&self, size_in_millimeters: NSSize);

        #[cfg(feature = "dispatch2")]
        /// Client supplied dispatch_queue on which to invoke client supplied blocks.
        ///
        /// Typical client provides serial queue, and redispatches if beneficial to process out of order.
        #[unsafe(method(queue))]
        #[unsafe(method_family = none)]
        pub unsafe fn queue(&self) -> Option<Retained<DispatchQueue>>;

        #[cfg(feature = "dispatch2")]
        /// Setter for [`queue`][Self::queue].
        ///
        /// # Safety
        ///
        /// `queue` possibly has additional threading requirements.
        #[unsafe(method(setQueue:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setQueue(&self, queue: Option<&DispatchQueue>);

        #[cfg(feature = "block2")]
        /// The block to invoke to handle display mode change.
        ///
        /// Handler invocation indicative of display mode change.
        #[unsafe(method(modeChangeHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn modeChangeHandler(&self) -> PGDisplayModeChangeHandler;

        #[cfg(feature = "block2")]
        /// Setter for [`modeChangeHandler`][Self::modeChangeHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `mode_change_handler` must be a valid pointer or null.
        #[unsafe(method(setModeChangeHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setModeChangeHandler(&self, mode_change_handler: PGDisplayModeChangeHandler);

        #[cfg(feature = "block2")]
        /// The block to invoke to handle notification of the presence of a new Guest compositor frame.
        ///
        /// Handler invocation indicates presence of new frame to be processed for display.  Only one of newFrameEventHandler or presentHandler may be non-nil.
        #[unsafe(method(newFrameEventHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn newFrameEventHandler(&self) -> PGDisplayNewFrameEventHandler;

        #[cfg(feature = "block2")]
        /// Setter for [`newFrameEventHandler`][Self::newFrameEventHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `new_frame_event_handler` must be a valid pointer or null.
        #[unsafe(method(setNewFrameEventHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setNewFrameEventHandler(
            &self,
            new_frame_event_handler: PGDisplayNewFrameEventHandler,
        );

        #[cfg(all(feature = "block2", feature = "objc2-app-kit"))]
        /// The block to invoke to handle cursor glyph updates.
        ///
        /// Handler invocation indicative of new cursor image for display.  If this block is not set, cursor will be precomposited in presented image.
        ///
        /// # Safety
        ///
        /// The returned block's argument 1 must be a valid pointer.
        #[unsafe(method(cursorGlyphHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn cursorGlyphHandler(&self) -> PGDisplayCursorGlyphHandler;

        #[cfg(all(feature = "block2", feature = "objc2-app-kit"))]
        /// Setter for [`cursorGlyphHandler`][Self::cursorGlyphHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `cursor_glyph_handler` must be a valid pointer or null.
        #[unsafe(method(setCursorGlyphHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCursorGlyphHandler(
            &self,
            cursor_glyph_handler: PGDisplayCursorGlyphHandler,
        );

        #[cfg(feature = "block2")]
        /// The block to invoke to handle cursor show/hide updates.
        ///
        /// Handler invocation indicative of hide/show of cursor glyph.  If this block is not set, cursor will be precomposited in presented image.
        #[unsafe(method(cursorShowHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn cursorShowHandler(&self) -> PGDisplayCursorShowHandler;

        #[cfg(feature = "block2")]
        /// Setter for [`cursorShowHandler`][Self::cursorShowHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `cursor_show_handler` must be a valid pointer or null.
        #[unsafe(method(setCursorShowHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCursorShowHandler(&self, cursor_show_handler: PGDisplayCursorShowHandler);

        #[cfg(feature = "block2")]
        /// The block to invoke to handle cursor movement.
        ///
        /// Handler invocation indicative of movement.  Handler should resampling via PGDisplay::cursorPosition.
        #[unsafe(method(cursorMoveHandler))]
        #[unsafe(method_family = none)]
        pub unsafe fn cursorMoveHandler(&self) -> PGDisplayCursorMoveHandler;

        #[cfg(feature = "block2")]
        /// Setter for [`cursorMoveHandler`][Self::cursorMoveHandler].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        ///
        /// # Safety
        ///
        /// `cursor_move_handler` must be a valid pointer or null.
        #[unsafe(method(setCursorMoveHandler:))]
        #[unsafe(method_family = none)]
        pub unsafe fn setCursorMoveHandler(&self, cursor_move_handler: PGDisplayCursorMoveHandler);
    );
}

/// Methods declared on superclass `NSObject`.
impl PGDisplayDescriptor {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_class!(
    /// Description of supported display mode.
    ///
    /// Client of PGDisplay can dynamically supply NSArray of PGDisplayMode objects to convey supported modes.  The first mode in array is preferred.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplaymode?language=objc)
    #[unsafe(super(NSObject))]
    #[derive(Debug, PartialEq, Eq, Hash)]
    pub struct PGDisplayMode;
);

extern_conformance!(
    unsafe impl NSObjectProtocol for PGDisplayMode {}
);

impl PGDisplayMode {
    extern_methods!(
        /// Width/height of supported display mode.
        #[unsafe(method(sizeInPixels))]
        #[unsafe(method_family = none)]
        pub unsafe fn sizeInPixels(&self) -> PGDisplayCoord_t;

        /// refreshRate of supported display mode.  Consider only supplying modes using a refreshRate equal to that of host OS's physical display where representation is ultimately shown.
        #[unsafe(method(refreshRate))]
        #[unsafe(method_family = none)]
        pub unsafe fn refreshRate(&self) -> c_double;

        /// Used to conjure up display mode objects (to be arranged into NSArrays for modeList).
        ///
        /// Parameter `sizeInPixels`: Width/height of supported display mode.
        ///
        /// Parameter `refreshRateInHz`: Refresh rate of supported display mode.
        #[unsafe(method(initWithSizeInPixels:refreshRateInHz:))]
        #[unsafe(method_family = init)]
        pub unsafe fn initWithSizeInPixels_refreshRateInHz(
            this: Allocated<Self>,
            size_in_pixels: PGDisplayCoord_t,
            refresh_rate_in_hz: c_double,
        ) -> Option<Retained<PGDisplayMode>>;
    );
}

/// Methods declared on superclass `NSObject`.
impl PGDisplayMode {
    extern_methods!(
        #[unsafe(method(init))]
        #[unsafe(method_family = init)]
        pub unsafe fn init(this: Allocated<Self>) -> Retained<Self>;

        #[unsafe(method(new))]
        #[unsafe(method_family = new)]
        pub unsafe fn new() -> Retained<Self>;
    );
}

extern_protocol!(
    /// Object providing display functionality to guest in a way that host-side VM app can intercept (and process as it chooses).
    ///
    /// The first time the modeList is set for a display, the guest will receive a simulated hot-plug of a display on its port. When this object is freed, the guest will receive a simulated hot-unplug of the display on its port.
    ///
    /// See also [Apple's documentation](https://developer.apple.com/documentation/paravirtualizedgraphics/pgdisplay?language=objc)
    pub unsafe trait PGDisplay: NSObjectProtocol {
        /// The name of the display.
        #[unsafe(method(name))]
        #[unsafe(method_family = none)]
        unsafe fn name(&self) -> Option<Retained<NSString>>;

        /// The size of the display.
        ///
        /// Mostly for debug visibility.
        #[unsafe(method(sizeInMillimeters))]
        #[unsafe(method_family = none)]
        unsafe fn sizeInMillimeters(&self) -> NSSize;

        #[cfg(feature = "dispatch2")]
        /// The dispatch_queue on which to invoke client supplied blocks.
        #[unsafe(method(queue))]
        #[unsafe(method_family = none)]
        unsafe fn queue(&self) -> Option<Retained<DispatchQueue>>;

        #[cfg(feature = "block2")]
        /// The block to invoke to handle display mode change.
        #[unsafe(method(modeChangeHandler))]
        #[unsafe(method_family = none)]
        unsafe fn modeChangeHandler(&self) -> PGDisplayModeChangeHandler;

        #[cfg(feature = "block2")]
        /// The block to invoke to notify presence of new Guest frame to be processed.
        ///
        /// See encodeCurrentFrameToCommandBuffer:texture:region: below to get further processing underway.
        #[unsafe(method(newFrameEventHandler))]
        #[unsafe(method_family = none)]
        unsafe fn newFrameEventHandler(&self) -> PGDisplayNewFrameEventHandler;

        #[cfg(all(feature = "block2", feature = "objc2-app-kit"))]
        /// The block to invoke to handle cursor glyph updates.
        ///
        /// # Safety
        ///
        /// The returned block's argument 1 must be a valid pointer.
        #[unsafe(method(cursorGlyphHandler))]
        #[unsafe(method_family = none)]
        unsafe fn cursorGlyphHandler(&self) -> PGDisplayCursorGlyphHandler;

        #[cfg(feature = "block2")]
        /// The block to invoke to handle cursor show/hide updates.
        #[unsafe(method(cursorShowHandler))]
        #[unsafe(method_family = none)]
        unsafe fn cursorShowHandler(&self) -> PGDisplayCursorShowHandler;

        #[cfg(feature = "block2")]
        /// The block to invoke to handle cursor movement.
        #[unsafe(method(cursorMoveHandler))]
        #[unsafe(method_family = none)]
        unsafe fn cursorMoveHandler(&self) -> PGDisplayCursorMoveHandler;

        /// Top,left display relative position of cursor hotSpot.
        ///
        /// This is a low overhead mechanism to sample cursor location on this display of guest compositor.  Sentinel value for cursor not on display is {0xffff,0xffff}.
        #[unsafe(method(cursorPosition))]
        #[unsafe(method_family = none)]
        unsafe fn cursorPosition(&self) -> PGDisplayCoord_t;

        /// Create-time serialNum of display.
        ///
        /// Mostly for debug visibility.  Param of [PGDevice newDisplayWithDescriptor:port:serialNum].
        #[unsafe(method(serialNum))]
        #[unsafe(method_family = none)]
        unsafe fn serialNum(&self) -> u32;

        /// Create-time port number of display.
        ///
        /// Mostly for debug visibility.  Param of [PGDevice newDisplayWithDescriptor:port:serialNum].
        #[unsafe(method(port))]
        #[unsafe(method_family = none)]
        unsafe fn port(&self) -> NSUInteger;

        #[cfg(feature = "objc2-metal")]
        /// Minimally required textureUsage bits for destination texture of encodeCurrentFrameToCommandBuffer:texture:region:.
        ///
        /// If destination texture doesn't meet this requirement, encodeCurrentFrameToCommandBuffer:texture:region: will fail.
        #[unsafe(method(minimumTextureUsage))]
        #[unsafe(method_family = none)]
        unsafe fn minimumTextureUsage(&self) -> MTLTextureUsage;

        /// The number of frame presents generated by the guest since object creation.
        ///
        /// This value could exceed the number of times newFrameEventHandler block is invoked when host is not encoding frames fast enough to keep up.
        #[unsafe(method(guestPresentCount))]
        #[unsafe(method_family = none)]
        unsafe fn guestPresentCount(&self) -> NSUInteger;

        /// The number of unique frames encoded for present by the host since object creation.
        ///
        /// This value could be smaller than than the count of times encodeCurrentFrameToCommandBuffer:texture:region: is invoked when same frame is encoded multiple times.
        #[unsafe(method(hostPresentCount))]
        #[unsafe(method_family = none)]
        unsafe fn hostPresentCount(&self) -> NSUInteger;

        /// Supported list of display modes.
        ///
        /// This is the only writeable property of display object.  Setting it will update supported mode list (up to 128 modes) and potentially trigger a mode change.  First setting looks like hot-plug.
        #[unsafe(method(modeList))]
        #[unsafe(method_family = none)]
        unsafe fn modeList(&self) -> Retained<NSArray<PGDisplayMode>>;

        /// Setter for [`modeList`][Self::modeList].
        ///
        /// This is [copied][objc2_foundation::NSCopying::copy] when set.
        #[unsafe(method(setModeList:))]
        #[unsafe(method_family = none)]
        unsafe fn setModeList(&self, mode_list: &NSArray<PGDisplayMode>);

        #[cfg(feature = "objc2-metal")]
        /// Encode processing of new frame (to deal with gamma, CSC, and more...), landing it in specific region of specific texture.
        ///
        /// Parameter `commandBuffer`: The Metal command buffer in which to encode processing of new frame.
        ///
        /// Parameter `texture`: The Metal texture in which the processed frame should land.
        ///
        /// Parameter `region`: The region within the Metal texture that the (linear scaled) frame should land in.
        ///
        /// Returns: True if encoding was successful, otherwise, false.
        ///
        /// Client calls this method to direct display object to append encoded display processing Metal pass to client supplied commandBuffer.  Processed frame will land in specified region of client supplied texture.  Nothing outside the specified region will be written.  Note that commandBuffer and texture objects must both be descendants of host Metal device being used for guest acceleration.  Note that texture.textureUsage must contain the bits specified in self.minimumTextureUsage.  See newFrameEventHandler above since it notifies client of the existence of a new frame.
        ///
        /// # Safety
        ///
        /// - `texture` may need to be synchronized.
        /// - `texture` may be unretained, you must ensure it is kept alive while in use.
        #[unsafe(method(encodeCurrentFrameToCommandBuffer:texture:region:))]
        #[unsafe(method_family = none)]
        unsafe fn encodeCurrentFrameToCommandBuffer_texture_region(
            &self,
            command_buffer: &ProtocolObject<dyn MTLCommandBuffer>,
            texture: &ProtocolObject<dyn MTLTexture>,
            region: MTLRegion,
        ) -> bool;
    }
);