jawt-binding/io.github.mimimishkin.jni.binding.awt

Package-level declarations

Bindings for JAWT - access to the native structures behind AWT (java.awt), used for native rendering onto a component or for hand-off of a native window to AWT.

Constants and versions

All constants live on the JAWT object:

Versions: JAWT.v3 (1.3), JAWT.v4 (1.4), JAWT.v7 (1.7), JAWT.v9 (9). Pass one to getAwt / withAwt; newer versions unlock extra entry points (Lock/Unlock/GetComponent from 1.4, embedding from 9).
Lock result flags returned by DrawingSurface.lock: JAWT.LOCK_ERROR, JAWT.LOCK_CLIP_CHANGED, JAWT.LOCK_BOUNDS_CHANGED, JAWT.LOCK_SURFACE_CHANGED.

Typical rendering loop

Obtain the Awt interface, take a DrawingSurface for a java.awt.Component (usually a Canvas or Window), lock it, and read the platform-specific DrawingSurfaceInfo. Session helpers acquire and release everything for you:

// context(env: JniEnv, memScope: MemScope)
withAwt(JAWT.v9) { awt ->
    awt.useDrawingSurface(component) { surface ->
        surface.locking {
            surface.useInfo { info ->
                // info.bounds, info.clipRects, ...
                // platform members: hwnd/hdc on Windows, display/drawable on Linux, layer on macOS
                // draw...
            }
        }
    }
}

Or in one call: Awt.useDrawingSurfaceInfo.

All operations on a DrawingSurface must run on the same thread that obtained it via getDrawingSurface. When calling lock / unlock / getInfo / freeInfo from another thread, set DrawingSurface.env to that thread's JniEnv first.

Session helpers

Helper	Role
withAwt	getAwt + throw if the VM does not expose JAWT
Awt.locking	lock / unlock the entire AWT (since 1.4)
Awt.useDrawingSurface	getDrawingSurface + freeDrawingSurface
DrawingSurface.locking	lock + unlock; throws on JAWT.LOCK_ERROR
DrawingSurface.useInfo	getInfo + freeInfo
Awt.useDrawingSurfaceInfo	surface + lock + info stacked together

Low-level entry points (getAwt, getDrawingSurface, lock, getInfo, …) remain available when you need finer control or want to cache the surface across frames.

Embedding a native window into AWT

Since JAWT 9, a native container can host an AWT Frame:

Awt.createEmbeddedFrame - create a java.awt.Frame inside a native parent (HWND / Drawable / NSWindow).
Awt.setBounds - move/resize that embedded frame relative to the native parent (Component.setBounds alone keeps embedded frames at (0, 0) for compatibility).
Awt.synthesizeWindowActivation - synthesize activate / deactivate for the embedded frame.

The reverse direction - resolve a java.awt.Component from a native handle - is Awt.getComponent (since 1.4).

Platform handles passed to embedding / getComponent:

Platform	Handle
Windows	`HWND`
Linux	X11 `Drawable`
macOS	`NSWindow`

Platform-specific DrawingSurfaceInfo members

Each desktop source set exposes the native structure members directly on DrawingSurfaceInfo - no platformInfo cast:

Windows (mingwMain):

hwnd - window handle (mutually exclusive with hbitmap / pbits)
hbitmap - DDB handle
pbits - DIB bits pointer
hdc - preferred device context (use instead of BeginPaint / GetDC)
hpalette

Linux (linuxMain):

drawable, display, visualID, colormapID, depth
GetAWTColor - RGB → pixel for paletted modes (since 1.4)

macOS (macosMain):

layer / windowLayer - CALayer of the surface / window

Types

Awt - the JAWT interface pointer returned by getAwt.
DrawingSurface - drawing surface of a JAwtComponent; must be freed with freeDrawingSurface.
DrawingSurfaceInfo - bounds, clip rectangles (clipRects / clipSize) and platform info; must be freed with freeInfo.
AwtRectangle - { x, y, width, height } used by bounds and clip.
JAwtComponent / JAwtFrame - typed JObject aliases for java.awt.Component / java.awt.Frame.

Bindings for JAWT - access to the native structures behind AWT (java.awt), used for native rendering onto a component or for hand-off of a native window to AWT.

Constants and versions

All constants live on the JAWT object:

