mirror of https://github.com/BOINC/boinc.git
442 lines
13 KiB
C
Executable File
442 lines
13 KiB
C
Executable File
// Event loop and support functions for Windows versions
|
|
// of BOINC applications w/ graphics.
|
|
// Platform-independent code should NOT be here.
|
|
//
|
|
|
|
/* This Code Was Created By Jeff Molofee 2000.
|
|
* A HUGE thanks to fredric echols for cleaning up
|
|
* and optimizing this code, making it more flexible!
|
|
* If you've found this code useful, please let me know.
|
|
* Visit My Site At nehe.gamedev.net
|
|
* Adapted to BOINC by Eric Heien
|
|
*/
|
|
#include "boinc_win.h"
|
|
|
|
#include "diagnostics.h"
|
|
#include "boinc_api.h"
|
|
#include "graphics_api.h"
|
|
#include "app_ipc.h"
|
|
#include "util.h"
|
|
#include "win_util.h"
|
|
|
|
#define BOINC_WINDOW_CLASS_NAME "BOINC_app"
|
|
|
|
static HDC hDC = NULL;
|
|
static HGLRC hRC = NULL;
|
|
static HWND hWnd = NULL; // Holds Our Window Handle
|
|
static HINSTANCE hInstance; // Holds The Instance Of The Application
|
|
static RECT rect = {50, 50, 50+640, 50+480};
|
|
static int current_graphics_mode = MODE_HIDE_GRAPHICS;
|
|
static int acked_graphics_mode = -1;
|
|
static POINT mousePos;
|
|
static HDC myhDC;
|
|
BOOL win_loop_done;
|
|
|
|
static GRAPHICS_MSG graphics_msg;
|
|
static HWINSTA hOriginalWindowStation = NULL;
|
|
static HDESK hOriginalDesktop = NULL;
|
|
static HWINSTA hInteractiveWindowStation = NULL;
|
|
static HDESK hInteractiveDesktop = NULL;
|
|
|
|
|
|
static bool visible = true;
|
|
|
|
void KillWindow() {
|
|
wglMakeCurrent(NULL,NULL); // release GL rendering context
|
|
if (hRC) {
|
|
wglDeleteContext(hRC);
|
|
hRC=NULL;
|
|
}
|
|
|
|
if (hWnd && hDC) {
|
|
ReleaseDC(hWnd,hDC);
|
|
}
|
|
hDC = NULL;
|
|
|
|
if (hWnd) {
|
|
DestroyWindow(hWnd);
|
|
}
|
|
hWnd = NULL;
|
|
|
|
if (hOriginalWindowStation) {
|
|
SetProcessWindowStation(hOriginalWindowStation);
|
|
CloseWindowStation(hInteractiveWindowStation);
|
|
hInteractiveWindowStation = NULL;
|
|
}
|
|
|
|
if (hOriginalDesktop) {
|
|
SetThreadDesktop(hOriginalDesktop);
|
|
CloseDesktop(hInteractiveDesktop);
|
|
hInteractiveDesktop = NULL;
|
|
}
|
|
}
|
|
|
|
void SetupPixelFormat(HDC hDC) {
|
|
int nPixelFormat;
|
|
|
|
static PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR), // size of structure.
|
|
1, // always 1.
|
|
PFD_DRAW_TO_WINDOW | // support window
|
|
PFD_SUPPORT_OPENGL | // support OpenGl
|
|
PFD_DOUBLEBUFFER, // support double buffering
|
|
PFD_TYPE_RGBA, // support RGBA
|
|
32, // 32 bit color mode
|
|
0, 0, 0, 0, 0, 0, // ignore color bits
|
|
0, // no alpha buffer
|
|
0, // ignore shift bit
|
|
0, // no accumulation buffer
|
|
0, 0, 0, 0, // ignore accumulation bits.
|
|
16, // number of depth buffer bits.
|
|
0, // number of stencil buffer bits.
|
|
0, // 0 means no auxiliary buffer
|
|
PFD_MAIN_PLANE, // The main drawing plane
|
|
0, // this is reserved
|
|
0, 0, 0 }; // layer masks ignored.
|
|
|
|
// this chooses the best pixel format and returns index.
|
|
nPixelFormat = ChoosePixelFormat(hDC, &pfd);
|
|
|
|
// This set pixel format to device context.
|
|
SetPixelFormat(hDC, nPixelFormat, &pfd);
|
|
}
|
|
|
|
static void make_new_window() {
|
|
RECT WindowRect = {0,0,0,0};
|
|
int width, height;
|
|
DWORD dwExStyle;
|
|
DWORD dwStyle;
|
|
|
|
if (current_graphics_mode == MODE_FULLSCREEN) {
|
|
HDC screenDC=GetDC(NULL);
|
|
WindowRect.left = WindowRect.top = 0;
|
|
WindowRect.right=GetDeviceCaps(screenDC, HORZRES);
|
|
WindowRect.bottom=GetDeviceCaps(screenDC, VERTRES);
|
|
ReleaseDC(NULL, screenDC);
|
|
dwExStyle=WS_EX_TOPMOST;
|
|
dwStyle=WS_POPUP;
|
|
while(ShowCursor(false) >= 0);
|
|
} else {
|
|
WindowRect = rect;
|
|
dwExStyle=WS_EX_APPWINDOW|WS_EX_WINDOWEDGE;
|
|
dwStyle=WS_OVERLAPPEDWINDOW;
|
|
while(ShowCursor(true) < 0);
|
|
}
|
|
|
|
APP_INIT_DATA aid;
|
|
boinc_get_init_data(aid);
|
|
if (!strlen(aid.app_name)) strcpy(aid.app_name, "BOINC Application");
|
|
hWnd = CreateWindowEx(dwExStyle, BOINC_WINDOW_CLASS_NAME, aid.app_name,
|
|
dwStyle|WS_CLIPSIBLINGS|WS_CLIPCHILDREN, WindowRect.left, WindowRect.top,
|
|
WindowRect.right-WindowRect.left,WindowRect.bottom-WindowRect.top,
|
|
NULL, NULL, hInstance, NULL
|
|
);
|
|
|
|
SetForegroundWindow(hWnd);
|
|
|
|
GetCursorPos(&mousePos);
|
|
|
|
hDC = GetDC(hWnd);
|
|
myhDC=hDC;
|
|
SetupPixelFormat(myhDC);
|
|
|
|
if(!(hRC = wglCreateContext(hDC))) {
|
|
ReleaseDC(hWnd, hDC);
|
|
return;
|
|
}
|
|
|
|
if(!wglMakeCurrent(hDC, hRC)) {
|
|
ReleaseDC(hWnd, hDC);
|
|
wglDeleteContext(hRC);
|
|
return;
|
|
}
|
|
|
|
width = WindowRect.right-WindowRect.left;
|
|
height = WindowRect.bottom-WindowRect.top;
|
|
|
|
ShowWindow(hWnd, SW_SHOW);
|
|
SetFocus(hWnd);
|
|
|
|
app_graphics_init();
|
|
}
|
|
|
|
// switch to the given graphics mode. This is called:
|
|
// - on initialization
|
|
// - when get mode change msg (via shared mem)
|
|
// - when in SS mode and get user input
|
|
//
|
|
static void set_mode(int mode) {
|
|
int new_mode = mode;
|
|
|
|
if (mode == current_graphics_mode) return;
|
|
if (current_graphics_mode != MODE_FULLSCREEN) GetWindowRect(hWnd, &rect);
|
|
|
|
KillWindow();
|
|
|
|
if (!boinc_is_standalone() &&
|
|
strlen(graphics_msg.window_station) > 0 &&
|
|
strlen(graphics_msg.desktop) > 0)
|
|
{
|
|
GetDesktopWindow();
|
|
|
|
if (NULL == hOriginalWindowStation) {
|
|
hOriginalWindowStation = GetProcessWindowStation();
|
|
if (NULL == hOriginalWindowStation) {
|
|
BOINCTRACE(_T("Failed to retrieve the orginal window station\n"));
|
|
}
|
|
}
|
|
|
|
if (NULL == hOriginalDesktop) {
|
|
hOriginalDesktop = GetThreadDesktop(GetCurrentThreadId());
|
|
if (NULL == hOriginalDesktop) {
|
|
BOINCTRACE(_T("Failed to retrieve the orginal desktop\n"));
|
|
}
|
|
}
|
|
|
|
hInteractiveWindowStation = OpenWindowStation( graphics_msg.window_station, FALSE, GENERIC_READ );
|
|
if (NULL == hInteractiveWindowStation) {
|
|
BOINCTRACE(_T("Failed to retrieve the required window station\n"));
|
|
new_mode = MODE_UNSUPPORTED;
|
|
} else {
|
|
BOINCTRACE(_T("Retrieved the required window station\n"));
|
|
SetProcessWindowStation(hInteractiveWindowStation);
|
|
hInteractiveDesktop = OpenDesktop( graphics_msg.desktop, NULL, FALSE, GENERIC_READ | DESKTOP_CREATEWINDOW | DESKTOP_CREATEMENU );
|
|
if (NULL == hInteractiveDesktop) {
|
|
BOINCTRACE(_T("Failed to retrieve the required desktop\n"));
|
|
new_mode = MODE_UNSUPPORTED;
|
|
} else {
|
|
BOINCTRACE(_T("Retrieved the required desktop\n"));
|
|
SetThreadDesktop(hInteractiveDesktop);
|
|
}
|
|
}
|
|
}
|
|
|
|
current_graphics_mode = new_mode;
|
|
if (new_mode != MODE_HIDE_GRAPHICS && new_mode != MODE_QUIT && new_mode != MODE_UNSUPPORTED) {
|
|
make_new_window();
|
|
}
|
|
|
|
}
|
|
|
|
void parse_mouse_event(UINT uMsg, int& which, bool& down) {
|
|
switch(uMsg) {
|
|
case WM_LBUTTONDOWN: which = 0; down = true; break;
|
|
case WM_MBUTTONDOWN: which = 1; down = true; break;
|
|
case WM_RBUTTONDOWN: which = 2; down = true; break;
|
|
case WM_LBUTTONUP: which = 0; down = false; break;
|
|
case WM_MBUTTONUP: which = 1; down = false; break;
|
|
case WM_RBUTTONUP: which = 2; down = false; break;
|
|
}
|
|
}
|
|
|
|
// message handler (includes timer, Windows msgs)
|
|
//
|
|
LRESULT CALLBACK WndProc(
|
|
HWND hWnd, // Handle For This Window
|
|
UINT uMsg, // Message For This Window
|
|
WPARAM wParam, // Additional Message Information
|
|
LPARAM lParam // Additional Message Information
|
|
) {
|
|
switch(uMsg) {
|
|
case WM_ERASEBKGND: // Check To See If Windows Is Trying To Erase The Background
|
|
return 0;
|
|
case WM_KEYDOWN:
|
|
case WM_KEYUP:
|
|
if (current_graphics_mode == MODE_FULLSCREEN) {
|
|
set_mode(MODE_QUIT);
|
|
} else {
|
|
if (uMsg == WM_KEYDOWN) {
|
|
boinc_app_key_press((int)wParam, (int)lParam);
|
|
} else {
|
|
boinc_app_key_release((int)wParam, (int)lParam);
|
|
}
|
|
}
|
|
return 0;
|
|
case WM_LBUTTONDOWN:
|
|
case WM_MBUTTONDOWN:
|
|
case WM_RBUTTONDOWN:
|
|
case WM_LBUTTONUP:
|
|
case WM_MBUTTONUP:
|
|
case WM_RBUTTONUP:
|
|
if (current_graphics_mode == MODE_FULLSCREEN) {
|
|
set_mode(MODE_QUIT);
|
|
} else {
|
|
int which;
|
|
bool down;
|
|
POINT cPos;
|
|
GetCursorPos(&cPos);
|
|
parse_mouse_event(uMsg, which, down);
|
|
boinc_app_mouse_button(cPos.x, cPos.y, which, down);
|
|
}
|
|
return 0;
|
|
case WM_MOUSEMOVE:
|
|
POINT cPos;
|
|
GetCursorPos(&cPos);
|
|
if(current_graphics_mode == MODE_FULLSCREEN) {
|
|
if(cPos.x != mousePos.x || cPos.y != mousePos.y) {
|
|
set_mode(MODE_QUIT);
|
|
}
|
|
} else {
|
|
boinc_app_mouse_move(
|
|
cPos.x, cPos.y,
|
|
(wParam&MK_LBUTTON)!=0,
|
|
(wParam&MK_MBUTTON)!=0,
|
|
(wParam&MK_RBUTTON)!=0
|
|
);
|
|
}
|
|
return 0;
|
|
case WM_CLOSE:
|
|
if (boinc_is_standalone()) {
|
|
exit(0);
|
|
} else {
|
|
set_mode(MODE_HIDE_GRAPHICS);
|
|
return 0;
|
|
}
|
|
case WM_PAINT:
|
|
PAINTSTRUCT ps;
|
|
RECT winRect;
|
|
HDC pdc;
|
|
pdc = BeginPaint(hWnd, &ps);
|
|
GetClientRect(hWnd, &winRect);
|
|
FillRect(pdc, &winRect, (HBRUSH)GetStockObject(BLACK_BRUSH));
|
|
EndPaint(hWnd, &ps);
|
|
return 0;
|
|
case WM_SIZE:
|
|
if ( SIZE_MINIMIZED == wParam ) {
|
|
visible = FALSE;
|
|
} else {
|
|
visible = TRUE;
|
|
}
|
|
app_graphics_resize(LOWORD(lParam), HIWORD(lParam));
|
|
return 0;
|
|
}
|
|
|
|
// Pass All Unhandled Messages To DefWindowProc
|
|
return DefWindowProc(hWnd,uMsg,wParam,lParam);
|
|
}
|
|
|
|
BOOL reg_win_class() {
|
|
WNDCLASS wc; // Windows Class Structure
|
|
|
|
hInstance = GetModuleHandle(NULL); // Grab An Instance For Our Window
|
|
wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC; // Redraw On Size, And Own DC For Window.
|
|
wc.lpfnWndProc = (WNDPROC) WndProc; // WndProc Handles Messages
|
|
wc.cbClsExtra = 0; // No Extra Window Data
|
|
wc.cbWndExtra = 0; // No Extra Window Data
|
|
wc.hInstance = hInstance; // Set The Instance
|
|
wc.hIcon = LoadIcon(NULL, IDI_WINLOGO); // Load The Default Icon
|
|
wc.hCursor = LoadCursor(NULL, IDC_ARROW); // Load The Arrow Pointer
|
|
wc.hbrBackground = NULL; // No Background Required For GL
|
|
wc.lpszMenuName = NULL; // We Don't Want A Menu
|
|
wc.lpszClassName = BOINC_WINDOW_CLASS_NAME; // Set The Class Name
|
|
|
|
if (!RegisterClass(&wc)) // Attempt To Register The Window Class
|
|
{
|
|
MessageBox(NULL,"Failed To Register The Window Class.","ERROR",MB_OK|MB_ICONEXCLAMATION);
|
|
return FALSE; // Return FALSE
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
BOOL unreg_win_class() {
|
|
if (!UnregisterClass(BOINC_WINDOW_CLASS_NAME,hInstance)) {
|
|
MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION);
|
|
hInstance=NULL; // Set hInstance To NULL
|
|
}
|
|
|
|
return TRUE;
|
|
}
|
|
|
|
static VOID CALLBACK timer_handler(HWND, UINT, UINT, DWORD) {
|
|
RECT rt;
|
|
int width, height;
|
|
char buf[MSG_CHANNEL_SIZE];
|
|
|
|
// check for graphics-related message from core client
|
|
//
|
|
if (app_client_shm) {
|
|
if (app_client_shm->shm->graphics_request.get_msg(buf)) {
|
|
//fprintf(stderr, "%d got graphics request: %s\n", time(0), buf); fflush(stderr);
|
|
app_client_shm->decode_graphics_msg(buf, graphics_msg);
|
|
switch (graphics_msg.mode) {
|
|
case MODE_REREAD_PREFS:
|
|
// only reread graphics prefs if we have a window open
|
|
//
|
|
switch(current_graphics_mode) {
|
|
case MODE_WINDOW:
|
|
case MODE_FULLSCREEN:
|
|
app_graphics_reread_prefs();
|
|
break;
|
|
}
|
|
break;
|
|
case MODE_HIDE_GRAPHICS:
|
|
case MODE_WINDOW:
|
|
case MODE_FULLSCREEN:
|
|
case MODE_BLANKSCREEN:
|
|
set_mode(graphics_msg.mode);
|
|
break;
|
|
}
|
|
}
|
|
// ack graphics mode
|
|
//
|
|
if (acked_graphics_mode != current_graphics_mode) {
|
|
bool sent = app_client_shm->shm->graphics_reply.send_msg(
|
|
xml_graphics_modes[current_graphics_mode]
|
|
);
|
|
if (sent) acked_graphics_mode = current_graphics_mode;
|
|
if (MODE_QUIT == current_graphics_mode) {
|
|
current_graphics_mode = MODE_HIDE_GRAPHICS;
|
|
}
|
|
}
|
|
}
|
|
if (!visible) return;
|
|
if (current_graphics_mode == MODE_HIDE_GRAPHICS) return;
|
|
if (!hWnd) return;
|
|
|
|
// TODO: remove width, height from API
|
|
//
|
|
GetClientRect(hWnd, &rt);
|
|
width = rt.right-rt.left;
|
|
height = rt.bottom-rt.top;
|
|
|
|
if (throttled_app_render(width, height, dtime())) {
|
|
SwapBuffers(hDC);
|
|
}
|
|
}
|
|
|
|
void win_graphics_event_loop() {
|
|
MSG msg; // Windows Message Structure
|
|
|
|
// Register window class and graphics mode message
|
|
reg_win_class();
|
|
|
|
SetTimer(NULL, 1, 30, &timer_handler);
|
|
|
|
if (boinc_is_standalone()) {
|
|
set_mode(MODE_WINDOW);
|
|
} else {
|
|
set_mode(MODE_HIDE_GRAPHICS);
|
|
}
|
|
win_loop_done = false;
|
|
while(!win_loop_done) {
|
|
if (GetMessage(&msg,NULL,0,0)) {
|
|
TranslateMessage(&msg);
|
|
DispatchMessage(&msg);
|
|
} else {
|
|
win_loop_done = true;
|
|
}
|
|
}
|
|
|
|
unreg_win_class();
|
|
|
|
SetEvent(hQuitEvent); // Signal the worker thread that we're quitting
|
|
}
|
|
|
|
|
|
#ifdef __GNUC__
|
|
static volatile const char __attribute__((unused)) *BOINCrcsid="$Id$";
|
|
#else
|
|
static volatile const char *BOINCrcsid="$Id$";
|
|
#endif
|