boinc/api/windows_opengl.C

// 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"

#define BOINC_WINDOW_CLASS_NAME "BOINC_app"

const UINT              WM_BOINCSFW = RegisterWindowMessage(TEXT("BOINCSetForegroundWindow"));


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) {
		if (IsIconic(hWnd) || IsZoomed(hWnd)){
            // If graphics window is minimized or maximized
            // then set default values of window size
			rect.left = 50;
            rect.top = 50;
            rect.right = 50+640;
            rect.bottom = 50+480;
		}
		else GetWindowRect(hWnd, &rect); // else get current values
	}

    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_CREATE:
		app_graphics_init();
		return 0;
	case WM_SIZE:
        if ( SIZE_MINIMIZED == wParam ) {
            visible = FALSE;
        } else {
            visible = TRUE;
        }
		app_graphics_resize(LOWORD(lParam), HIWORD(lParam));
		return 0;
    default:
        if ( WM_BOINCSFW == uMsg ) {
            SetForegroundWindow(hWnd);
        }
	}

	// 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
}


const char *BOINC_RCSID_462f482d81 = "$Id$";