korge/korlibs.render.awt/BaseAwtGameWindow

BaseAwtGameWindow

abstract class BaseAwtGameWindow(val ag: AGOpengl) : GameWindow, ClipboardOwner

Inheritors

GLCanvasGameWindow

Constructors

BaseAwtGameWindow

constructor(ag: AGOpengl)

Properties

open override val ag: AGOpengl

open var alwaysOnTop: Boolean

androidContextAny

open val androidContextAny: Any?

open override var bgcolor: RGBA

open val bufferHeight: Int

open val bufferWidth: Int

val clipboard: Clipboard

abstract val component: Component

computedPixelRatio

open val computedPixelRatio: Double

contentComponent

abstract val contentComponent: Component

continuousRenderMode

open var continuousRenderMode: Boolean

coroutineDispatcher

open val coroutineDispatcher: GameWindowCoroutineDispatcher

counterTimePerFrame

val counterTimePerFrame: TimeSpan

open val ctx: BaseOpenglContext? = null

open override var cursor: GameWindow.ICursor

open var debug: Boolean

open val debugComponent: Any? = null

devicePixelRatio

open override val devicePixelRatio: Double

dialogInterface

open override val dialogInterface: DialogInterface

displayLinkLock

var displayLinkLock: Object?

eventListenerParent

var eventListenerParent: BaseEventListener?

var exitCode: Int

exitProcessOnClose

var exitProcessOnClose: Boolean

open override var extra: ExtraType

open var fps: Int

frameScaleFactor

val frameScaleFactor: Float

open var fullscreen: Boolean

val fvsync: Boolean

val gamepadEmitter: GamepadInfoEmitter

var gamePadTime: TimeSpan

gameWindowAndroidContext

val GameWindow.gameWindowAndroidContext: Context

gameWindowAndroidContextOrNull

val GameWindow.gameWindowAndroidContextOrNull: Context?

hapticFeedbackGenerateSupport

open override val hapticFeedbackGenerateSupport: Boolean

open override val height: Int

open var icon: Bitmap?

isSoftKeyboardVisible

open val isSoftKeyboardVisible: Boolean

open var keepScreenOn: Boolean

Flag to keep the screen on, even when there is no user input and the user is idle

open override val key: CoroutineContext.Key<*>

mustTriggerRender

val mustTriggerRender: Boolean

myCoroutineDispatcher

open val myCoroutineDispatcher: SyncEventLoopCoroutineDispatcher

nonScaledHeight

val nonScaledHeight: Double

val nonScaledWidth: Double

onContinuousRenderModeUpdated

var onContinuousRenderModeUpdated: (Boolean) -> Unit?

val onDebugChanged: Signal<Boolean>

val onDebugEnabled: Signal<Unit>

paintInContextDelegate

val paintInContextDelegate: (Graphics, BaseOpenglContext.ContextInfo) -> Unit

open val pixelsPerCm: Double

Approximate on iOS

open override val pixelsPerInch: Double

Approximate on iOS

pixelsPerLogicalInchRatio

open override val pixelsPerLogicalInchRatio: Double

open var preferredFps: Int

open override var quality: GameWindow.Quality

var renderTime: Duration

var reshaped: Boolean

var running: Boolean

val scaledHeight: Float

val scaledWidth: Float

val state: KmlGlState

val timePerFrame: TimeSpan

open var title: String

updatedSinceFrame

var updatedSinceFrame: Int

var updateTime: Duration

open override var visible: Boolean

open var vsync: Boolean

open override val width: Int

val window: Window?

windowOrComponent

val windowOrComponent: Component

Functions

suspend fun DialogInterfaceProvider.alert(message: String)

suspend fun DialogInterfaceProvider.alertError(e: Throwable)

suspend fun DialogInterfaceProvider.browse(url: URL)

fun clearEvents()

fun <T : BEvent> clearEvents(type: EventType<T>)

open suspend override fun clipboardRead(): ClipboardData?

open suspend override fun clipboardWrite(data: ClipboardData)

open fun close(exitCode: Int = 0)

computeDisplayRefreshRate

open override fun computeDisplayRefreshRate(): Int

fun GameWindow.configure(size: Size, title: String? = "GameWindow", icon: Bitmap? = null, fullscreen: Boolean? = null, bgcolor: RGBA = Colors.BLACK)

suspend fun DialogInterfaceProvider.confirm(message: String): Boolean

override fun <T : BEvent> dispatch(event: T): Boolean

