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
|
#include <QGuiApplication>
#include <QQmlApplicationEngine>
#include <QQuickWindow>
#include <QTimer>
#include <QtQml>
#include <string>
#include "handlers.h"
#include "qjsonmodel.h"
#include "lib/libgoshim.h"
/* Hi! I'm Troy McClure and I'll be your guide today. You probably remember me
from blockbusters like "here be dragons" and "darling, I wrote a little
contraption". */
/* Our glorious global object state. In here we store a serialized snapshot of
the context from the application "backend", living in the linked Go-land
lib. */
static char *json;
/* We are interested in observing changes to this global json variable.
The jsonWatchdog bridges the gap from pure c callbacks to the rest of the c++
logic. QJsonWatch comes from QObject so it can emit signals. */
QJsonWatch *qw;
struct jsonWatchdog {
jsonWatchdog() { qw = new QJsonWatch; }
void changed() { emit qw->jsonChanged(QString(json)); }
};
/* we need C wrappers around every C++ object, so that we can invoke their methods
from the function pointers passed as callbacks to CGO. */
extern "C" {
static void *newWatchdog(void) { return (void *)(new jsonWatchdog); }
static void jsonChanged(void *ptr) {
if (ptr != NULL) {
jsonWatchdog *klsPtr = static_cast<jsonWatchdog *>(ptr);
klsPtr->changed();
}
}
}
void *wd = newWatchdog();
/* onStatusChanged is the C function that we register as a callback with CGO,
to be called from the Go side. It pulls a string serialization of the
context object, than we then pass along to Qt objects and to Qml. */
void onStatusChanged() {
char *ctx = RefreshContext();
json = ctx;
/* the method wrapped emits a qt signal */
jsonChanged(wd);
free(ctx);
}
std::string getEnv(std::string const& key)
{
char const* val = getenv(key.c_str());
return val == NULL ? std::string() : std::string(val);
}
int main(int argc, char **argv) {
bool debugQml = getEnv("DEBUG_QML_DATA") == "yes";
QGuiApplication::setAttribute(Qt::AA_EnableHighDpiScaling);
QGuiApplication app(argc, argv);
app.setQuitOnLastWindowClosed(false);
QQmlApplicationEngine engine;
QQmlContext *ctx = engine.rootContext();
QJsonModel *model = new QJsonModel;
std::string json = R"({"appName": "unknown", "provider": "unknown"})";
model->loadJson(QByteArray::fromStdString(json));
/* the backend handler has slots for calling back to Go when triggered by
signals in Qml. */
Backend backend;
ctx->setContextProperty("backend", &backend);
/* set the json model, load the qml */
ctx->setContextProperty("jsonModel", model);
ctx->setContextProperty("debugQml", debugQml);
engine.load(QUrl(QStringLiteral("qrc:/qml/main.qml")));
/* connect the jsonChanged signal explicitely.
In the lambda, we reload the json in the model every time we receive an
update from Go */
QObject::connect(qw, &QJsonWatch::jsonChanged, [ctx, model](QString js) {
model->loadJson(js.toUtf8());
});
/* connect quitDone signal, exit app */
QObject::connect(&backend, &Backend::quitDone, []() {
QGuiApplication::quit();
});
/* register statusChanged callback with CGO */
const char *stCh = "OnStatusChanged";
GoString statusChangedEvt = {stCh, (long int)strlen(stCh)};
SubscribeToEvent(statusChangedEvt, (void *)onStatusChanged);
/* let the Go side initialize its internal state */
InitializeBitmaskContext();
/* kick off your shoes, put your feet up */
return app.exec();
}
|
