all repos — min @ 4d53dbbeaf8e8da0baacb88b612e18658ef8463d

A small but practical concatenative programming language.

minpkg/lib/min_gui.nim

 1
 2
 3
 4
 5
 6
 7
 8
 9
 10
 11
 12
 13
 14
 15
 16
 17
 18
 19
 20
 21
 22
 23
 24
 25
 26
 27
 28
 29
 30
 31
 32
 33
 34
 35
 36
 37
 38
 39
 40
 41
 42
 43
 44
 45
 46
 47
 48
 49
 50
 51
 52
 53
 54
 55
 56
 57
 58
 59
 60
 61
 62
 63
 64
 65
 66
 67
 68
 69
 70
 71
 72
 73
 74
 75
 76
 77
 78
 79
 80
 81
 82
 83
 84
 85
 86
 87
 88
 89
 90
 91
 92
 93
 94
 95
 96
 97
 98
 99
 100
 101
 102
 103
 104
 105
 106
 107
 108
 109
 110
 
import std/sequtils

import pkg/fenstim

import
    ../core/parser,
    ../core/interpreter,
    ../core/value,
    ../core/utils

var WINDOWS*: seq[Fenster] = @[]

proc window(i: In, v: MinValue): var Fenster =
    return WINDOWS[i.dget(v, "ref").intVal]

proc gui_module*(i: In) =
    let def = i.define()

    def.symbol("window") do (i: In):
        let vals = i.expect("dict")
        var d = vals[0]
        var title = "min"
        var height = 400
        var width = 400
        var fps = 60
        if d.dhas("title"):
            title = i.dget(d, "title").getString
        if d.dhas("height"):
            height = i.dget(d, "height").intVal
        if d.dhas("width"):
            width = i.dget(d, "width").intVal
        if d.dhas("fps"):
            fps = i.dget(d, "fps").intVal
        var window = Fenster.init(title, width, height, fps)
        var win = newDict(i.scope)
        win = i.dset(win, "title", title.newVal)
        win = i.dset(win, "height", height.newVal)
        win = i.dset(win, "width", width.newVal)
        win = i.dset(win, "fps", fps.newVal)
        win = i.dset(win, "ref", WINDOWS.len.newVal)
        win.objType = "window"
        WINDOWS.add window
        i.push win

    def.symbol("loop") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).loop.newVal

    def.symbol("close") do (i: In):
        var vals = i.expect("dict:window")
        i.window(vals[0]).close()
        WINDOWS.delete(vals[0].intVal)

    def.symbol("pixel") do (i: In):
        var vals = i.expect("quot", "dict:window")
        i.push i.window(vals[1]).pixel(vals[0].qVal[0].intVal, vals[0].qVal[
                1].intVal).int.newVal

    def.symbol("draw") do (i: In):
        var vals = i.expect("int", "quot", "dict:window")
        var f = i.window(vals[2])
        let x = vals[1].qVal[0].intVal
        let y = vals[1].qVal[1].intVal
        let v = vals[0].intVal.uint32
        f.pixel(x, y) = v

    def.symbol("width") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).width.newVal

    def.symbol("height") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).height.newVal

    def.symbol("keys") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).keys.mapIt(it.int.newVal).newVal

    def.symbol("modkey") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).modkey.newVal

    def.symbol("mouse") do (i: In):
        var vals = i.expect("dict:window")
        var win = i.window(vals[0])
        var mouse = newDict(i.scope)
        # Double quote quotations
        let click = @[win.mouse.mclick.mapIt(
                it.int.newVal).newVal].newVal
        let hold = @[win.mouse.mhold.mapIt(
                it.int.newVal).newVal].newVal
        i.dset(mouse, "x", win.mouse.pos.x.newVal)
        i.dset(mouse, "y", win.mouse.pos.y.newVal)
        i.dset(mouse, "click", click)
        i.dset(mouse, "hold", hold)
        i.push mouse

    def.symbol("sleep") do (i: In):
        var vals = i.expect("int", "dict:window")
        i.window(vals[1]).sleep(vals[0].intVal)

    def.symbol("time") do (i: In):
        var vals = i.expect("dict:window")
        i.push i.window(vals[0]).time.newVal

    def.symbol("clear") do (i: In):
        var vals = i.expect("dict:window")
        i.window(vals[0]).clear()

    def.finalize("gui")