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

#pragma comment(lib, "user32.lib")
#pragma comment(lib, "gdi32.lib")
#pragma comment(lib, "ole32.lib")

//#include "win32.h"
#include "../application.h"

#include <stdlib.h>
#define WIN32_LEAN_AND_MEAN

#include <WinDef.h>
#include <Windows.h>

#include "../win32.h"
#include "../window/win32.h"

#include <stdio.h>



void bw_Application_dispatch( bw_Application* app, bw_ApplicationDispatchFn func, void* data ) {

	bw_ApplicationDispatchData* dispatch_data = malloc( sizeof( bw_ApplicationDispatchData ) );
	dispatch_data->func = func;
	dispatch_data->data = data;

	PostThreadMessageW( app->thread_id, WM_APP, (WPARAM)NULL, (LPARAM)dispatch_data );
}

bw_Application* bw_Application_new() {

	bw_Application* app = malloc( sizeof( bw_Application ) );

	app->thread_id = GetCurrentThreadId();
 	app->handle = GetModuleHandle( NULL );
	app->engine_data = 0;
	app->windows_alive = 0;

	bw_Application_init( app );

	// Register window class
	memset( &app->wc, 0, sizeof(WNDCLASSEX) );
	app->wc.cbSize = sizeof( WNDCLASSEX );
	app->wc.hInstance = app->handle;
	app->wc.lpfnWndProc = bw_Window_proc;
	app->wc.lpszClassName = L"browser_window";
	RegisterClassExW( &app->wc );

	return app;
}

void bw_Application_free( bw_Application* app ) {

	bw_Application_uninit( app );

	UnregisterClassW( L"browser_window", app->handle );

	free( app );
}


void bw_Application_exit( bw_Application* app, int exit_code ) {
	// We assume the size of an int is smaller or equal to the size of a pointer.
	// This should be true for 32 and 64 bit systems in general.
	_STATIC_ASSERT( sizeof(int) <= sizeof(WPARAM) );

	PostThreadMessageW( app->thread_id, WM_QUIT, (WPARAM)exit_code, (LPARAM)NULL );
}

void bw_Application_exitAsync( bw_Application* app, int code ) {
	// PostThreadMessage is threadsafe, so we do exactly the same thing
	bw_Application_exit( app, code );
}

int bw_Application_run( bw_Application* app ) {
	MSG msg;

	while ( 1 ) {
		BOOL res = GetMessageW( &msg, 0, 0, 0);
		if ( res == 0 ) {
			int exit_code = (int)msg.wParam;
			return exit_code;
		}
		else if (res == -1) {
			BW_WIN32_ASSERT_ERROR;
		}
		else {
			TranslateMessage( &msg );
			DispatchMessageW( &msg );

			// Execute the dispatch functions when given
			if ( msg.message == WM_APP ) {
				bw_ApplicationDispatchData* params = (bw_ApplicationDispatchData*)msg.lParam;

				(params->func)( app, params->data );

				free( params );
			}
			else if ( msg.message == WM_APP + 1 ) {
				bw_WindowDispatchData* params = (bw_WindowDispatchData*)msg.lParam;

				(params->func)( params->window, params->data );

				free( params );
			}
		}
	}
}