Versions: JAWT.v3 (1.3), JAWT.v4 (1.4), JAWT.v7 (1.7), JAWT.v9 (9). Pass one to getAwt / withAwt; newer versions unlock extra entry points (Lock/Unlock/GetComponent from 1.4, embedding from 9).
Lock result flags returned by DrawingSurface.lock: JAWT.LOCK_ERROR, JAWT.LOCK_CLIP_CHANGED, JAWT.LOCK_BOUNDS_CHANGED, JAWT.LOCK_SURFACE_CHANGED.

Typical rendering loop

// context(env: JniEnv, memScope: MemScope)
withAwt(JAWT.v9) { awt ->
    awt.useDrawingSurface(component) { surface ->
        surface.locking {
            surface.useInfo { info ->
                // info.bounds, info.clipRects, ...
                // platform members: hwnd/hdc on Windows, display/drawable on Linux, layer on macOS
                // draw...
            }
        }
    }
}

Or in one call: Awt.useDrawingSurfaceInfo.

Session helpers

Helper	Role
withAwt	getAwt + throw if the VM does not expose JAWT
Awt.locking	lock / unlock the entire AWT (since 1.4)
Awt.useDrawingSurface	getDrawingSurface + freeDrawingSurface
DrawingSurface.locking	lock + unlock; throws on JAWT.LOCK_ERROR
DrawingSurface.useInfo	getInfo + freeInfo
Awt.useDrawingSurfaceInfo	surface + lock + info stacked together

Low-level entry points (getAwt, getDrawingSurface, lock, getInfo, …) remain available when you need finer control or want to cache the surface across frames.

Embedding a native window into AWT

Since JAWT 9, a native container can host an AWT Frame:

Awt.createEmbeddedFrame - create a java.awt.Frame inside a native parent (HWND / Drawable / NSWindow).
Awt.setBounds - move/resize that embedded frame relative to the native parent (Component.setBounds alone keeps embedded frames at (0, 0) for compatibility).
Awt.synthesizeWindowActivation - synthesize activate / deactivate for the embedded frame.

The reverse direction - resolve a java.awt.Component from a native handle - is Awt.getComponent (since 1.4).

Platform handles passed to embedding / getComponent:

Platform	Handle
Windows	`HWND`
Linux	X11 `Drawable`
macOS	`NSWindow`

Platform-specific DrawingSurfaceInfo members

Each desktop source set exposes the native structure members directly on DrawingSurfaceInfo - no platformInfo cast:

Windows (mingwMain):

hwnd - window handle (mutually exclusive with hbitmap / pbits)
hbitmap - DDB handle
pbits - DIB bits pointer
hdc - preferred device context (use instead of BeginPaint / GetDC)
hpalette

Linux (linuxMain):

drawable, display, visualID, colormapID, depth
GetAWTColor - RGB → pixel for paletted modes (since 1.4)

macOS (macosMain):

layer / windowLayer - CALayer of the surface / window

Types

Awt - the JAWT interface pointer returned by getAwt.
DrawingSurface - drawing surface of a JAwtComponent; must be freed with freeDrawingSurface.
DrawingSurfaceInfo - bounds, clip rectangles (clipRects / clipSize) and platform info; must be freed with freeInfo.
AwtRectangle - { x, y, width, height } used by bounds and clip.
JAwtComponent / JAwtFrame - typed JObject aliases for java.awt.Component / java.awt.Frame.

Bindings for JAWT - access to the native structures behind AWT (java.awt), used for native rendering onto a component or for hand-off of a native window to AWT.

Constants and versions

All constants live on the JAWT object:

Versions: JAWT.v3 (1.3), JAWT.v4 (1.4), JAWT.v7 (1.7), JAWT.v9 (9). Pass one to getAwt / withAwt; newer versions unlock extra entry points (Lock/Unlock/GetComponent from 1.4, embedding from 9).
Lock result flags returned by DrawingSurface.lock: JAWT.LOCK_ERROR, JAWT.LOCK_CLIP_CHANGED, JAWT.LOCK_BOUNDS_CHANGED, JAWT.LOCK_SURFACE_CHANGED.

Typical rendering loop

// context(env: JniEnv, memScope: MemScope)
withAwt(JAWT.v9) { awt ->
    awt.useDrawingSurface(component) { surface ->
        surface.locking {
            surface.useInfo { info ->
                // info.bounds, info.clipRects, ...
                // platform members: hwnd/hdc on Windows, display/drawable on Linux, layer on macOS
                // draw...
            }
        }
    }
}

