korge/korlibs.render.osx/MacGameWindow

MacGameWindow

class MacGameWindow(val checkGl: Boolean, val logGl: Boolean) : GameWindow

Constructors

constructor(checkGl: Boolean, logGl: Boolean)

Types

object Companion

Properties

open override val ag: AGOpengl

open var alwaysOnTop: Boolean

androidContextAny

open val androidContextAny: Any?

applicationShouldTerminate

val applicationShouldTerminate: ApplicationShouldTerminateCallback

autoreleasePool

val autoreleasePool: Long

backingScaleFactor

val backingScaleFactor: Float

open var bgcolor: RGBA

open val bufferHeight: Int

open val bufferWidth: Int

val checkGl: Boolean

computedPixelRatio

open val computedPixelRatio: Double

var contentView: Long

continuousRenderMode

open var continuousRenderMode: Boolean

coroutineDispatcher

open val coroutineDispatcher: GameWindowCoroutineDispatcher

counterTimePerFrame

val counterTimePerFrame: TimeSpan

open var cursor: GameWindow.ICursor

open var debug: Boolean

open val debugComponent: Any? = null

devicePixelRatio

open val devicePixelRatio: Double

dialogInterface

open override val dialogInterface: DialogInterface

eventListenerParent

var eventListenerParent: BaseEventListener?

var exitCode: Int

exitProcessOnClose

var exitProcessOnClose: Boolean

open override var extra: ExtraType

open var fps: Int

open override var fullscreen: Boolean

val gamepadEmitter: GamepadInfoEmitter

var gamePadTime: TimeSpan

gameWindowAndroidContext

val GameWindow.gameWindowAndroidContext: Context

gameWindowAndroidContextOrNull

val GameWindow.gameWindowAndroidContextOrNull: Context?

var glCtx: MacosGLContext?

hapticFeedbackGenerateSupport

open val hapticFeedbackGenerateSupport: Boolean

open override var height: Int

open override var icon: Bitmap?

val initialHeight: Int = 128

val initialWidth: Int = 128

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<*>

keyEventHandler

val keyEventHandler: ObjcCallbackVoid

val logGl: Boolean

mouseEventHandler

val mouseEventHandler: ObjcCallbackVoid

mustTriggerRender

val mustTriggerRender: Boolean

myCoroutineDispatcher

open val myCoroutineDispatcher: SyncEventLoopCoroutineDispatcher

onContinuousRenderModeUpdated

var onContinuousRenderModeUpdated: (Boolean) -> Unit?

val onDebugChanged: Signal<Boolean>

val onDebugEnabled: Signal<Unit>

open val pixelsPerCm: Double

Approximate on iOS

open val pixelsPerInch: Double

Approximate on iOS

pixelsPerLogicalInchRatio

open val pixelsPerLogicalInchRatio: Double

open var preferredFps: Int

open override var quality: GameWindow.Quality

val rect: NSRect

var renderTime: Duration

var running: Boolean

val sharedApp: Long

val timePerFrame: TimeSpan

val timerCallback: Callback

val timerCallback2: ObjcCallbackVoid

open override var title: String

updatedSinceFrame

var updatedSinceFrame: Int

var updateTime: Duration

open override var visible: Boolean

open var vsync: Boolean

open override var width: Int

val window: Long

windowDidResize

val windowDidResize: ObjcCallbackVoid

val windowTimer: ObjcCallbackVoid

windowWillClose

val windowWillClose: WindowWillCloseCallback

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 fun clipboardRead(): ClipboardData?

open suspend fun clipboardWrite(data: ClipboardData)

open override fun close(exitCode: Int)

computeDisplayRefreshRate

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

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)

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

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 fun hapticFeedbackGenerate(kind: GameWindow.HapticFeedbackKind)

fun hide()

hideSoftKeyboard

open fun hideSoftKeyboard()

invalidatedView

fun invalidatedView()

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

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>

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)

fun renderOpengl(update: Boolean = false)

open override fun repaint()

setInputRectangle

open fun setInputRectangle(windowRect: Rectangle)

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

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

fun show()

showContextMenu

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

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

showSoftKeyboard

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

fun startFrame()

toggleFullScreen

fun GameWindow.toggleFullScreen()

open fun updateGamepads()

updateRenderLock

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

suspend fun waitClose()

windowDidResize

fun windowDidResize()