korge/korlibs.render/IosGameWindow

IosGameWindow

open class IosGameWindow(val windowProvider: () -> UIWindow?? = null, val glXViewControllerProvider: () -> MyGLKViewController?? = null) : GameWindow

Constructors

IosGameWindow

constructor(windowProvider: () -> UIWindow?? = null, glXViewControllerProvider: () -> MyGLKViewController?? = null)

Types

MyUITextComponent

class MyUITextComponent(val gw: IosGameWindow, rect: CValue<CGRect>) : UIView, UITextInputProtocol, UITextInputTraitsProtocol

Properties

open override val ag: AG

alwaysOnTop

open var alwaysOnTop: Boolean

androidContextAny

open val androidContextAny: Any?

bgcolor

open var bgcolor: RGBA

bufferHeight

open val bufferHeight: Int

bufferWidth

open val bufferWidth: Int

computedPixelRatio

open val computedPixelRatio: Double

continuousRenderMode

open var continuousRenderMode: Boolean

coroutineDispatcher

open val coroutineDispatcher: GameWindowCoroutineDispatcher

counterTimePerFrame

val counterTimePerFrame: TimeSpan

cursor

open var cursor: GameWindow.ICursor

debug

open var debug: Boolean

debugComponent

open val debugComponent: Any?

devicePixelRatio

open val devicePixelRatio: Double

dialogInterface

open override val dialogInterface: DialogInterfaceIos

eventListenerParent

var eventListenerParent: BaseEventListener?

exitCode

var exitCode: Int

exitProcessOnClose

var exitProcessOnClose: Boolean

extra

open override var extra: ExtraType

fps

open override var fps: Int

fullscreen

open var fullscreen: Boolean

gamepadEmitter

val gamepadEmitter: GamepadInfoEmitter

gamePadTime

var gamePadTime: TimeSpan

gameWindowAndroidContext

val GameWindow.gameWindowAndroidContext: Context

gameWindowAndroidContextOrNull

val GameWindow.gameWindowAndroidContextOrNull: Context?

glXViewController

val glXViewController: MyGLKViewController?

glXViewControllerProvider

val glXViewControllerProvider: () -> MyGLKViewController?? = null

hapticFeedbackGenerateSupport

open override val hapticFeedbackGenerateSupport: Boolean

height

open val height: Int

icon

open var icon: Bitmap?

isSoftKeyboardVisible

open override val isSoftKeyboardVisible: Boolean

keepScreenOn

open override var keepScreenOn: Boolean

key

open override val key: CoroutineContext.Key<*>

mustTriggerRender

val mustTriggerRender: Boolean

myCoroutineDispatcher

open val myCoroutineDispatcher: SyncEventLoopCoroutineDispatcher

onContinuousRenderModeUpdated

var onContinuousRenderModeUpdated: (Boolean) -> Unit?

onDebugChanged

val onDebugChanged: Signal<Boolean>

onDebugEnabled

val onDebugEnabled: Signal<Unit>

pixelsPerCm

open val pixelsPerCm: Double

pixelsPerInch

open override val pixelsPerInch: Double

pixelsPerLogicalInchRatio

open val pixelsPerLogicalInchRatio: Double

preferredFps

open override var preferredFps: Int

quality

open override var quality: GameWindow.Quality

renderTime

var renderTime: Duration

running

var running: Boolean

textField

lateinit var textField: IosGameWindow.MyUITextComponent

timePerFrame

val timePerFrame: TimeSpan

title

open var title: String

updatedSinceFrame

var updatedSinceFrame: Int

updateTime

var updateTime: Duration

visible

open var visible: Boolean

vsync

open var vsync: Boolean

width

open val width: Int

window

val window: UIWindow

windowProvider

val windowProvider: () -> UIWindow?? = null

Functions

alert

suspend fun DialogInterfaceProvider.alert(message: String)

alertError

suspend fun DialogInterfaceProvider.alertError(e: Throwable)

browse

suspend fun DialogInterfaceProvider.browse(url: URL)

clearEvents

fun clearEvents()

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

clipboardRead

open suspend fun clipboardRead(): ClipboardData?

clipboardWrite

open suspend fun clipboardWrite(data: ClipboardData)

open override fun close(exitCode: Int)

computeDisplayRefreshRate

open fun computeDisplayRefreshRate(): Int

configure

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

confirm

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

dispatch

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

dispatchChildren

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

dispatchDestroyEvent

fun dispatchDestroyEvent(): Boolean

dispatchDisposeEvent

fun dispatchDisposeEvent(): Boolean

dispatchDown

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

dispatchDown

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

dispatchGamepadUpdateStart

fun dispatchGamepadUpdateStart()

dispatchInitEvent

fun dispatchInitEvent(): Boolean

dispatchKeyEvent

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

dispatchKeyEventDownUp

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

dispatchKeyEventEx

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

dispatchMouseEvent

fun dispatchMouseEvent(type: MouseEvent.Type, id: Int, x: Int, y: Int, button: MouseButton, buttons: Int, scrollDeltaX: Float, scrollDeltaY: Float, scrollDeltaZ: Float, isShiftDown: Boolean, isCtrlDown: Boolean, isAltDown: Boolean, isMetaDown: Boolean, scaleCoords: Boolean, simulateClickOnUp: Boolean, scrollDeltaMode: MouseEvent.ScrollDeltaMode)

dispatchNewRenderEvent

fun dispatchNewRenderEvent()

dispatchParent

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

dispatchPauseEvent

fun dispatchPauseEvent(): Boolean

dispatchRenderEvent

fun dispatchRenderEvent(update: Boolean, render: Boolean)

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)

dispatchStopEvent

fun dispatchStopEvent(): Boolean

dispatchUp

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

dispatchUp

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

dispatchUpdateEvent

fun dispatchUpdateEvent()

dispatchWithResult

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

entry

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

executePending

fun executePending(availableTime: TimeSpan)

exit

fun exit(exitCode: Int)

fold

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

frame

fun frame(doUpdate: Boolean, doRender: Boolean, frameStartTime: TimeSpan): TimeSpan

frameRender

fun frameRender(doUpdate: Boolean, doRender: Boolean)

frameUpdate

fun frameUpdate(startTime: TimeSpan)

get

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)

hide

fun hide()

hideSoftKeyboard

open override fun hideSoftKeyboard()

invalidatedView

fun invalidatedView()

loop

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

mainLoop

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

minusKey

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

onDragAndDropFileEvent

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

onEvent

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

onEventCount

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

onEvents

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

onEventsCount

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

onRenderEvent

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

onUpdateEvent

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

openFileDialog

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>

plus

open operator fun plus(context: CoroutineContext): CoroutineContext

prompt

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

queue

fun queue(callback: () -> Unit)

fun queue(callback: Runnable)

queueBlocking

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

registerTime

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

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

repaint

open override fun repaint()

setInputRectangle

open override fun setInputRectangle(windowRect: Rectangle)

setMainMenu

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

setSize

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

show

fun show()

showContextMenu

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

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

showSoftKeyboard

open override fun showSoftKeyboard(force: Boolean, config: ISoftKeyboardConfig?)

startFrame

fun startFrame()

toggleFullScreen

fun GameWindow.toggleFullScreen()

toIOS

fun SoftKeyboardReturnKeyType.toIOS(): UIReturnKeyType

fun SoftKeyboardType?.toIOS(): UIKeyboardType

fun <T> Boolean?.toIOS(default: T, no: T, yes: T): T

updateGamepads

open fun updateGamepads()

updateRenderLock

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

waitClose

suspend fun waitClose()