override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?): Boolean

open override fun <T : BEvent> dispatch(type: EventType<T>, event: T, result: EventResult?, up: Boolean, down: Boolean): Boolean

Dispatched a event of type that will execute all the handlers registered with onEvents in this object and its children.

dispatchChildren

open fun <T : BEvent> dispatchChildren(type: EventType<T>, event: T, result: EventResult?)

dispatchDestroyEvent

fun dispatchDestroyEvent(): Boolean

dispatchDisposeEvent

fun dispatchDisposeEvent(): Boolean

open fun <T : BEvent> dispatchDown(type: EventType<T>, event: T, result: EventResult? = null): Boolean

fun <T : BEvent> EventListener.dispatchDown(event: T): Boolean

dispatchDropfileEvent

fun dispatchDropfileEvent(type: DropFileEvent.Type, files: List<VfsFile>?): Boolean

dispatchFullscreenEvent

fun dispatchFullscreenEvent(fullscreen: Boolean): Boolean

dispatchGamepadUpdateAdd

fun dispatchGamepadUpdateAdd(info: GamepadInfo)

dispatchGamepadUpdateEnd

fun dispatchGamepadUpdateEnd(out: IntArrayList = IntArrayList()): IntArrayList

Triggers an update envent and potential CONNECTED/DISCONNECTED events.

dispatchGamepadUpdateStart

fun dispatchGamepadUpdateStart()

dispatchInitEvent

fun dispatchInitEvent(): Boolean

dispatchKeyEvent

fun dispatchKeyEvent(type: KeyEvent.Type, id: Int, character: Char, key: Key, keyCode: Int, str: String? = null): Boolean

dispatchKeyEventDownUp

fun dispatchKeyEventDownUp(id: Int, character: Char, key: Key, keyCode: Int, str: String? = null): Boolean

dispatchKeyEventEx

fun dispatchKeyEventEx(type: KeyEvent.Type, id: Int, character: Char, key: Key, keyCode: Int, shift: Boolean = this.shift, ctrl: Boolean = this.ctrl, alt: Boolean = this.alt, meta: Boolean = this.meta, str: String? = null): Boolean

dispatchMouseEvent

fun dispatchMouseEvent(type: MouseEvent.Type, id: Int, x: Int, y: Int, button: MouseButton, buttons: Int = this.mouseButtons, scrollDeltaX: Float = this.scrollDeltaX, scrollDeltaY: Float = this.scrollDeltaY, scrollDeltaZ: Float = this.scrollDeltaZ, isShiftDown: Boolean = this.shift, isCtrlDown: Boolean = this.ctrl, isAltDown: Boolean = this.alt, isMetaDown: Boolean = this.meta, scaleCoords: Boolean = this.scaleCoords, simulateClickOnUp: Boolean = false, scrollDeltaMode: MouseEvent.ScrollDeltaMode = MouseEvent.ScrollDeltaMode.LINE)

dispatchNewRenderEvent

fun dispatchNewRenderEvent()

open fun <T : BEvent> dispatchParent(type: EventType<T>, event: T, result: EventResult?)

dispatchPauseEvent

fun dispatchPauseEvent(): Boolean

dispatchRenderEvent

fun dispatchRenderEvent(update: Boolean = true, render: Boolean = true)

dispatchReshapeEvent

fun dispatchReshapeEvent(x: Int, y: Int, width: Int, height: Int)

fun dispatchReshapeEvent()

dispatchReshapeEventEx

fun dispatchReshapeEventEx(x: Int, y: Int, width: Int, height: Int, fullWidth: Int, fullHeight: Int)

dispatchResumeEvent

fun dispatchResumeEvent(): Boolean

dispatchSimpleMouseEvent

fun dispatchSimpleMouseEvent(type: MouseEvent.Type, id: Int, x: Int, y: Int, button: MouseButton, simulateClickOnUp: Boolean = false)

dispatchStopEvent

fun dispatchStopEvent(): Boolean

open fun <T : BEvent> dispatchUp(type: EventType<T>, event: T, result: EventResult? = null): Boolean

fun <T : BEvent> EventListener.dispatchUp(event: T): Boolean

dispatchUpdateEvent

fun dispatchUpdateEvent()

dispatchWithResult

override fun <T : BEvent> dispatchWithResult(event: T, out: EventResult): EventResult

fun entry(callback: suspend () -> Unit)

eventQueueLater