Or in one call: Awt.useDrawingSurfaceInfo.

Session helpers

Helper	Role
withAwt	getAwt + throw if the VM does not expose JAWT
Awt.locking	lock / unlock the entire AWT (since 1.4)
Awt.useDrawingSurface	getDrawingSurface + freeDrawingSurface
DrawingSurface.locking	lock + unlock; throws on JAWT.LOCK_ERROR
DrawingSurface.useInfo	getInfo + freeInfo
Awt.useDrawingSurfaceInfo	surface + lock + info stacked together

Low-level entry points (getAwt, getDrawingSurface, lock, getInfo, …) remain available when you need finer control or want to cache the surface across frames.

Embedding a native window into AWT

Since JAWT 9, a native container can host an AWT Frame:

Awt.createEmbeddedFrame - create a java.awt.Frame inside a native parent (HWND / Drawable / NSWindow).
Awt.setBounds - move/resize that embedded frame relative to the native parent (Component.setBounds alone keeps embedded frames at (0, 0) for compatibility).
Awt.synthesizeWindowActivation - synthesize activate / deactivate for the embedded frame.

The reverse direction - resolve a java.awt.Component from a native handle - is Awt.getComponent (since 1.4).

Platform handles passed to embedding / getComponent:

Platform	Handle
Windows	`HWND`
Linux	X11 `Drawable`
macOS	`NSWindow`

Platform-specific DrawingSurfaceInfo members

Each desktop source set exposes the native structure members directly on DrawingSurfaceInfo - no platformInfo cast:

Windows (mingwMain):

hwnd - window handle (mutually exclusive with hbitmap / pbits)
hbitmap - DDB handle
pbits - DIB bits pointer
hdc - preferred device context (use instead of BeginPaint / GetDC)
hpalette

Linux (linuxMain):

drawable, display, visualID, colormapID, depth
GetAWTColor - RGB → pixel for paletted modes (since 1.4)

macOS (macosMain):

layer / windowLayer - CALayer of the surface / window

Types

Awt - the JAWT interface pointer returned by getAwt.
DrawingSurface - drawing surface of a JAwtComponent; must be freed with freeDrawingSurface.
DrawingSurfaceInfo - bounds, clip rectangles (clipRects / clipSize) and platform info; must be freed with freeInfo.
AwtRectangle - { x, y, width, height } used by bounds and clip.
JAwtComponent / JAwtFrame - typed JObject aliases for java.awt.Component / java.awt.Frame.

Bindings for JAWT - access to the native structures behind AWT (java.awt), used for native rendering onto a component or for hand-off of a native window to AWT.

Constants and versions

All constants live on the JAWT object:

Versions: JAWT.v3 (1.3), JAWT.v4 (1.4), JAWT.v7 (1.7), JAWT.v9 (9). Pass one to getAwt / withAwt; newer versions unlock extra entry points (Lock/Unlock/GetComponent from 1.4, embedding from 9).
Lock result flags returned by DrawingSurface.lock: JAWT.LOCK_ERROR, JAWT.LOCK_CLIP_CHANGED, JAWT.LOCK_BOUNDS_CHANGED, JAWT.LOCK_SURFACE_CHANGED.

Typical rendering loop

// context(env: JniEnv, memScope: MemScope)
withAwt(JAWT.v9) { awt ->
    awt.useDrawingSurface(component) { surface ->
        surface.locking {
            surface.useInfo { info ->
                // info.bounds, info.clipRects, ...
                // platform members: hwnd/hdc on Windows, display/drawable on Linux, layer on macOS
                // draw...
            }
        }
    }
}

Or in one call: Awt.useDrawingSurfaceInfo.

Session helpers

Helper	Role
withAwt	getAwt + throw if the VM does not expose JAWT
Awt.locking	lock / unlock the entire AWT (since 1.4)
Awt.useDrawingSurface	getDrawingSurface + freeDrawingSurface
DrawingSurface.locking	lock + unlock; throws on JAWT.LOCK_ERROR
DrawingSurface.useInfo	getInfo + freeInfo
Awt.useDrawingSurfaceInfo	surface + lock + info stacked together

Low-level entry points (getAwt, getDrawingSurface, lock, getInfo, …) remain available when you need finer control or want to cache the surface across frames.

Embedding a native window into AWT

Since JAWT 9, a native container can host an AWT Frame:

