void/ZeroTierOne
2
0
Fork 0
mirror of https://github.com/zerotier/ZeroTierOne.git synced 2025-07-22 18:32:51 +02:00
Code Issues Projects Releases Packages Wiki Activity Actions 2
ZeroTierOne/attic/webview/webview.h
Adam Ierymenko 47b4efd49b
Work in progress...
2019-11-04 14:24:37 -08:00

1248 lines
39 KiB
C
Raw Blame History

/*
* MIT License
*
* Copyright (c) 2017 Serge Zaitsev
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*/
#ifndef WEBVIEW_H
#define WEBVIEW_H
#ifndef WEBVIEW_API
#define WEBVIEW_API extern
#endif
#ifdef __cplusplus
extern "C" {
#endif
typedef void *webview_t;
// Create a new webview instance
WEBVIEW_API webview_t webview_create(int debug, void *wnd);
// Destroy a webview
WEBVIEW_API void webview_destroy(webview_t w);
// Run the main loop
WEBVIEW_API void webview_run(webview_t w);
// Stop the main loop
WEBVIEW_API void webview_terminate(webview_t w);
// Post a function to be executed on the main thread
WEBVIEW_API void
webview_dispatch(webview_t w, void (*fn)(webview_t w, void *arg), void *arg);
WEBVIEW_API void *webview_get_window(webview_t w);
WEBVIEW_API void webview_set_title(webview_t w, const char *title);
WEBVIEW_API void webview_set_bounds(webview_t w, int x, int y, int width,
int height, int flags);
WEBVIEW_API void webview_get_bounds(webview_t w, int *x, int *y, int *width,
int *height, int *flags);
WEBVIEW_API void webview_navigate(webview_t w, const char *url);
WEBVIEW_API void webview_init(webview_t w, const char *js);
WEBVIEW_API void webview_eval(webview_t w, const char *js);
#ifdef __cplusplus
}
#endif
#ifndef WEBVIEW_HEADER
#if !defined(WEBVIEW_GTK) && !defined(WEBVIEW_COCOA) && \
!defined(WEBVIEW_MSHTML) && !defined(WEBVIEW_EDGE)
#error "please, specify webview backend"
#endif
#include <atomic>
#include <functional>
#include <future>
#include <map>
#include <string>
#include <vector>
#include <cstring>
namespace webview {
using dispatch_fn_t = std::function<void()>;
using msg_cb_t = std::function<void(const char *msg)>;
inline std::string url_encode(std::string s) {
std::string encoded;
for (unsigned int i = 0; i < s.length(); i++) {
auto c = s[i];
if (isalnum(c) || c == '-' || c == '_' || c == '.' || c == '~') {
encoded = encoded + c;
} else {
char hex[4];
snprintf(hex, sizeof(hex), "%%%02x", c);
encoded = encoded + hex;
}
}
return encoded;
}
inline std::string url_decode(std::string s) {
std::string decoded;
for (unsigned int i = 0; i < s.length(); i++) {
if (s[i] == '%') {
int n;
sscanf(s.substr(i + 1, 2).c_str(), "%x", &n);
decoded = decoded + static_cast<char>(n);
i = i + 2;
} else if (s[i] == '+') {
decoded = decoded + ' ';
} else {
decoded = decoded + s[i];
}
}
return decoded;
}
inline std::string html_from_uri(std::string s) {
if (s.substr(0, 15) == "data:text/html,") {
return url_decode(s.substr(15));
}
return "";
}
inline int json_parse_c(const char *s, size_t sz, const char *key, size_t keysz,
const char **value, size_t *valuesz) {
enum {
JSON_STATE_VALUE,
JSON_STATE_LITERAL,
JSON_STATE_STRING,
JSON_STATE_ESCAPE,
JSON_STATE_UTF8
} state = JSON_STATE_VALUE;
const char *k = NULL;
int index = 1;
int depth = 0;
int utf8_bytes = 0;
if (key == NULL) {
index = keysz;
keysz = 0;
}
*value = NULL;
*valuesz = 0;
for (; sz > 0; s++, sz--) {
enum {
JSON_ACTION_NONE,
JSON_ACTION_START,
JSON_ACTION_END,
JSON_ACTION_START_STRUCT,
JSON_ACTION_END_STRUCT
} action = JSON_ACTION_NONE;
unsigned char c = *s;
switch (state) {
case JSON_STATE_VALUE:
if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ',' ||
c == ':') {
continue;
} else if (c == '"') {
action = JSON_ACTION_START;
state = JSON_STATE_STRING;
} else if (c == '{' || c == '[') {
action = JSON_ACTION_START_STRUCT;
} else if (c == '}' || c == ']') {
action = JSON_ACTION_END_STRUCT;
} else if (c == 't' || c == 'f' || c == 'n' || c == '-' ||
(c >= '0' && c <= '9')) {
action = JSON_ACTION_START;
state = JSON_STATE_LITERAL;
} else {
return -1;
}
break;
case JSON_STATE_LITERAL:
if (c == ' ' || c == '\t' || c == '\n' || c == '\r' || c == ',' ||
c == ']' || c == '}' || c == ':') {
state = JSON_STATE_VALUE;
s--;
sz++;
action = JSON_ACTION_END;
} else if (c < 32 || c > 126) {
return -1;
} // fallthrough
case JSON_STATE_STRING:
if (c < 32 || (c > 126 && c < 192)) {
return -1;
} else if (c == '"') {
action = JSON_ACTION_END;
state = JSON_STATE_VALUE;
} else if (c == '\\') {
state = JSON_STATE_ESCAPE;
} else if (c >= 192 && c < 224) {
utf8_bytes = 1;
state = JSON_STATE_UTF8;
} else if (c >= 224 && c < 240) {
utf8_bytes = 2;
state = JSON_STATE_UTF8;
} else if (c >= 240 && c < 247) {
utf8_bytes = 3;
state = JSON_STATE_UTF8;
} else if (c >= 128 && c < 192) {
return -1;
}
break;
case JSON_STATE_ESCAPE:
if (c == '"' || c == '\\' || c == '/' || c == 'b' || c == 'f' ||
c == 'n' || c == 'r' || c == 't' || c == 'u') {
state = JSON_STATE_STRING;
} else {
return -1;
}
break;
case JSON_STATE_UTF8:
if (c < 128 || c > 191) {
return -1;
}
utf8_bytes--;
if (utf8_bytes == 0) {
state = JSON_STATE_STRING;
}
break;
default:
return -1;
}
if (action == JSON_ACTION_END_STRUCT) {
depth--;
}
if (depth == 1) {
if (action == JSON_ACTION_START || action == JSON_ACTION_START_STRUCT) {
if (index == 0) {
*value = s;
} else if (keysz > 0 && index == 1) {
k = s;
} else {
index--;
}
} else if (action == JSON_ACTION_END ||
action == JSON_ACTION_END_STRUCT) {
if (*value != NULL && index == 0) {
*valuesz = (size_t)(s + 1 - *value);
return 0;
} else if (keysz > 0 && k != NULL) {
if (keysz == (size_t)(s - k - 1) && memcmp(key, k + 1, keysz) == 0) {
index = 0;
} else {
index = 2;
}
k = NULL;
}
}
}
if (action == JSON_ACTION_START_STRUCT) {
depth++;
}
}
return -1;
}
inline std::string json_escape(std::string s) {
// TODO: implement
return '"' + s + '"';
}
inline int json_unescape(const char *s, size_t n, char *out) {
int r = 0;
if (*s++ != '"') {
return -1;
}
while (n > 2) {
char c = *s;
if (c == '\\') {
s++;
n--;
switch (*s) {
case 'b':
c = '\b';
break;
case 'f':
c = '\f';
break;
case 'n':
c = '\n';
break;
case 'r':
c = '\r';
break;
case 't':
c = '\t';
break;
case '\\':
c = '\\';
break;
case '/':
c = '/';
break;
case '\"':
c = '\"';
break;
default: // TODO: support unicode decoding
return -1;
}
}
if (out != NULL) {
*out++ = c;
}
s++;
n--;
r++;
}
if (*s != '"') {
return -1;
}
if (out != NULL) {
*out = '\0';
}
return r;
}
inline std::string json_parse(std::string s, std::string key, int index) {
const char *value;
size_t value_sz;
if (key == "") {
json_parse_c(s.c_str(), s.length(), nullptr, index, &value, &value_sz);
} else {
json_parse_c(s.c_str(), s.length(), key.c_str(), key.length(), &value,
&value_sz);
}
if (value != nullptr) {
if (value[0] != '"') {
return std::string(value, value_sz);
}
int n = json_unescape(value, value_sz, nullptr);
if (n > 0) {
char *decoded = new char[n];
json_unescape(value, value_sz, decoded);
auto result = std::string(decoded, n);
delete[] decoded;
return result;
}
}
return "";
}
} // namespace webview
#if defined(WEBVIEW_GTK)
//
// ====================================================================
//
// This implementation uses webkit2gtk backend. It requires gtk+3.0 and
// webkit2gtk-4.0 libraries. Proper compiler flags can be retrieved via:
//
// pkg-config --cflags --libs gtk+-3.0 webkit2gtk-4.0
//
// ====================================================================
//
#include <JavaScriptCore/JavaScript.h>
#include <gtk/gtk.h>
#include <webkit2/webkit2.h>
namespace webview {
class browser_engine {
public:
browser_engine(msg_cb_t cb, bool debug, void *window)
: m_cb(cb), m_window(static_cast<GtkWidget *>(window)) {
gtk_init_check(0, NULL);
m_window = static_cast<GtkWidget *>(window);
if (m_window == nullptr) {
m_window = gtk_window_new(GTK_WINDOW_TOPLEVEL);
}
g_signal_connect(G_OBJECT(m_window), "destroy",
G_CALLBACK(+[](GtkWidget *w, gpointer arg) {
static_cast<browser_engine *>(arg)->terminate();
}),
this);
// Initialize webview widget
m_webview = webkit_web_view_new();
WebKitUserContentManager *manager =
webkit_web_view_get_user_content_manager(WEBKIT_WEB_VIEW(m_webview));
g_signal_connect(manager, "script-message-received::external",
G_CALLBACK(+[](WebKitUserContentManager *m,
WebKitJavascriptResult *r, gpointer arg) {
auto *w = static_cast<browser_engine *>(arg);
#if WEBKIT_MAJOR_VERSION >= 2 && WEBKIT_MINOR_VERSION >= 22
JSCValue *value =
webkit_javascript_result_get_js_value(r);
char *s = jsc_value_to_string(value);
#else
JSGlobalContextRef ctx =
webkit_javascript_result_get_global_context(r);
JSValueRef value = webkit_javascript_result_get_value(r);
JSStringRef js = JSValueToStringCopy(ctx, value, NULL);
size_t n = JSStringGetMaximumUTF8CStringSize(js);
char *s = g_new(char, n);
JSStringGetUTF8CString(js, s, n);
JSStringRelease(js);
#endif
w->m_cb(s);
g_free(s);
}),
this);
webkit_user_content_manager_register_script_message_handler(manager,
"external");
init("window.external={invoke:function(s){window.webkit.messageHandlers."
"external.postMessage(s);}}");
gtk_container_add(GTK_CONTAINER(m_window), GTK_WIDGET(m_webview));
gtk_widget_grab_focus(GTK_WIDGET(m_webview));
if (debug) {
WebKitSettings *settings =
webkit_web_view_get_settings(WEBKIT_WEB_VIEW(m_webview));
webkit_settings_set_enable_write_console_messages_to_stdout(settings,
true);
webkit_settings_set_enable_developer_extras(settings, true);
}
gtk_widget_show_all(m_window);
}
void run() { gtk_main(); }
void terminate() { gtk_main_quit(); }
void dispatch(std::function<void()> f) {
g_idle_add_full(G_PRIORITY_HIGH_IDLE, (GSourceFunc)([](void *f) -> int {
(*static_cast<dispatch_fn_t *>(f))();
return G_SOURCE_REMOVE;
}),
new std::function<void()>(f),
[](void *f) { delete static_cast<dispatch_fn_t *>(f); });
}
void set_title(const char *title) {
gtk_window_set_title(GTK_WINDOW(m_window), title);
}
void set_size(int width, int height, bool resizable) {
gtk_window_set_resizable(GTK_WINDOW(m_window), !!resizable);
if (resizable) {
gtk_window_set_default_size(GTK_WINDOW(m_window), width, height);
} else {
gtk_widget_set_size_request(m_window, width, height);
}
}
void navigate(const char *url) {
webkit_web_view_load_uri(WEBKIT_WEB_VIEW(m_webview), url);
}
void init(const char *js) {
WebKitUserContentManager *manager =
webkit_web_view_get_user_content_manager(WEBKIT_WEB_VIEW(m_webview));
webkit_user_content_manager_add_script(
manager, webkit_user_script_new(
js, WEBKIT_USER_CONTENT_INJECT_TOP_FRAME,
WEBKIT_USER_SCRIPT_INJECT_AT_DOCUMENT_START, NULL, NULL));
}
void eval(const char *js) {
webkit_web_view_run_javascript(WEBKIT_WEB_VIEW(m_webview), js, NULL, NULL,
NULL);
}
protected:
std::function<void(const char *)> m_cb;
GtkWidget *m_window;
GtkWidget *m_webview;
};
} // namespace webview
#elif defined(WEBVIEW_COCOA)
//
// ====================================================================
//
// This implementation uses Cocoa WKWebView backend on macOS. It is
// written using ObjC runtime and uses WKWebView class as a browser runtime.
// You should pass "-framework Webkit" flag to the compiler.
//
// ====================================================================
//
#include <CoreGraphics/CoreGraphics.h>
#include <objc/objc-runtime.h>
#define NSBackingStoreBuffered 2
#define NSWindowStyleMaskResizable 8
#define NSWindowStyleMaskMiniaturizable 4
#define NSWindowStyleMaskTitled 1
#define NSWindowStyleMaskClosable 2
#define NSApplicationActivationPolicyRegular 0
#define WKUserScriptInjectionTimeAtDocumentStart 0
namespace webview {
id operator"" _cls(const char *s, std::size_t sz) {
return (id)objc_getClass(s);
}
SEL operator"" _sel(const char *s, std::size_t sz) {
return sel_registerName(s);
}
id operator"" _str(const char *s, std::size_t sz) {
return objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, s);
}
class browser_engine {
public:
browser_engine(msg_cb_t cb, bool debug, void *window) : m_cb(cb) {
// Application
id app = objc_msgSend("NSApplication"_cls, "sharedApplication"_sel);
objc_msgSend(app, "setActivationPolicy:"_sel,
NSApplicationActivationPolicyRegular);
// Delegate
auto cls = objc_allocateClassPair((Class) "NSObject"_cls, "AppDelegate", 0);
class_addProtocol(cls, objc_getProtocol("NSApplicationDelegate"));
class_addProtocol(cls, objc_getProtocol("WKScriptMessageHandler"));
class_addMethod(
cls, "applicationShouldTerminateAfterLastWindowClosed:"_sel,
(IMP)(+[](id self, SEL cmd, id notification) -> BOOL { return 1; }),
"c@:@");
class_addMethod(
cls, "userContentController:didReceiveScriptMessage:"_sel,
(IMP)(+[](id self, SEL cmd, id notification, id msg) {
auto w = (browser_engine *)objc_getAssociatedObject(self, "webview");
w->m_cb((const char *)objc_msgSend(objc_msgSend(msg, "body"_sel),
"UTF8String"_sel));
}),
"v@:@@");
objc_registerClassPair(cls);
auto delegate = objc_msgSend((id)cls, "new"_sel);
objc_setAssociatedObject(delegate, "webview", (id)this,
OBJC_ASSOCIATION_ASSIGN);
objc_msgSend(app, sel_registerName("setDelegate:"), delegate);
// Main window
if (window == nullptr) {
m_window = objc_msgSend("NSWindow"_cls, "alloc"_sel);
m_window = objc_msgSend(
m_window, "initWithContentRect:styleMask:backing:defer:"_sel,
CGRectMake(0, 0, 0, 0), 0, NSBackingStoreBuffered, 0);
set_size(480, 320, true);
} else {
m_window = (id)window;
}
// Webview
auto config = objc_msgSend("WKWebViewConfiguration"_cls, "new"_sel);
m_manager = objc_msgSend(config, "userContentController"_sel);
m_webview = objc_msgSend("WKWebView"_cls, "alloc"_sel);
objc_msgSend(m_webview, "initWithFrame:configuration:"_sel,
CGRectMake(0, 0, 0, 0), config);
objc_msgSend(m_manager, "addScriptMessageHandler:name:"_sel, delegate,
"external"_str);
init(R"script(
window.external = {
invoke: function(s) {
window.webkit.messageHandlers.external.postMessage(s);
},
};
)script");
if (debug) {
objc_msgSend(objc_msgSend(config, "preferences"_sel),
"setValue:forKey:"_sel, 1, "developerExtrasEnabled"_str);
}
objc_msgSend(m_window, "setContentView:"_sel, m_webview);
objc_msgSend(m_window, "makeKeyAndOrderFront:"_sel, nullptr);
}
~browser_engine() { objc_msgSend(m_window, "close"_sel); }
void terminate() { objc_msgSend("NSApp"_cls, "terminate:"_sel, nullptr); }
void run() {
id app = objc_msgSend("NSApplication"_cls, "sharedApplication"_sel);
dispatch([&]() { objc_msgSend(app, "activateIgnoringOtherApps:"_sel, 1); });
objc_msgSend(app, "run"_sel);
}
void dispatch(std::function<void()> f) {
dispatch_async_f(dispatch_get_main_queue(), new dispatch_fn_t(f),
(dispatch_function_t)([](void *arg) {
auto f = static_cast<dispatch_fn_t *>(arg);
(*f)();
delete f;
}));
}
void set_title(const char *title) {
objc_msgSend(
m_window, "setTitle:"_sel,
objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, title));
}
void set_size(int width, int height, bool resizable) {
auto style = NSWindowStyleMaskTitled | NSWindowStyleMaskClosable |
NSWindowStyleMaskMiniaturizable;
if (resizable) {
style = style | NSWindowStyleMaskResizable;
}
objc_msgSend(m_window, "setStyleMask:"_sel, style);
objc_msgSend(m_window, "setFrame:display:animate:"_sel,
CGRectMake(0, 0, width, height), 1, 0);
}
void navigate(const char *url) {
auto nsurl = objc_msgSend(
"NSURL"_cls, "URLWithString:"_sel,
objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, url));
objc_msgSend(
m_webview, "loadRequest:"_sel,
objc_msgSend("NSURLRequest"_cls, "requestWithURL:"_sel, nsurl));
}
void init(const char *js) {
objc_msgSend(
m_manager, "addUserScript:"_sel,
objc_msgSend(
objc_msgSend("WKUserScript"_cls, "alloc"_sel),
"initWithSource:injectionTime:forMainFrameOnly:"_sel,
objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, js),
WKUserScriptInjectionTimeAtDocumentStart, 1));
}
void eval(const char *js) {
objc_msgSend(m_webview, "evaluateJavaScript:completionHandler:"_sel,
objc_msgSend("NSString"_cls, "stringWithUTF8String:"_sel, js),
nullptr);
}
protected:
id m_window;
id m_webview;
id m_manager;
msg_cb_t m_cb;
};
} // namespace webview
#elif defined(WEBVIEW_MSHTML) || defined(WEBVIEW_EDGE)
//
// ====================================================================
//
// This implementation uses Win32 API to create a native window. It can
// use either MSHTML or EdgeHTML backend as a browser engine.
//
// ====================================================================
//
#define WIN32_LEAN_AND_MEAN
#include <windows.h>
#pragma comment(lib, "user32.lib")
namespace webview {
class browser_window {
public:
browser_window(msg_cb_t cb, void *window) : m_cb(cb) {
if (window == nullptr) {
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(WNDCLASSEX));
wc.cbSize = sizeof(WNDCLASSEX);
wc.hInstance = GetModuleHandle(nullptr);
wc.lpszClassName = "webview";
wc.lpfnWndProc =
(WNDPROC)(+[](HWND hwnd, UINT msg, WPARAM wp, LPARAM lp) -> int {
auto w = (browser_window *)GetWindowLongPtr(hwnd, GWLP_USERDATA);
switch (msg) {
case WM_SIZE:
w->resize();
break;
case WM_CLOSE:
DestroyWindow(hwnd);
break;
case WM_DESTROY:
w->terminate();
break;
default:
return DefWindowProc(hwnd, msg, wp, lp);
}
return 0;
});
RegisterClassEx(&wc);
m_window = CreateWindow("webview", "", WS_OVERLAPPEDWINDOW, CW_USEDEFAULT,
CW_USEDEFAULT, 640, 480, nullptr, nullptr,
GetModuleHandle(nullptr), nullptr);
SetWindowLongPtr(m_window, GWLP_USERDATA, (LONG_PTR)this);
} else {
m_window = *(static_cast<HWND *>(window));
}
ShowWindow(m_window, SW_SHOW);
UpdateWindow(m_window);
SetFocus(m_window);
}
void run() {
MSG msg;
BOOL res;
while ((res = GetMessage(&msg, nullptr, 0, 0)) != -1) {
if (msg.hwnd) {
TranslateMessage(&msg);
DispatchMessage(&msg);
continue;
}
if (msg.message == WM_APP) {
auto f = (dispatch_fn_t *)(msg.lParam);
(*f)();
delete f;
} else if (msg.message == WM_QUIT) {
return;
}
}
}
void terminate() { PostQuitMessage(0); }
void dispatch(dispatch_fn_t f) {
PostThreadMessage(m_main_thread, WM_APP, 0, (LPARAM) new dispatch_fn_t(f));
}
void set_title(const char *title) { SetWindowText(m_window, title); }
void set_size(int width, int height, bool resizable) {
RECT r;
r.left = 50;
r.top = 50;
r.right = width;
r.bottom = height;
AdjustWindowRect(&r, WS_OVERLAPPEDWINDOW, 0);
SetWindowPos(m_window, NULL, r.left, r.top, r.right - r.left,
r.bottom - r.top,
SWP_NOZORDER | SWP_NOACTIVATE | SWP_FRAMECHANGED);
}
protected:
virtual void resize() {}
HWND m_window;
DWORD m_main_thread = GetCurrentThreadId();
msg_cb_t m_cb;
};
} // namespace webview
#if defined(WEBVIEW_MSHTML)
#include <exdisp.h>
#include <exdispid.h>
#include <mshtmhst.h>
#include <mshtml.h>
#include <shobjidl.h>
#pragma comment(lib, "ole32.lib")
#pragma comment(lib, "oleaut32.lib")
#define DISPID_EXTERNAL_INVOKE 0x1000
namespace webview {
class browser_engine : public browser_window,
public IOleClientSite,
public IOleInPlaceSite,
public IOleInPlaceFrame,
public IDocHostUIHandler,
public DWebBrowserEvents2 {
public:
browser_engine(msg_cb_t cb, bool debug, void *window)
: browser_window(cb, window) {
RECT rect;
LPCLASSFACTORY cf = nullptr;
IOleObject *obj = nullptr;
fix_ie_compat_mode();
OleInitialize(nullptr);
CoGetClassObject(CLSID_WebBrowser,
CLSCTX_INPROC_SERVER | CLSCTX_INPROC_HANDLER, nullptr,
IID_IClassFactory, (void **)&cf);
cf->CreateInstance(nullptr, IID_IOleObject, (void **)&obj);
cf->Release();
obj->SetClientSite(this);
OleSetContainedObject(obj, TRUE);
GetWindowRect(m_window, &rect);
obj->DoVerb(OLEIVERB_INPLACEACTIVATE, NULL, this, -1, m_window, &rect);
obj->QueryInterface(IID_IWebBrowser2, (void **)&m_webview);
IConnectionPointContainer *cpc;
IConnectionPoint *cp;
DWORD cookie;
m_webview->QueryInterface(IID_IConnectionPointContainer, (void **)&cpc);
cpc->FindConnectionPoint(DIID_DWebBrowserEvents2, &cp);
cpc->Release();
cp->Advise(static_cast<IOleClientSite *>(this), &cookie);
resize();
navigate("about:blank");
}
~browser_engine() { OleUninitialize(); }
void navigate(const char *url) {
VARIANT v;
DWORD size = MultiByteToWideChar(CP_UTF8, 0, url, -1, 0, 0);
WCHAR *ws = (WCHAR *)GlobalAlloc(GMEM_FIXED, sizeof(WCHAR) * size);
MultiByteToWideChar(CP_UTF8, 0, url, -1, ws, size);
VariantInit(&v);
v.vt = VT_BSTR;
v.bstrVal = SysAllocString(ws);
m_webview->Navigate2(&v, nullptr, nullptr, nullptr, nullptr);
VariantClear(&v);
}
void eval(const char *js) {
// TODO
}
private:
IWebBrowser2 *m_webview;
int fix_ie_compat_mode() {
const char *WEBVIEW_KEY_FEATURE_BROWSER_EMULATION =
"Software\\Microsoft\\Internet "
"Explorer\\Main\\FeatureControl\\FEATURE_BROWSER_EMULATION";
HKEY hKey;
DWORD ie_version = 11000;
TCHAR appname[MAX_PATH + 1];
TCHAR *p;
if (GetModuleFileName(NULL, appname, MAX_PATH + 1) == 0) {
return -1;
}
for (p = &appname[strlen(appname) - 1]; p != appname && *p != '\\'; p--) {
}
p++;
if (RegCreateKey(HKEY_CURRENT_USER, WEBVIEW_KEY_FEATURE_BROWSER_EMULATION,
&hKey) != ERROR_SUCCESS) {
return -1;
}
if (RegSetValueEx(hKey, p, 0, REG_DWORD, (BYTE *)&ie_version,
sizeof(ie_version)) != ERROR_SUCCESS) {
RegCloseKey(hKey);
return -1;
}
RegCloseKey(hKey);
return 0;
}
// Inheruted via browser_window
void resize() override {
RECT rect;
GetClientRect(m_window, &rect);
m_webview->put_Left(0);
m_webview->put_Top(0);
m_webview->put_Width(rect.right);
m_webview->put_Height(rect.bottom);
m_webview->put_Visible(VARIANT_TRUE);
}
// Inherited via IUnknown
ULONG __stdcall AddRef(void) override { return 1; }
ULONG __stdcall Release(void) override { return 1; }
HRESULT __stdcall QueryInterface(REFIID riid, void **obj) override {
if (riid == IID_IUnknown || riid == IID_IOleClientSite) {
*obj = static_cast<IOleClientSite *>(this);
return S_OK;
}
if (riid == IID_IOleInPlaceSite) {
*obj = static_cast<IOleInPlaceSite *>(this);
return S_OK;
}
if (riid == IID_IDocHostUIHandler) {
*obj = static_cast<IDocHostUIHandler *>(this);
return S_OK;
}
if (riid == IID_IDispatch || riid == DIID_DWebBrowserEvents2) {
*obj = static_cast<IDispatch *>(this);
return S_OK;
}
*obj = nullptr;
return E_NOINTERFACE;
}
// Inherited via IOleClientSite
HRESULT __stdcall SaveObject(void) override { return E_NOTIMPL; }
HRESULT __stdcall GetMoniker(DWORD dwAssign, DWORD dwWhichMoniker,
IMoniker **ppmk) override {
return E_NOTIMPL;
}
HRESULT __stdcall GetContainer(IOleContainer **ppContainer) override {
*ppContainer = nullptr;
return E_NOINTERFACE;
}
HRESULT __stdcall ShowObject(void) override { return S_OK; }
HRESULT __stdcall OnShowWindow(BOOL fShow) override { return S_OK; }
HRESULT __stdcall RequestNewObjectLayout(void) override { return E_NOTIMPL; }
// Inherited via IOleInPlaceSite
HRESULT __stdcall GetWindow(HWND *phwnd) override {
*phwnd = m_window;
return S_OK;
}
HRESULT __stdcall ContextSensitiveHelp(BOOL fEnterMode) override {
return E_NOTIMPL;
}
HRESULT __stdcall CanInPlaceActivate(void) override { return S_OK; }
HRESULT __stdcall OnInPlaceActivate(void) override { return S_OK; }
HRESULT __stdcall OnUIActivate(void) override { return S_OK; }
HRESULT __stdcall GetWindowContext(
IOleInPlaceFrame **ppFrame, IOleInPlaceUIWindow **ppDoc,
LPRECT lprcPosRect, LPRECT lprcClipRect,
LPOLEINPLACEFRAMEINFO lpFrameInfo) override {
*ppFrame = static_cast<IOleInPlaceFrame *>(this);
*ppDoc = nullptr;
lpFrameInfo->fMDIApp = FALSE;
lpFrameInfo->hwndFrame = m_window;
lpFrameInfo->haccel = 0;
lpFrameInfo->cAccelEntries = 0;
return S_OK;
}
HRESULT __stdcall Scroll(SIZE scrollExtant) override { return E_NOTIMPL; }
HRESULT __stdcall OnUIDeactivate(BOOL fUndoable) override { return S_OK; }
HRESULT __stdcall OnInPlaceDeactivate(void) override { return S_OK; }
HRESULT __stdcall DiscardUndoState(void) override { return E_NOTIMPL; }
HRESULT __stdcall DeactivateAndUndo(void) override { return E_NOTIMPL; }
HRESULT __stdcall OnPosRectChange(LPCRECT lprcPosRect) override {
IOleInPlaceObject *inplace;
m_webview->QueryInterface(IID_IOleInPlaceObject, (void **)&inplace);
inplace->SetObjectRects(lprcPosRect, lprcPosRect);
return S_OK;
}
// Inherited via IDocHostUIHandler
HRESULT __stdcall ShowContextMenu(DWORD dwID, POINT *ppt,
IUnknown *pcmdtReserved,
IDispatch *pdispReserved) override {
return S_OK;
}
HRESULT __stdcall GetHostInfo(DOCHOSTUIINFO *pInfo) override {
pInfo->dwDoubleClick = DOCHOSTUIDBLCLK_DEFAULT;
pInfo->dwFlags = DOCHOSTUIFLAG_NO3DBORDER;
return S_OK;
}
HRESULT __stdcall ShowUI(DWORD dwID, IOleInPlaceActiveObject *pActiveObject,
IOleCommandTarget *pCommandTarget,
IOleInPlaceFrame *pFrame,
IOleInPlaceUIWindow *pDoc) override {
return S_OK;
}
HRESULT __stdcall HideUI(void) override { return S_OK; }
HRESULT __stdcall UpdateUI(void) override { return S_OK; }
HRESULT __stdcall EnableModeless(BOOL fEnable) override { return S_OK; }
HRESULT __stdcall OnDocWindowActivate(BOOL fActivate) override {
return S_OK;
}
HRESULT __stdcall OnFrameWindowActivate(BOOL fActivate) override {
return S_OK;
}
HRESULT __stdcall ResizeBorder(LPCRECT prcBorder,
IOleInPlaceUIWindow *pUIWindow,
BOOL fRameWindow) override {
return S_OK;
}
HRESULT __stdcall GetOptionKeyPath(LPOLESTR *pchKey, DWORD dw) override {
return S_FALSE;
}
HRESULT __stdcall GetDropTarget(IDropTarget *pDropTarget,
IDropTarget **ppDropTarget) override {
return E_NOTIMPL;
}
HRESULT __stdcall GetExternal(IDispatch **ppDispatch) override {
*ppDispatch = static_cast<IDispatch *>(this);
return S_OK;
}
HRESULT __stdcall TranslateUrl(DWORD dwTranslate, LPWSTR pchURLIn,
LPWSTR *ppchURLOut) override {
*ppchURLOut = nullptr;
return S_FALSE;
}
HRESULT __stdcall FilterDataObject(IDataObject *pDO,
IDataObject **ppDORet) override {
*ppDORet = nullptr;
return S_FALSE;
}
HRESULT __stdcall TranslateAcceleratorA(LPMSG lpMsg,
const GUID *pguidCmdGroup,
DWORD nCmdID) {
return S_FALSE;
}
// Inherited via IOleInPlaceFrame
HRESULT __stdcall GetBorder(LPRECT lprectBorder) override { return S_OK; }
HRESULT __stdcall RequestBorderSpace(LPCBORDERWIDTHS pborderwidths) override {
return S_OK;
}
HRESULT __stdcall SetBorderSpace(LPCBORDERWIDTHS pborderwidths) override {
return S_OK;
}
HRESULT __stdcall SetActiveObject(IOleInPlaceActiveObject *pActiveObject,
LPCOLESTR pszObjName) override {
return S_OK;
}
HRESULT __stdcall InsertMenus(HMENU hmenuShared,
LPOLEMENUGROUPWIDTHS lpMenuWidths) override {
return S_OK;
}
HRESULT __stdcall SetMenu(HMENU hmenuShared, HOLEMENU holemenu,
HWND hwndActiveObject) override {
return S_OK;
}
HRESULT __stdcall RemoveMenus(HMENU hmenuShared) override { return S_OK; }
HRESULT __stdcall SetStatusText(LPCOLESTR pszStatusText) override {
return S_OK;
}
HRESULT __stdcall TranslateAcceleratorA(LPMSG lpmsg, WORD wID) {
return S_OK;
}
// Inherited via IDispatch
HRESULT __stdcall GetTypeInfoCount(UINT *pctinfo) override { return S_OK; }
HRESULT __stdcall GetTypeInfo(UINT iTInfo, LCID lcid,
ITypeInfo **ppTInfo) override {
return S_OK;
}
HRESULT __stdcall GetIDsOfNames(REFIID riid, LPOLESTR *rgszNames, UINT cNames,
LCID lcid, DISPID *rgDispId) override {
*rgDispId = DISPID_EXTERNAL_INVOKE;
return S_OK;
}
HRESULT __stdcall Invoke(DISPID dispIdMember, REFIID riid, LCID lcid,
WORD wFlags, DISPPARAMS *pDispParams,
VARIANT *pVarResult, EXCEPINFO *pExcepInfo,
UINT *puArgErr) override {
if (dispIdMember == DISPID_NAVIGATECOMPLETE2) {
} else if (dispIdMember == DISPID_DOCUMENTCOMPLETE) {
} else if (dispIdMember == DISPID_EXTERNAL_INVOKE) {
}
return S_OK;
}
};
} // namespace webview
#elif defined(WEBVIEW_EDGE)
#include <objbase.h>
#include <winrt/Windows.Foundation.h>
#include <winrt/Windows.Web.UI.Interop.h>
#pragma comment(lib, "windowsapp")
namespace webview {
using namespace winrt;
using namespace Windows::Foundation;
using namespace Windows::Web::UI;
using namespace Windows::Web::UI::Interop;
class browser_engine : public browser_window {
public:
browser_engine(msg_cb_t cb, bool debug, void *window)
: browser_window(cb, window) {
init_apartment(winrt::apartment_type::single_threaded);
m_process = WebViewControlProcess();
auto op = m_process.CreateWebViewControlAsync(
reinterpret_cast<int64_t>(m_window), Rect());
if (op.Status() != AsyncStatus::Completed) {
handle h(CreateEvent(nullptr, false, false, nullptr));
op.Completed([h = h.get()](auto, auto) { SetEvent(h); });
HANDLE hs[] = {h.get()};
DWORD i;
CoWaitForMultipleHandles(COWAIT_DISPATCH_WINDOW_MESSAGES |
COWAIT_DISPATCH_CALLS |
COWAIT_INPUTAVAILABLE,
INFINITE, 1, hs, &i);
}
m_webview = op.GetResults();
m_webview.Settings().IsScriptNotifyAllowed(true);
m_webview.IsVisible(true);
m_webview.ScriptNotify([=](auto const &sender, auto const &args) {
std::string s = winrt::to_string(args.Value());
m_cb(s.c_str());
});
m_webview.NavigationStarting([=](auto const &sender, auto const &args) {
m_webview.AddInitializeScript(winrt::to_hstring(init_js));
});
init("window.external.invoke = s => window.external.notify(s)");
resize();
}
void navigate(const char *url) {
Uri uri(winrt::to_hstring(url));
// TODO: if url starts with 'data:text/html,' prefix then use it as a string
m_webview.Navigate(uri);
// m_webview.NavigateToString(winrt::to_hstring(url));
}
void init(const char *js) {
init_js = init_js + "(function(){" + js + "})();";
}
void eval(const char *js) {
m_webview.InvokeScriptAsync(
L"eval", single_threaded_vector<hstring>({winrt::to_hstring(js)}));
}
private:
void resize() {
RECT r;
GetClientRect(m_window, &r);
Rect bounds(r.left, r.top, r.right - r.left, r.bottom - r.top);
m_webview.Bounds(bounds);
}
WebViewControlProcess m_process;
WebViewControl m_webview = nullptr;
std::string init_js = "";
};
} // namespace webview
#endif
#endif /* WEBVIEW_GTK, WEBVIEW_COCOA, WEBVIEW_MSHTML, WEBVIEW_MSHTML */
namespace webview {
class webview : public browser_engine {
public:
webview(bool debug = false, void *wnd = nullptr)
: browser_engine(
std::bind(&webview::on_message, this, std::placeholders::_1), debug,
wnd) {}
void *window() { return (void *)m_window; }
void navigate(const char *url) {
std::string html = html_from_uri(url);
if (html != "") {
browser_engine::navigate(("data:text/html," + url_encode(html)).c_str());
} else {
browser_engine::navigate(url);
}
}
using binding_t = std::function<std::string(std::string)>;
void bind(const char *name, binding_t f) {
auto js = "(function() { var name = '" + std::string(name) + "';" + R"(
window[name] = function() {
var me = window[name];
var errors = me['errors'];
var callbacks = me['callbacks'];
if (!callbacks) {
callbacks = {};
me['callbacks'] = callbacks;
}
if (!errors) {
errors = {};
me['errors'] = errors;
}
var seq = (me['lastSeq'] || 0) + 1;
me['lastSeq'] = seq;
var promise = new Promise(function(resolve, reject) {
callbacks[seq] = resolve;
errors[seq] = reject;
});
window.external.invoke(JSON.stringify({
name: name,
seq:seq,
args: Array.prototype.slice.call(arguments),
}));
return promise;
}
})())";
init(js.c_str());
bindings[name] = new binding_t(f);
}
private:
void on_message(const char *msg) {
auto seq = json_parse(msg, "seq", 0);
auto name = json_parse(msg, "name", 0);
auto args = json_parse(msg, "args", 0);
auto fn = bindings[name];
if (fn == nullptr) {
return;
}
std::async(std::launch::async, [=]() {
auto result = (*fn)(args);
dispatch([=]() {
eval(("var b = window['" + name + "'];b['callbacks'][" + seq + "](" +
result + ");b['callbacks'][" + seq +
"] = undefined;b['errors'][" + seq + "] = undefined;")
.c_str());
});
});
}
std::map<std::string, binding_t *> bindings;
};
} // namespace webview
WEBVIEW_API webview_t webview_create(int debug, void *wnd) {
return new webview::webview(debug, wnd);
}
WEBVIEW_API void webview_destroy(webview_t w) {
delete static_cast<webview::webview *>(w);
}
WEBVIEW_API void webview_run(webview_t w) {
static_cast<webview::webview *>(w)->run();
}
WEBVIEW_API void webview_terminate(webview_t w) {
static_cast<webview::webview *>(w)->terminate();
}
WEBVIEW_API void
webview_dispatch(webview_t w, void (*fn)(webview_t w, void *arg), void *arg) {
static_cast<webview::webview *>(w)->dispatch([=]() { fn(w, arg); });
}
WEBVIEW_API void *webview_get_window(webview_t w) {
return static_cast<webview::webview *>(w)->window();
}
WEBVIEW_API void webview_set_title(webview_t w, const char *title) {
static_cast<webview::webview *>(w)->set_title(title);
}
WEBVIEW_API void webview_set_bounds(webview_t w, int x, int y, int width,
int height, int flags) {
// TODO: x, y, flags
static_cast<webview::webview *>(w)->set_size(width, height, true);
}
WEBVIEW_API void webview_get_bounds(webview_t w, int *x, int *y, int *width,
int *height, int *flags) {
// TODO
}
WEBVIEW_API void webview_navigate(webview_t w, const char *url) {
static_cast<webview::webview *>(w)->navigate(url);
}
WEBVIEW_API void webview_init(webview_t w, const char *js) {
static_cast<webview::webview *>(w)->init(js);
}
WEBVIEW_API void webview_eval(webview_t w, const char *js) {
static_cast<webview::webview *>(w)->eval(js);
}
#endif /* WEBVIEW_HEADER */
#endif /* WEBVIEW_H */
Reference in a new issue View git blame Copy permalink