browser-window-ffi 0.0.5

FFI bindings for the browser-window crate.
Documentation 
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

#pragma comment(lib, "libcef.lib")
#pragma comment(lib, "libcef_dll_wrapper.lib")

#include "../application.h"
#include "../cef/app_handler.hpp"
#include "../cef/client_handler.hpp"

#include <include/cef_app.h>
#include <include/cef_base.h>

#ifdef BW_WIN32
#define WIN32_LEAN_AND_MEAN

#include <Windows.h>
#pragma comment(lib, "shell32.lib")
#pragma comment(lib, "user32.lib")
#endif

// Causes the current process to exit with the given exit code.
void _bw_Application_exitProcess( int exit_code );



/*class bw_ApplicationDispatchTask: public CefTask {
	bw_Application* app;
	bw_ApplicationDispatchFn func;
	void* data;

public:
	bw_ApplicationDispatchTask( bw_Application* app, bw_ApplicationDispatchFn func, void* data ) :
		app(app), func(func), data(data)	{}

	void Execute() override {
		this->func( this->app, data );
	}

private:
	IMPLEMENT_REFCOUNTING( bw_ApplicationDispatchTask );
};

void _bw_Application_dispatch_exit( bw_Application* app, void* data ) {
	int* param = (int*)data;

	bw_Application_exit( app, *param );

	delete param;
}

void bw_Application_dispatch( bw_Application* app, bw_ApplicationDispatchFn func, void* data ) {
	CefRefPtr<bw_ApplicationDispatchTask> task( new bw_ApplicationDispatchTask( app, func, data ) );
	CefPostTask( TID_UI, task.get() );
}

void bw_Application_exit( bw_Application* app, int exit_code ) {
	app->exit_code = exit_code;

	CefQuitMessageLoop();
}*/

void _bw_Application_exitProcess( int exit_code ) {
#ifdef BW_WIN32
	ExitProcess( exit_code );
#endif
}

/*void bw_Application_exit_async( bw_Application* app, int exit_code ) {
	int* param = new int( exit_code );

	// This will call bw_Application_exit, but on the GUI thread
	bw_Application_dispatch( app, _bw_Application_dispatch_exit, (void*)param );
}*/

void bw_Application_init( bw_Application* app ) {
	app->engine_data = new bw_ApplicationEngineData;

#ifdef BW_WIN32
	CefMainArgs main_args( GetModuleHandle( NULL ) );
#else
#error Platform not yet supported
#endif

	CefSettings app_settings;
	// Only works on Windows:
	app_settings.multi_threaded_message_loop = 1;
	CefBrowserSettings browser_settings;
	CefRefPtr<CefApp> cef_app_handle( new AppHandler( app ) );

	int exit_code = CefExecuteProcess( main_args, cef_app_handle.get(), 0 );
	// If the current process returns a non-negative number, it is not the main process on which we run user code.
	if ( exit_code >= 0 ) {
		_bw_Application_exitProcess( exit_code );
		return;
	}

	CefRefPtr<CefClient>* client = new CefRefPtr<CefClient>(new ClientHandler( app ));
	//client_handler = (ClientHandler*) client.get();

	CefInitialize( main_args, app_settings, cef_app_handle.get(), 0 );

	app->engine_data->exit_code = 0;
	app->engine_data->cef_client = (void*)client;
}

void bw_Application_step() {
	CefDoMessageLoopWork();
}

void bw_Application_uninit( bw_Application* app ) {
	delete app->engine_data;
}

/*int bw_Application_run( bw_Application* app ) {
	CefRunMessageLoop();

	return app->exit_code;
}

void bw_Application_free( bw_Application* app ) {
	CefShutdown();

	CefRefPtr<CefClient>* app_cef = (CefRefPtr<CefClient>*)app->cef_client;
	delete app_cef;
	delete app;
}*/