suspend fun <T> eventQueueLater(block: () -> T): T

fun executePending(availableTime: TimeSpan)

fun exit(exitCode: Int = 0)

open override fun <R> fold(initial: R, operation: (R, CoroutineContext.Element) -> R): R

fun frame(doUpdate: Boolean = true, doRender: Boolean = true, frameStartTime: TimeSpan = PerformanceCounter.reference): TimeSpan

open fun frameDispose()

fun framePaint(g: Graphics)

fun frameRender(doUpdate: Boolean = true, doRender: Boolean = true)

fun frameUpdate(startTime: TimeSpan)

open operator override fun <E : CoroutineContext.Element> get(key: CoroutineContext.Key<E>): E?

getCoroutineDispatcherWithCurrentContext

suspend fun getCoroutineDispatcherWithCurrentContext(): CoroutineContext

fun getCoroutineDispatcherWithCurrentContext(coroutineContext: CoroutineContext): CoroutineContext

getSelfEventCount

fun getSelfEventCount(type: EventType<*>): Int

handleContextLost

fun handleContextLost()

handleInitEventIfRequired

fun handleInitEventIfRequired()

handleReshapeEventIfRequired

fun handleReshapeEventIfRequired(x: Int, y: Int, width: Int, height: Int)

hapticFeedbackGenerate

open override fun hapticFeedbackGenerate(kind: GameWindow.HapticFeedbackKind)

fun hide()

hideSoftKeyboard

open fun hideSoftKeyboard()

invalidatedView

fun invalidatedView()

open suspend override fun loop(entry: suspend GameWindow.() -> Unit)

open override fun lostOwnership(clipboard: Clipboard?, contents: Transferable?)

fun GameWindow.mainLoop(entry: suspend GameWindow.() -> Unit): AsyncEntryPointResult

open override fun minusKey(key: CoroutineContext.Key<*>): CoroutineContext

onDragAndDropFileEvent

fun GameWindow.onDragAndDropFileEvent(block: suspend (DropFileEvent) -> Unit)

override fun <T : BEvent> onEvent(type: EventType<T>, handler: (T) -> Unit): CloseableCancellable

Registers a handler block to be executed when an event of type is dispatched

override fun onEventCount(type: EventType<*>): Int

open fun <T : BEvent> onEvents(vararg etypes: EventType<out T>, handler: (T) -> Unit): Closeable

override fun onEventsCount(): FastIdentityMap<EventType<*>, Int>?

fun onRenderEvent(block: (RenderEvent) -> Unit): Closeable

Happens on the rendering thread

fun onUpdateEvent(block: (UpdateEvent) -> Unit): Closeable

Happens on the updater thread

suspend fun DialogInterfaceProvider.openFileDialog(filter: String? = null, write: Boolean = false, multi: Boolean = false): List<VfsFile>

suspend fun DialogInterfaceProvider.openFileDialog(filter: FileFilter? = null, write: Boolean = false, multi: Boolean = false, currentDir: VfsFile? = null): List<VfsFile>

fun paintInContext(g: Graphics, info: BaseOpenglContext.ContextInfo)

paintInContextInternal

fun paintInContextInternal(g: Graphics, info: BaseOpenglContext.ContextInfo)

open operator fun plus(context: CoroutineContext): CoroutineContext

suspend fun DialogInterfaceProvider.prompt(message: String, default: String = ""): String

fun queue(callback: Runnable)

fun queue(callback: () -> Unit)

fun <T> queueBlocking(callback: () -> T): T

inline fun <T> registerTime(name: String, block: () -> T): T

open fun registerTime(name: String, time: TimeSpan)

open override fun repaint()

setInputRectangle

open fun setInputRectangle(windowRect: Rectangle)

open override fun setMainMenu(items: List<GameWindow.MenuItem>)

open fun setSize(width: Int, height: Int)

fun show()

showContextMenu

fun showContextMenu(block: GameWindow.MenuItemBuilder.() -> Unit)

open override fun showContextMenu(items: List<GameWindow.MenuItem>)

showSoftKeyboard

open fun showSoftKeyboard(force: Boolean = true, config: ISoftKeyboardConfig? = null)

fun startFrame()

toggleFullScreen

fun GameWindow.toggleFullScreen()

fun GameWindow.MenuItem?.toJMenuItem(): JComponent

open override fun updateGamepads()

updateRenderLock

inline fun updateRenderLock(block: () -> Unit)

suspend fun waitClose()