// Event loop and support functions for Windows versions // of BOINC applications w/ graphics. // Platform-independent code should NOT be here. // // TODO: Is any of this related to or dependent on OpenGL?? // Why not make it independent of OpenGL? // /* 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 #include // Header File For The OpenGL32 Library #include // Header File For The GLu32 Library #include #include #include "boinc_api.h" #include "graphics_api.h" #include "app_ipc.h" #include "util.h" //#include "win_idle_tracker.h" //remove if there are windows problems #define WIN32_LEAN_AND_MEAN // This trims down the windows libraries. #define WIN32_EXTRA_LEAN // Trims even farther. //#define DRAW_WITH_DLL #ifdef DRAW_WITH_DLL __declspec(dllimport) void vis_render(int,int,double,float*,int); __declspec(dllimport) void vis_unload(); __declspec(dllimport) void vis_init(); #pragma comment(lib,"../../vis_dll/debug/vis.lib") #endif static HDC hDC; static HGLRC hRC; 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 POINT mousePos; static UINT m_uEndSSMsg; HDC myhDC; BOOL win_loop_done; extern bool using_opengl; extern bool standalone; extern HANDLE hQuitEvent; extern unsigned int MyCreateFont(char *fontName, int Size, int weight); void SetupPixelFormat(HDC hDC); LRESULT CALLBACK WndProc(HWND, UINT, WPARAM, LPARAM); // Declaration For WndProc BOOL reg_win_class(); BOOL unreg_win_class(); bool KillWindow() { #ifdef DRAW_WITH_DLL if(hDC) vis_unload(); #else //if(hDC) app_unload_gl(); #endif if (hRC) { // Do We Have A Rendering Context? if (!wglMakeCurrent(NULL,NULL)) { // Are We Able To Release The DC And RC Contexts? return false; } if (!wglDeleteContext(hRC)) { // Are We Able To Delete The RC? return false; } hRC=NULL; // Set RC To NULL } if (hDC && !ReleaseDC(hWnd,hDC)) { // Are We Able To Release The DC hDC=NULL; // Set DC To NULL return false; } KillTimer(hWnd, 1); if (hWnd && !DestroyWindow(hWnd)) { // Are We Able To Destroy The Window? return false; hWnd=NULL; // Set hWnd To NULL } return true; } // 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 // void SetMode(int mode) { RECT WindowRect = {0,0,0,0}; int width, height; DWORD dwExStyle; DWORD dwStyle; if (current_graphics_mode != MODE_FULLSCREEN) GetWindowRect(hWnd, &rect); KillWindow(); current_graphics_mode = mode; 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); } // Do not do AdjustWindowRectEx here, this will // cause the window to creep upwards APP_INIT_DATA aid; boinc_get_init_data(aid); if (!strlen(aid.app_name)) strcpy(aid.app_name, "BOINC Application"); hWnd = CreateWindowEx(dwExStyle, "BOINC_OpenGL", 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; SetTimer(hWnd, 1, 100, NULL); if(current_graphics_mode == MODE_FULLSCREEN || current_graphics_mode == MODE_WINDOW) { ShowWindow(hWnd, SW_SHOW); SetFocus(hWnd); } else { ShowWindow(hWnd, SW_HIDE); } app_client_shm->send_graphics_mode_msg(APP_CORE_GFX_SEG, current_graphics_mode); } // 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 { RECT rt; int width, height, new_mode; static bool visible = true; switch(uMsg) { case WM_SHOWWINDOW: // this is an attempt to avoid wasting CPU time on rendering // when the window is minimized or hidden. // Doesn't seem to work though - never get this message // visible = (wParam == TRUE); return 0; case WM_KEYDOWN: case WM_KEYUP: case WM_LBUTTONDOWN: case WM_MBUTTONDOWN: case WM_RBUTTONDOWN: if(current_graphics_mode == MODE_FULLSCREEN) { SetMode(MODE_HIDE_GRAPHICS); PostMessage(HWND_BROADCAST, m_uEndSSMsg, 0, 0); } return 0; case WM_MOUSEMOVE: if(current_graphics_mode == MODE_FULLSCREEN) { POINT cPos; GetCursorPos(&cPos); if(cPos.x != mousePos.x || cPos.y != mousePos.y) { SetMode(MODE_HIDE_GRAPHICS); PostMessage(HWND_BROADCAST, m_uEndSSMsg, 0, 0); } } return 0; case WM_CLOSE: if (standalone) { exit(0); } else { SetMode(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: ReSizeGLScene(LOWORD(lParam),HIWORD(lParam)); return 0; case WM_TIMER: if (app_client_shm->get_graphics_mode_msg(CORE_APP_GFX_SEG, new_mode)) { SetMode(new_mode); } if (!visible) return 0; if (current_graphics_mode == MODE_HIDE_GRAPHICS) return 0; // 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); } return 0; } // Pass All Unhandled Messages To DefWindowProc return DefWindowProc(hWnd,uMsg,wParam,lParam); } DWORD WINAPI win_graphics_event_loop( LPVOID gi ) { MSG msg; // Windows Message Structure double start = (double)time(0); m_uEndSSMsg = RegisterWindowMessage(END_SS_MSG); // Register window class and graphics mode message reg_win_class(); if (standalone) { SetMode(MODE_WINDOW); } else { SetMode(MODE_HIDE_GRAPHICS); } InitGL(); app_init_gl(); win_loop_done = false; using_opengl = true; 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 to the worker thread that we're quitting return (msg.wParam); // Exit The thread } BOOL VerifyPassword(HWND hwnd) { // Under NT, we return TRUE immediately. This lets the saver quit, // and the system manages passwords. Under '95, we call VerifyScreenSavePwd. // This checks the appropriate registry key and, if necessary, // pops up a verify dialog OSVERSIONINFO osv; osv.dwOSVersionInfoSize=sizeof(osv); GetVersionEx(&osv); if (osv.dwPlatformId==VER_PLATFORM_WIN32_NT) return TRUE; HINSTANCE hpwdcpl=::LoadLibrary("PASSWORD.CPL"); if (hpwdcpl==NULL) {return TRUE;} typedef BOOL (WINAPI *VERIFYSCREENSAVEPWD)(HWND hwnd); VERIFYSCREENSAVEPWD VerifyScreenSavePwd; VerifyScreenSavePwd= (VERIFYSCREENSAVEPWD)GetProcAddress(hpwdcpl,"VerifyScreenSavePwd"); if (VerifyScreenSavePwd==NULL) { FreeLibrary(hpwdcpl);return TRUE; } BOOL bres=VerifyScreenSavePwd(hwnd); FreeLibrary(hpwdcpl); return bres; } 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_OpenGL"; // 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_OpenGL",hInstance)) // Are We Able To Unregister Class { MessageBox(NULL,"Could Not Unregister Class.","SHUTDOWN ERROR",MB_OK | MB_ICONINFORMATION); hInstance=NULL; // Set hInstance To NULL } return TRUE; } 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); // Remember that its not important to fully understand the pixel format, // just remember to include in all of your applications and you'll be // good to go. } float txt_widths[256]; unsigned int MyCreateFont(char *fontName, int Size, int weight) { // windows font HFONT hFont; unsigned int mylistbase =0; // Create space for 96 characters. mylistbase= glGenLists(256); if(stricmp(fontName, "symbol")==0) { hFont = CreateFont(Size, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, SYMBOL_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH, fontName); } else { hFont = CreateFont(Size, 0, 0, 0, FW_BOLD, FALSE, FALSE, FALSE, ANSI_CHARSET, OUT_TT_PRECIS, CLIP_DEFAULT_PRECIS, ANTIALIASED_QUALITY, FF_DONTCARE | DEFAULT_PITCH, fontName); } if(!hFont) return -1; SelectObject(myhDC, hFont); #if 1 //no idea why this has to be twice wglUseFontBitmaps(myhDC, 0, 256, mylistbase); wglUseFontBitmaps(myhDC, 0, 256, mylistbase); #endif #if 0 wglUseFontOutlines(hDC,0,255,mylistbase,0.0f,0.2f,WGL_FONT_POLYGONS,gmf); #endif TEXTMETRIC met; GetTextMetrics(myhDC,&met); GetCharWidthFloat(myhDC,met.tmFirstChar,met.tmLastChar,txt_widths); return mylistbase; } float get_char_width(unsigned char c) { return txt_widths[c]; }