aboutsummaryrefslogtreecommitdiffstats
path: root/ethereal/ui/ext_app.go
blob: d1a256cdbaf0cd779b34d53ba7f2efbde0a2010a (plain) (blame)
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
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
package ethui

import (
    "fmt"
    "github.com/ethereum/eth-go/ethchain"
    "github.com/ethereum/eth-go/ethpub"
    "github.com/ethereum/eth-go/ethutil"
    "github.com/go-qml/qml"
)

type AppContainer interface {
    Create() error
    Destroy()

    Window() *qml.Window
    Engine() *qml.Engine

    NewBlock(*ethchain.Block)
    ObjectChanged(*ethchain.StateObject)
    StorageChanged(*ethchain.StorageState)
    NewWatcher(chan bool)
}

type ExtApplication struct {
    *ethpub.PEthereum

    blockChan       chan ethutil.React
    changeChan      chan ethutil.React
    quitChan        chan bool
    watcherQuitChan chan bool

    container        AppContainer
    lib              *UiLib
    registeredEvents []string
}

func NewExtApplication(container AppContainer, lib *UiLib) *ExtApplication {
    app := &ExtApplication{
        ethpub.NewPEthereum(lib.eth),
        make(chan ethutil.React, 1),
        make(chan ethutil.React, 1),
        make(chan bool),
        make(chan bool),
        container,
        lib,
        nil,
    }

    return app
}

func (app *ExtApplication) run() {
    // Set the "eth" api on to the containers context
    context := app.container.Engine().Context()
    context.SetVar("eth", app)
    context.SetVar("ui", app.lib)

    err := app.container.Create()
    if err != nil {
        fmt.Println(err)

        return
    }

    // Call the main loop
    go app.mainLoop()

    // Subscribe to events
    reactor := app.lib.eth.Reactor()
    reactor.Subscribe("newBlock", app.blockChan)

    app.container.NewWatcher(app.watcherQuitChan)

    win := app.container.Window()
    win.Show()
    win.Wait()

    app.stop()
}

func (app *ExtApplication) stop() {
    // Clean up
    reactor := app.lib.eth.Reactor()
    reactor.Unsubscribe("newBlock", app.blockChan)
    for _, event := range app.registeredEvents {
        reactor.Unsubscribe(event, app.changeChan)
    }

    // Kill the main loop
    app.quitChan <- true
    app.watcherQuitChan <- true

    close(app.blockChan)
    close(app.quitChan)
    close(app.changeChan)

    app.container.Destroy()
}

func (app *ExtApplication) mainLoop() {
out:
    for {
        select {
        case <-app.quitChan:
            break out
        case block := <-app.blockChan:
            if block, ok := block.Resource.(*ethchain.Block); ok {
                app.container.NewBlock(block)
            }
        case object := <-app.changeChan:
            if stateObject, ok := object.Resource.(*ethchain.StateObject); ok {
                app.container.ObjectChanged(stateObject)
            } else if storageObject, ok := object.Resource.(*ethchain.StorageState); ok {
                app.container.StorageChanged(storageObject)
            }
        }
    }

}

func (app *ExtApplication) Watch(addr, storageAddr string) {
    var event string
    if len(storageAddr) == 0 {
        event = "object:" + string(ethutil.FromHex(addr))
        app.lib.eth.Reactor().Subscribe(event, app.changeChan)
    } else {
        event = "storage:" + string(ethutil.FromHex(addr)) + ":" + string(ethutil.FromHex(storageAddr))
        app.lib.eth.Reactor().Subscribe(event, app.changeChan)
    }

    app.registeredEvents = append(app.registeredEvents, event)
}