Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-window

Source of release 0.6.3

0.6.3 / tests / windows / window_contract.lucb

from luce_window import window, input
import platform
import thread
import time

extern func PostMessageW(window: void*, message: u32, word: usize, value: isize) -> i32
extern func GetWindowTextW(window: void*, text: u16*, count: i32) -> i32

## sockaddr_in.
extern struct Address:
    family: u16
    port: u16
    host: u32
    zero: u64

extern func WSAStartup(version: u16, data: void*) -> i32
extern func socket(family: i32, kind: i32, protocol: i32) -> platform.SocketDescriptor
extern func bind(socket: platform.SocketDescriptor, address: const Address*, length: i32) -> i32
extern func getsockname(socket: platform.SocketDescriptor, address: Address*, length: i32*) -> i32
extern func sendto(socket: platform.SocketDescriptor, data: const void*, length: i32, flags: i32, address: const Address*, address_length: i32) -> i32
extern func recv(socket: platform.SocketDescriptor, data: void*, length: i32, flags: i32) -> i32
extern func closesocket(socket: platform.SocketDescriptor) -> i32

struct Datagram:
    var socket: platform.SocketDescriptor
    var address: Address

## Send one datagram to a watched socket from another thread after a short delay.
func sender(context: void*?):
    let pointer = context else trap("missing test context")
    let datagram = (Datagram*)pointer
    thread.sleep(50)
    var byte: u8 = 1
    assert(sendto(datagram.socket, (const void*)&byte, 1, 0, &datagram.address, 16) == 1)

## A watched UDP socket ends a wait once a datagram arrives; one left readable ends the
## next wait at once.
func watched_socket(surface: window.Window*) -> !:
    var data: u8[512]
    assert(WSAStartup(0x0202, (void*)&data[0]) == 0)
    let receiver = socket(2, 2, 17)
    let sending = socket(2, 2, 17)
    defer _ = closesocket(receiver)
    defer _ = closesocket(sending)
    # 127.0.0.1, any port.
    var address = Address(family = 2, port = 0, host = 0x0100007F, zero = 0)
    assert(bind(receiver, &address, 16) == 0)
    var length: i32 = 16
    assert(getsockname(receiver, &address, &length) == 0)
    try window.watch(receiver, window.Interest.readable)
    var datagram = Datagram(socket = sending, address = address)
    var sender_thread = try thread.spawn(sender, (void*)&datagram)
    let started = time.now()
    _ = try surface.wait(3600000000000)
    try sender_thread.join()
    assert(time.since(started) < 5000000000)
    let ready = time.now()
    _ = try surface.wait(3600000000000)
    assert(time.since(ready) < 5000000000)
    var byte: u8 = 0
    assert(recv(receiver, (void*)&byte, 1, 0) == 1)
    try window.unwatch(receiver)

pub func main(arguments: str[]) -> i32!:
    var first = try window.Window.open(window.Options(title = "Luce Windows — 日本語 😀", width = 400, height = 300))
    defer first.destroy()
    var second = try window.Window.open(window.Options(title = "Luce second window", width = 320, height = 240))
    defer second.destroy()
    var lease = try first.acquire_presentation()
    defer lease.destroy()
    assert(not try lease.visible())
    try first.show()
    assert(try lease.visible())
    try first.resize(480, 320)
    let extent = try first.size()
    assert(extent.width == 480.0 and extent.height == 320.0)
    while let event = try first.poll(): _ = event
    let handle = try lease.windows_handle()
    try first.set_title("Retitled — é")
    var title: u16[32]
    assert(GetWindowTextW(handle, &title[0], 32) == 12 and title[11] == 233)
    try watched_socket(&first)
    while let event = try first.poll(): _ = event
    assert(PostMessageW(handle, 256, 65, 30 << 16) != 0)
    assert(PostMessageW(handle, 257, 65, (30 << 16) | 2147483648) != 0)
    assert(PostMessageW(handle, 512, 0, 20 | (30 << 16)) != 0)
    var key_down = false
    var key_up = false
    var pointer = false
    for tick in 0..<60:
        while let event = try first.poll():
            if event.kind == input.EventKind.key_down and event.key == input.Key.a: key_down = true
            if event.kind == input.EventKind.key_up and event.key == input.Key.a: key_up = true
            if event.kind == input.EventKind.pointer_moved: pointer = true
        thread.sleep(10)
    assert(key_down and key_up and pointer)
    try first.set_text_input(true)
    assert(PostMessageW(handle, 258, 233, 1) != 0)
    assert(PostMessageW(handle, 258, 0xD83D, 1) != 0)
    assert(PostMessageW(handle, 258, 0xDE00, 1) != 0)
    assert(PostMessageW(handle, 265, 0x4E16, 1) != 0)
    var committed: u32[3]
    var received: usize = 0
    for tick in 0..<60:
        while let event = try first.poll():
            if event.kind == input.EventKind.text_input:
                assert(received < committed.length)
                committed[received] = event.codepoint
                received += 1
        if received == 3:
            break
        thread.sleep(10)
    assert(received == 3 and committed[0] == 233 and committed[1] == 128512 and committed[2] == 0x4E16)
    try first.set_text_input(false)
    assert(PostMessageW(handle, 16, 0, 0) != 0)
    var close_received = false
    while let event = try first.poll():
        if event.kind == input.EventKind.close_requested: close_received = true
    assert(close_received)
    while let event = try second.poll():
        assert(event.kind != input.EventKind.close_requested)
    first.destroy()
    let visibility = lease.visible() catch failure:
        assert(failure.code == window.closed)
        recover false
    assert(not visibility)
    lease.destroy()
    first.destroy()
    print("ok Windows windows, DPI, Unicode, input, isolation and presentation lifetime")
    return 0