Awt.createEmbeddedFrame - create a java.awt.Frame inside a native parent (HWND / Drawable / NSWindow).
Awt.setBounds - move/resize that embedded frame relative to the native parent (Component.setBounds alone keeps embedded frames at (0, 0) for compatibility).
Awt.synthesizeWindowActivation - synthesize activate / deactivate for the embedded frame.

The reverse direction - resolve a java.awt.Component from a native handle - is Awt.getComponent (since 1.4).

Platform handles passed to embedding / getComponent:

Platform	Handle
Windows	`HWND`
Linux	X11 `Drawable`
macOS	`NSWindow`

Platform-specific DrawingSurfaceInfo members

Each desktop source set exposes the native structure members directly on DrawingSurfaceInfo - no platformInfo cast:

Windows (mingwMain):

hwnd - window handle (mutually exclusive with hbitmap / pbits)
hbitmap - DDB handle
pbits - DIB bits pointer
hdc - preferred device context (use instead of BeginPaint / GetDC)
hpalette

Linux (linuxMain):

drawable, display, visualID, colormapID, depth
GetAWTColor - RGB → pixel for paletted modes (since 1.4)

macOS (macosMain):

layer / windowLayer - CALayer of the surface / window

Types

Awt - the JAWT interface pointer returned by getAwt.
DrawingSurface - drawing surface of a JAwtComponent; must be freed with freeDrawingSurface.
DrawingSurfaceInfo - bounds, clip rectangles (clipRects / clipSize) and platform info; must be freed with freeInfo.
AwtRectangle - { x, y, width, height } used by bounds and clip.
JAwtComponent / JAwtFrame - typed JObject aliases for java.awt.Component / java.awt.Frame.

Bindings for JAWT - access to the native structures behind AWT (java.awt), used for native rendering onto a component or for hand-off of a native window to AWT.

Constants and versions

All constants live on the JAWT object:

Versions: JAWT.v3 (1.3), JAWT.v4 (1.4), JAWT.v7 (1.7), JAWT.v9 (9). Pass one to getAwt / withAwt; newer versions unlock extra entry points (Lock/Unlock/GetComponent from 1.4, embedding from 9).
Lock result flags returned by DrawingSurface.lock: JAWT.LOCK_ERROR, JAWT.LOCK_CLIP_CHANGED, JAWT.LOCK_BOUNDS_CHANGED, JAWT.LOCK_SURFACE_CHANGED.

Typical rendering loop

// context(env: JniEnv, memScope: MemScope)
withAwt(JAWT.v9) { awt ->
    awt.useDrawingSurface(component) { surface ->
        surface.locking {
            surface.useInfo { info ->
                // info.bounds, info.clipRects, ...
                // platform members: hwnd/hdc on Windows, display/drawable on Linux, layer on macOS
                // draw...
            }
        }
    }
}

Or in one call: Awt.useDrawingSurfaceInfo.

Session helpers

Helper	Role
withAwt	getAwt + throw if the VM does not expose JAWT
Awt.locking	lock / unlock the entire AWT (since 1.4)
Awt.useDrawingSurface	getDrawingSurface + freeDrawingSurface
DrawingSurface.locking	lock + unlock; throws on JAWT.LOCK_ERROR
DrawingSurface.useInfo	getInfo + freeInfo
Awt.useDrawingSurfaceInfo	surface + lock + info stacked together

Low-level entry points (getAwt, getDrawingSurface, lock, getInfo, …) remain available when you need finer control or want to cache the surface across frames.

Embedding a native window into AWT

Since JAWT 9, a native container can host an AWT Frame:

Awt.createEmbeddedFrame - create a java.awt.Frame inside a native parent (HWND / Drawable / NSWindow).
Awt.setBounds - move/resize that embedded frame relative to the native parent (Component.setBounds alone keeps embedded frames at (0, 0) for compatibility).
Awt.synthesizeWindowActivation - synthesize activate / deactivate for the embedded frame.

The reverse direction - resolve a java.awt.Component from a native handle - is Awt.getComponent (since 1.4).

Platform handles passed to embedding / getComponent:

Platform	Handle
Windows	`HWND`
Linux	X11 `Drawable`
macOS	`NSWindow`

Platform-specific DrawingSurfaceInfo members

Each desktop source set exposes the native structure members directly on DrawingSurfaceInfo - no platformInfo cast:

Windows (mingwMain):

hwnd - window handle (mutually exclusive with hbitmap / pbits)
hbitmap - DDB handle
pbits - DIB bits pointer
hdc - preferred device context (use instead of BeginPaint / GetDC)
hpalette

Linux (linuxMain):

drawable, display, visualID, colormapID, depth
GetAWTColor - RGB → pixel for paletted modes (since 1.4)

macOS (macosMain):

layer / windowLayer - CALayer of the surface / window

Types

Awt - the JAWT interface pointer returned by getAwt.
DrawingSurface - drawing surface of a JAwtComponent; must be freed with freeDrawingSurface.
DrawingSurfaceInfo - bounds, clip rectangles (clipRects / clipSize) and platform info; must be freed with freeInfo.
AwtRectangle - { x, y, width, height } used by bounds and clip.
JAwtComponent / JAwtFrame - typed JObject aliases for java.awt.Component / java.awt.Frame.

Types

_jawtComponent

open class _jawtComponent(rawPtr: NativePtr) : _jobject

The underlying open opaque type for JAwtComponent.

_jawtFrame

open class _jawtFrame(rawPtr: NativePtr) : _jawtComponent

The underlying open opaque type for JAwtFrame.

Awt

typealias Awt = CPointer<Raw_Awt>

AWT native interface.

AwtRectangle

actual typealias AwtRectangle = jawt_Rectangle

typealias AwtRectangle = jawt_Rectangle

Structure for a native rectangle.

expect class AwtRectangle : CStructVar

Structure for a native rectangle.

AwtVersion

typealias AwtVersion = Int

Java version that corresponds to the new JAWT API.

DrawingSurface

typealias DrawingSurface = CPointer<Raw_DrawingSurface>

Contains the underlying drawing information of a component.

DrawingSurfaceInfo

typealias DrawingSurfaceInfo = CPointer<Raw_DrawingSurfaceInfo>

Contains the underlying drawing information of a component.

JAWT

object JAWT

Functions and utilities to work with JAWT (Java Abstract Window Toolkit).

JAwtComponent

typealias JAwtComponent = JRef<_jawtComponent>

Pointer to java.awt.Component.

JAwtFrame

typealias JAwtFrame = JRef<_jawtComponent>

Pointer to java.awt.Frame.

Raw_Awt

actual typealias Raw_Awt = jawt

typealias Raw_Awt = jawt

The underlying type for Awt.

expect class Raw_Awt : CStructVar

The underlying type for Awt.

Raw_DrawingSurface

actual typealias Raw_DrawingSurface = jawt_DrawingSurface

typealias Raw_DrawingSurface = jawt_DrawingSurface

The underlying type for DrawingSurface.

expect class Raw_DrawingSurface : CStructVar

The underlying type for DrawingSurface.

Raw_DrawingSurfaceInfo

actual typealias Raw_DrawingSurfaceInfo = jawt_DrawingSurfaceInfo

typealias Raw_DrawingSurfaceInfo = jawt_DrawingSurfaceInfo

The underlying type for DrawingSurfaceInfo.

expect class Raw_DrawingSurfaceInfo : CStructVar

The underlying type for DrawingSurfaceInfo.

Properties

bounds

val DrawingSurfaceInfo.bounds: AwtRectangle

Bounding rectangle of the drawing surface.

clip

val DrawingSurfaceInfo.clip: CArrayPointer<AwtRectangle>

Clip rectangle C array.

clipRects

val DrawingSurfaceInfo.clipRects: List<AwtRectangle>

Clip rectangle list.

clipSize

val DrawingSurfaceInfo.clipSize: Int

Number of rectangles in the clip.

colormapID

val DrawingSurfaceInfo.colormapID: Colormap

depth

val DrawingSurfaceInfo.depth: Int

display

val DrawingSurfaceInfo.display: CPointer<Display>

drawable

val DrawingSurfaceInfo.drawable: Drawable

env

var DrawingSurface.env: JniEnv

Cached reference to the Java environment of the calling thread. If lock, unlock, getInfo or freeInfo are called from a different thread, this data member should be set before calling those functions.

hbitmap

val DrawingSurfaceInfo.hbitmap: HBITMAP

DDB handle.

hdc

val DrawingSurfaceInfo.hdc: HDC

This HDC should always be used instead of the HDC returned from BeginPaint() or any calls to GetDC().

hpalette

val DrawingSurfaceInfo.hpalette: HPALETTE

hwnd

val DrawingSurfaceInfo.hwnd: HWND

Native window handle.

layer

var DrawingSurfaceInfo.layer: CALayer

pbits

val DrawingSurfaceInfo.pbits: COpaquePointer

DIB handle.

surface

val DrawingSurfaceInfo.surface: DrawingSurface

Cached pointer to the underlying drawing surface.

target

val DrawingSurface.target: JAwtComponent

Cached reference to the target object.

version

val Awt.version: AwtVersion

Version of AWT.

visualID

val DrawingSurfaceInfo.visualID: VisualID

windowLayer

val DrawingSurfaceInfo.windowLayer: CALayer

Functions

createEmbeddedFrame

context(env: JniEnv)
fun Awt.createEmbeddedFrame(platformInfo: COpaquePointer): JAwtFrame?

Creates a java.awt.Frame placed in a native container. Container is referenced by the native platform handle:

freeDrawingSurface

fun Awt.freeDrawingSurface(surface: DrawingSurface)

Free the drawing surface allocated in getDrawingSurface.

freeInfo

fun DrawingSurface.freeInfo(info: DrawingSurfaceInfo)

Free the drawing surface info.

getAwt

context(env: JniEnv, placement: NativePlacement)
fun getAwt(version: AwtVersion): Awt?

Get the AWT native structure.

GetAWTColor

fun DrawingSurfaceInfo.GetAWTColor(r: Int, g: Int, b: Int): Int

Returns a pixel value from a set of RGB values. This is useful for paletted color (256 color) modes.

getComponent

context(env: JniEnv)
fun Awt.getComponent(platformInfo: COpaquePointer): JAwtComponent?

Returns a reference to a java.awt.Component from a native platform handle:

getDrawingSurface

context(env: JniEnv)
fun Awt.getDrawingSurface(target: JAwtComponent): DrawingSurface?

Return a drawing surface from a target JAwtComponent. This value may be cached.

getInfo

fun DrawingSurface.getInfo(): DrawingSurfaceInfo?

Get the drawing surface info. The value returned may be cached, but the values may change if additional calls to lock or unlock are made.

lock

context(env: JniEnv)
fun Awt.lock()

Locks the entire AWT for synchronization purposes.

fun DrawingSurface.lock(): Int

Lock the surface of the target component for native rendering. When finished drawing, the surface must be unlocked with unlock).

locking

context(env: JniEnv)
inline fun <T> Awt.locking(block: () -> T): T

Locks the entire AWT, executes block and then release lock.

inline fun <T> DrawingSurface.locking(block: context(JniEnv) () -> T): T

Locks the surface and executes block, then release lock.

setBounds

context(env: JniEnv)
fun Awt.setBounds(embeddedFrame: JAwtFrame, x: Int, y: Int, w: Int, h: Int)

Moves and resizes the embedded frame. The new location of the top-left corner is specified by x and y parameters relative to the native parent component. The new size is specified by width and height.

synthesizeWindowActivation

context(env: JniEnv)
fun Awt.synthesizeWindowActivation(embeddedFrame: JAwtFrame, doActivate: Boolean)

Synthesize a native message to activate or deactivate an EmbeddedFrame window. If doActivate is true activates the window, otherwise, deactivates the window.

unlock

context(env: JniEnv)
fun Awt.unlock()

Unlocks the entire AWT for synchronization purposes.

fun DrawingSurface.unlock()

Unlock the drawing surface of the target component for native rendering.

useDrawingSurface

context(env: JniEnv)
inline fun <T> Awt.useDrawingSurface(target: JAwtComponent, block: (DrawingSurface) -> T): T

Gets a DrawingSurface from a target JAwtComponent and executes block with it. Then safely release the surface.

useDrawingSurfaceInfo

context(env: JniEnv)
inline fun <T> Awt.useDrawingSurfaceInfo(target: JAwtComponent, block: DrawingSurface.(DrawingSurfaceInfo) -> T): T

Alias for stacking Awt.useDrawingSurface, DrawingSurface.locking and DrawingSurface.useInfo.

useInfo

inline fun <T> DrawingSurface.useInfo(block: (DrawingSurfaceInfo) -> T): T

Gets a DrawingSurfaceInfo and executes block, then release the surface info.

withAwt

context(env: JniEnv, placement: NativePlacement)
inline fun <T> withAwt(version: AwtVersion, block: (Awt) -> T): T

Receive Awt from JniEnv and executes block with it.