|
|
@@ -1,3566 +0,0 @@
|
|
|
-// Filename: wcrGraphicsWindow.cxx
|
|
|
-// Created by:
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-//
|
|
|
-// PANDA 3D SOFTWARE
|
|
|
-// Copyright (c) 2001, Disney Enterprises, Inc. All rights reserved
|
|
|
-//
|
|
|
-// All use of this software is subject to the terms of the Panda 3d
|
|
|
-// Software license. You should have received a copy of this license
|
|
|
-// along with this source code; you will also find a current copy of
|
|
|
-// the license at http://www.panda3d.org/license.txt .
|
|
|
-//
|
|
|
-// To contact the maintainers of this program write to
|
|
|
-// [email protected] .
|
|
|
-//
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-
|
|
|
-#include "wglGraphicsWindow.h"
|
|
|
-#include "wglGraphicsPipe.h"
|
|
|
-#include "config_wgldisplay.h"
|
|
|
-#include <keyboardButton.h>
|
|
|
-#include <mouseButton.h>
|
|
|
-#include <glGraphicsStateGuardian.h>
|
|
|
-#include <errno.h>
|
|
|
-#include <time.h>
|
|
|
-#include <mmsystem.h>
|
|
|
-#include <ddraw.h>
|
|
|
-#include <tchar.h>
|
|
|
-#include <map>
|
|
|
-#include <throw_event.h>
|
|
|
-//#include <eventQueue.h>
|
|
|
-#include <string.h>
|
|
|
-#include "Win32Defs.h"
|
|
|
-
|
|
|
-#ifdef DO_PSTATS
|
|
|
-#include <pStatTimer.h>
|
|
|
-#endif
|
|
|
-
|
|
|
-#define WGL_WGLEXT_PROTOTYPES
|
|
|
-#include "wglext.h"
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Static variables
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-TypeHandle wglGraphicsWindow::_type_handle;
|
|
|
-
|
|
|
-static bool wc_registered = false;
|
|
|
-
|
|
|
-#define FONT_BITMAP_OGLDISPLAYLISTNUM 1000 // an arbitrary ID #
|
|
|
-
|
|
|
-#define LAST_ERROR 0
|
|
|
-#define ERRORBOX_TITLE "Panda3D Error"
|
|
|
-#define WGL_WINDOWCLASSNAME "wglDisplay"
|
|
|
-
|
|
|
-#define PAUSED_TIMER_ID 7 // completely arbitrary choice
|
|
|
-
|
|
|
-typedef map<HWND,wglGraphicsWindow *> HWND_PANDAWIN_MAP;
|
|
|
-
|
|
|
-HWND_PANDAWIN_MAP hwnd_pandawin_map;
|
|
|
-wglGraphicsWindow *global_wglwinptr=NULL; // need this for temporary windproc
|
|
|
-
|
|
|
-typedef enum {Software, MCD, ICD} OGLDriverType;
|
|
|
-static char *OGLDrvStrings[3] = {"Software","MCD","ICD"};
|
|
|
-
|
|
|
-LONG WINAPI static_window_proc(HWND hwnd, UINT msg, WPARAM wparam,LPARAM lparam);
|
|
|
-extern char *ConvDDErrorToString(const HRESULT &error);
|
|
|
-
|
|
|
-// because we dont have access to ModifierButtons, as a hack just synchronize state of these
|
|
|
-// keys on get/lose keybd focus
|
|
|
-#define NUM_MODIFIER_KEYS 16
|
|
|
-unsigned int hardcoded_modifier_buttons[NUM_MODIFIER_KEYS]={VK_SHIFT,VK_MENU,VK_CONTROL,VK_SPACE,VK_TAB,
|
|
|
- VK_UP,VK_DOWN,VK_LEFT,VK_RIGHT,VK_PRIOR,VK_NEXT,VK_HOME,VK_END,
|
|
|
- VK_INSERT,VK_DELETE,VK_ESCAPE};
|
|
|
-
|
|
|
-// dont pick any video modes < MIN_REFRESH_RATE Hz
|
|
|
-#define MIN_REFRESH_RATE 60
|
|
|
-// EnumDisplaySettings may indicate 0 or 1 for refresh rate, which means use driver default rate (assume its >min_refresh_rate)
|
|
|
-#define ACCEPTABLE_REFRESH_RATE(RATE) ((RATE >= MIN_REFRESH_RATE) || (RATE==0) || (RATE==1))
|
|
|
-
|
|
|
-void PrintErrorMessage(DWORD msgID) {
|
|
|
- LPTSTR pMessageBuffer;
|
|
|
-
|
|
|
- if (msgID==LAST_ERROR)
|
|
|
- msgID=GetLastError();
|
|
|
-
|
|
|
- FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM,
|
|
|
- NULL,msgID,
|
|
|
- MAKELANGID(LANG_NEUTRAL, SUBLANG_DEFAULT), //The user default language
|
|
|
- (LPTSTR) &pMessageBuffer, // the weird ptrptr->ptr cast is intentional, see FORMAT_MESSAGE_ALLOCATE_BUFFER
|
|
|
- 1024, NULL);
|
|
|
- MessageBox(GetDesktopWindow(),pMessageBuffer,_T(ERRORBOX_TITLE),MB_OK);
|
|
|
- wgldisplay_cat.fatal() << "System error msg: " << pMessageBuffer << endl;
|
|
|
- LocalFree(pMessageBuffer);
|
|
|
-}
|
|
|
-
|
|
|
-// fn exists so AtExitFn can call it without refcntr blowing up since its !=0
|
|
|
-void wglGraphicsWindow::DestroyMe(bool bAtExitFnCalled) {
|
|
|
-
|
|
|
- _exiting_window = true; // needed before DestroyWindow call
|
|
|
-
|
|
|
- // several GL drivers (voodoo,ATI, not nvidia) crash if we call these wgl deletion routines from
|
|
|
- // an atexit() fn. Possible that GL has already unloaded itself. So we just wont call them for now
|
|
|
- // for that case, we're exiting the app anyway.
|
|
|
- if (!bAtExitFnCalled) {
|
|
|
- // to do gl releases, we need to have the context be current
|
|
|
- if ((_hdc!=NULL)&&(_context!=NULL)) {
|
|
|
- // need to bypass make_current() since it checks _window_active which we need to ignore
|
|
|
- HGLRC current_context = wglGetCurrentContext();
|
|
|
- HDC current_dc = wglGetCurrentDC();
|
|
|
-
|
|
|
- if ((current_context != _context) || (current_dc != _hdc)) {
|
|
|
- if (!wglMakeCurrent(_hdc, _context)) {
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- }
|
|
|
- }
|
|
|
- report_errors();
|
|
|
- }
|
|
|
-
|
|
|
- if (gl_show_fps_meter)
|
|
|
- glDeleteLists(FONT_BITMAP_OGLDISPLAYLISTNUM, 128);
|
|
|
-
|
|
|
- report_errors();
|
|
|
-
|
|
|
- // implicitly calls gsg destructors which release GL objects (textures, display lists, etc)
|
|
|
- release_gsg();
|
|
|
-
|
|
|
- report_errors();
|
|
|
- // cant report errors after we set cur context to NULL
|
|
|
-
|
|
|
- HGLRC curcxt=wglGetCurrentContext();
|
|
|
- if (curcxt!=NULL)
|
|
|
- unmake_current();
|
|
|
-
|
|
|
- if (_context!=NULL) {
|
|
|
- wglDeleteContext(_context);
|
|
|
- _context = NULL;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (_hdc!=NULL) {
|
|
|
- ReleaseDC(_mwindow,_hdc);
|
|
|
- _hdc = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if ((_hOldForegroundWindow!=NULL) && (_mwindow==GetForegroundWindow())) {
|
|
|
- SetForegroundWindow(_hOldForegroundWindow);
|
|
|
- }
|
|
|
-
|
|
|
- if (_mwindow!=NULL) {
|
|
|
- if (_bLoadedCustomCursor && _hMouseCursor!=NULL)
|
|
|
- DestroyCursor(_hMouseCursor);
|
|
|
-
|
|
|
- DestroyWindow(_mwindow);
|
|
|
- hwnd_pandawin_map.erase(_mwindow);
|
|
|
- _mwindow = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if (_pCurrent_display_settings!=NULL) {
|
|
|
- delete _pCurrent_display_settings;
|
|
|
- _pCurrent_display_settings = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- if (_props._fullscreen) {
|
|
|
- // revert to default display mode
|
|
|
- ChangeDisplaySettings(NULL,0x0);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void wglGraphicsWindow::do_close_window() {
|
|
|
- GraphicsWindow::do_close_window();
|
|
|
- DestroyMe(false);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Destructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wglGraphicsWindow::~wglGraphicsWindow() {
|
|
|
- close_window();
|
|
|
-}
|
|
|
-
|
|
|
-void DestroyAllWindows(bool bAtExitFnCalled) {
|
|
|
- // need to go through all windows in map var and delete them
|
|
|
- while(!hwnd_pandawin_map.empty()) {
|
|
|
- // cant use a for loop cause DestroyMe erases things out from under us, so iterator is invalid
|
|
|
- HWND_PANDAWIN_MAP::iterator pwin = hwnd_pandawin_map.begin();
|
|
|
- if ((*pwin).second != NULL)
|
|
|
- (*pwin).second->DestroyMe(bAtExitFnCalled);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void AtExitFn() {
|
|
|
-#ifdef _DEBUG
|
|
|
- wgldisplay_cat.spam() << "AtExitFn called\n";
|
|
|
-#endif
|
|
|
-
|
|
|
- restore_global_parameters();
|
|
|
-
|
|
|
- DestroyAllWindows(true);
|
|
|
-}
|
|
|
-
|
|
|
-// spare me the trouble of linking with dxguid.lib or defining ALL the dx guids in this .obj by #defining INITGUID
|
|
|
-#define MY_DEFINE_GUID(name, l, w1, w2, b1, b2, b3, b4, b5, b6, b7, b8) \
|
|
|
- EXTERN_C const GUID DECLSPEC_SELECTANY name \
|
|
|
- = { l, w1, w2, { b1, b2, b3, b4, b5, b6, b7, b8 } }
|
|
|
-
|
|
|
-MY_DEFINE_GUID(IID_IDirectDraw2, 0xB3A6F3E0,0x2B43,0x11CF,0xA2,0xDE,0x00,0xAA,0x00,0xB9,0x33,0x56);
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: GetAvailVidMem
|
|
|
-// Description: Uses DDraw to get available video memory
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-static DWORD GetAvailVidMem() {
|
|
|
-
|
|
|
- LPDIRECTDRAW2 pDD2;
|
|
|
- LPDIRECTDRAW pDD;
|
|
|
- HRESULT hr;
|
|
|
-
|
|
|
- typedef HRESULT (WINAPI *DIRECTDRAWCREATEPROC)(GUID FAR *lpGUID,LPDIRECTDRAW FAR *lplpDD,IUnknown FAR *pUnkOuter);
|
|
|
- DIRECTDRAWCREATEPROC pfnDDCreate=NULL;
|
|
|
-
|
|
|
- HINSTANCE DDHinst = LoadLibrary("ddraw.dll");
|
|
|
- if (DDHinst == 0) {
|
|
|
- wgldisplay_cat.fatal() << "LoadLibrary() can't find DDRAW.DLL!" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- pfnDDCreate = (DIRECTDRAWCREATEPROC) GetProcAddress(DDHinst, "DirectDrawCreate");
|
|
|
-
|
|
|
- // just use DX5 DD interface, since that's the minimum ver we need
|
|
|
- if (NULL == pfnDDCreate) {
|
|
|
- wgldisplay_cat.fatal() << "GetProcAddress failed on DirectDrawCreate\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // Create the Direct Draw Object
|
|
|
- hr = (*pfnDDCreate)((GUID *)DDCREATE_HARDWAREONLY, &pDD, NULL);
|
|
|
- if (hr != DD_OK) {
|
|
|
- wgldisplay_cat.fatal()
|
|
|
- << "DirectDrawCreate failed : result = " << ConvDDErrorToString(hr) << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- FreeLibrary(DDHinst); //undo LoadLib above, decrement ddrawl.dll refcnt (after DDrawCreate, since dont want to unload/reload)
|
|
|
-
|
|
|
- // need DDraw2 interface for GetAvailVidMem
|
|
|
- hr = pDD->QueryInterface(IID_IDirectDraw2, (LPVOID *)&pDD2);
|
|
|
- if (hr != DD_OK) {
|
|
|
- wgldisplay_cat.fatal() << "DDraw QueryInterface failed : result = " << ConvDDErrorToString(hr) << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- pDD->Release();
|
|
|
-
|
|
|
- // Now we try to figure out if we can use requested screen resolution and best
|
|
|
- // rendertarget bpp and still have at least 2 meg of texture vidmem
|
|
|
-
|
|
|
- // Get Current VidMem avail. Note this is only an estimate, when we switch to fullscreen
|
|
|
- // mode from desktop, more vidmem will be available (typically 1.2 meg). I dont want
|
|
|
- // to switch to fullscreen more than once due to the annoying monitor flicker, so try
|
|
|
- // to figure out optimal mode using this estimate
|
|
|
- DDSCAPS ddsCaps;
|
|
|
- DWORD dwTotal,dwFree;
|
|
|
- ZeroMemory(&ddsCaps,sizeof(DDSCAPS));
|
|
|
- ddsCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM; // dont count AGP mem!
|
|
|
- if (FAILED(hr = pDD2->GetAvailableVidMem(&ddsCaps,&dwTotal,&dwFree))) {
|
|
|
- if (hr==DDERR_NODIRECTDRAWHW) {
|
|
|
- if (wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "GetAvailableVidMem returns no-DDraw HW, assuming we have plenty of vidmem\n";
|
|
|
- dwTotal=dwFree=0x7FFFFFFF;
|
|
|
- } else {
|
|
|
- wgldisplay_cat.fatal() << "GetAvailableVidMem failed : result = " << ConvDDErrorToString(hr) << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- } else {
|
|
|
- if (wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "before FullScreen switch: GetAvailableVidMem returns Total: " << dwTotal/1000000.0 << " Free: " << dwFree/1000000.0 << endl;
|
|
|
- if (dwTotal==0) {
|
|
|
- if (wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "GetAvailVidMem returns bogus total of 0, assuming we have plenty of vidmem\n";
|
|
|
- dwTotal=dwFree=0x7FFFFFFF;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- pDD2->Release(); // bye-bye ddraw
|
|
|
-
|
|
|
- return dwFree;
|
|
|
-}
|
|
|
-
|
|
|
-bool find_acceptable_display_mode(DWORD dwWidth,DWORD dwHeight,DWORD bpp,DEVMODE &dm) {
|
|
|
- int modenum=0;
|
|
|
-
|
|
|
- // look for acceptable mode
|
|
|
- while(1) {
|
|
|
- ZeroMemory(&dm, sizeof(dm));
|
|
|
- dm.dmSize = sizeof(dm);
|
|
|
-
|
|
|
- if (!EnumDisplaySettings(NULL,modenum,&dm))
|
|
|
- break;
|
|
|
-
|
|
|
- if ((dm.dmPelsWidth==dwWidth) && (dm.dmPelsHeight==dwHeight) &&
|
|
|
- (dm.dmBitsPerPel==bpp) && ACCEPTABLE_REFRESH_RATE(dm.dmDisplayFrequency)) {
|
|
|
- return true;
|
|
|
- }
|
|
|
- modenum++;
|
|
|
- }
|
|
|
-
|
|
|
- return false;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: config
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::config() {
|
|
|
-
|
|
|
- GraphicsWindow::config();
|
|
|
-
|
|
|
- HINSTANCE hinstance = GetModuleHandle(NULL);
|
|
|
- HWND hDesktopWindow = GetDesktopWindow();
|
|
|
-
|
|
|
- global_wglwinptr = this; // need this until we get an HWND from CreateWindow
|
|
|
-
|
|
|
- _exiting_window = false;
|
|
|
- _return_control_to_app = false;
|
|
|
- _bIsLowVidMemCard = false;
|
|
|
- _active_minimized_fullscreen = false;
|
|
|
- _PandaPausedTimer = NULL;
|
|
|
- _context = NULL;
|
|
|
- _hdc = NULL;
|
|
|
- _window_active = true;
|
|
|
- _pCurrent_display_settings = NULL;
|
|
|
- _mwindow = NULL;
|
|
|
- _gsg = NULL;
|
|
|
- ZeroMemory(&_pixelformat,sizeof(_pixelformat));
|
|
|
- _hOldForegroundWindow=GetForegroundWindow();
|
|
|
-
|
|
|
- WNDCLASS wc;
|
|
|
-
|
|
|
- // these fns arent defined on win95, so get dynamic ptrs to them to avoid
|
|
|
- // ugly DLL loader failures on w95
|
|
|
- HINSTANCE hUser32 = (HINSTANCE) LoadLibrary("user32.dll");
|
|
|
- assert(hUser32);
|
|
|
- _pfnTrackMouseEvent = (PFN_TRACKMOUSEEVENT) GetProcAddress(hUser32, "TrackMouseEvent");
|
|
|
- FreeLibrary(hUser32);
|
|
|
-
|
|
|
- // Clear before filling in window structure!
|
|
|
- ZeroMemory(&wc, sizeof(WNDCLASS));
|
|
|
- wc.style = CS_HREDRAW | CS_VREDRAW | CS_OWNDC;
|
|
|
- wc.lpfnWndProc = (WNDPROC) static_window_proc;
|
|
|
- wc.hInstance = hinstance;
|
|
|
-
|
|
|
- string windows_icon_filename = get_icon_filename_2().to_os_specific();
|
|
|
- string windows_mono_cursor_filename = get_mono_cursor_filename_2().to_os_specific();
|
|
|
-
|
|
|
- if (!windows_icon_filename.empty()) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp
|
|
|
-
|
|
|
- // loads a .ico fmt file
|
|
|
- wc.hIcon = (HICON) LoadImage(NULL, windows_icon_filename.c_str(), IMAGE_ICON, 0, 0, LR_LOADFROMFILE);
|
|
|
-
|
|
|
- if (wc.hIcon==NULL) {
|
|
|
- wgldisplay_cat.warning() << "windows icon filename '" << windows_icon_filename << "' not found!!\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- wc.hIcon = NULL; // use default app icon
|
|
|
- }
|
|
|
-
|
|
|
- _bLoadedCustomCursor = false;
|
|
|
- if (!windows_mono_cursor_filename.empty()) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp (because it was 'mapping' 16bpp colors to the device?)
|
|
|
-
|
|
|
- DWORD load_flags = LR_LOADFROMFILE;
|
|
|
-
|
|
|
- if (_props._fullscreen) {
|
|
|
- // I think cursors should use LR_CREATEDIBSECTION since they should not be mapped to the device palette (in the case of 256-color cursors)
|
|
|
- // since they are not going to be used on the desktop
|
|
|
- load_flags |= LR_CREATEDIBSECTION;
|
|
|
- }
|
|
|
-
|
|
|
- // loads a .cur fmt file
|
|
|
- _hMouseCursor = (HCURSOR) LoadImage(NULL, windows_mono_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags);
|
|
|
-
|
|
|
- if (_hMouseCursor==NULL) {
|
|
|
- wgldisplay_cat.warning() << "windows cursor filename '" << windows_mono_cursor_filename << "' not found!!\n";
|
|
|
- }
|
|
|
- _bLoadedCustomCursor = true;
|
|
|
- } else {
|
|
|
- _hMouseCursor = LoadCursor(NULL, IDC_ARROW);
|
|
|
- }
|
|
|
-
|
|
|
- if (!wc_registered) {
|
|
|
- // We only need to register the window class once per session.
|
|
|
-
|
|
|
- wc.hCursor = _hMouseCursor; // even if cursor isnt visible, we need to load it so its visible in client-area window border
|
|
|
- wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH);
|
|
|
- wc.lpszMenuName = NULL;
|
|
|
- wc.lpszClassName = WGL_WINDOWCLASSNAME;
|
|
|
-
|
|
|
- if (!RegisterClass(&wc)) {
|
|
|
- wgldisplay_cat.error() << "could not register window class!" << endl;
|
|
|
- }
|
|
|
- wc_registered = true;
|
|
|
- }
|
|
|
-
|
|
|
-// from MSDN:
|
|
|
-// An OpenGL window has its own pixel format. Because of this, only device contexts retrieved
|
|
|
-// for the client area of an OpenGL window are allowed to draw into the window. As a result, an
|
|
|
-// OpenGL window should be created with the WS_CLIPCHILDREN and WS_CLIPSIBLINGS styles. Additionally,
|
|
|
-// the window class attribute should not include the CS_PARENTDC style.
|
|
|
-
|
|
|
- DWORD window_style = WS_POPUP | WS_SYSMENU | WS_CLIPCHILDREN | WS_CLIPSIBLINGS; // for CreateWindow
|
|
|
-
|
|
|
- // rect now contains the coords for the entire window, not the client
|
|
|
- if (_props._fullscreen) {
|
|
|
- DWORD dwWidth = _props._xsize;
|
|
|
- DWORD dwHeight = _props._ysize;
|
|
|
-
|
|
|
- HDC scrnDC=GetDC(hDesktopWindow);
|
|
|
- DWORD drvr_ver=GetDeviceCaps(scrnDC,DRIVERVERSION);
|
|
|
- DWORD cur_bitdepth=GetDeviceCaps(scrnDC,BITSPIXEL);
|
|
|
- DWORD cur_scrnwidth=GetDeviceCaps(scrnDC,HORZRES);
|
|
|
- DWORD cur_scrnheight=GetDeviceCaps(scrnDC,VERTRES);
|
|
|
- ReleaseDC(hDesktopWindow,scrnDC);
|
|
|
-
|
|
|
- DWORD dwFullScreenBitDepth=cur_bitdepth;
|
|
|
-
|
|
|
- #define LOWVIDMEMTHRESHOLD 3500000
|
|
|
- if (gl_do_vidmemsize_check && (GetAvailVidMem() < LOWVIDMEMTHRESHOLD)) {
|
|
|
- _bIsLowVidMemCard = true;
|
|
|
- wgldisplay_cat.debug() << "small video memory card detect, switching fullscreen to minimum 640x480x16 config\n";
|
|
|
- // we're going to need 640x480 at 16 bit to save enough tex vidmem
|
|
|
- dwFullScreenBitDepth=16;
|
|
|
- dwWidth=640;
|
|
|
- dwHeight=480;
|
|
|
- }
|
|
|
-
|
|
|
- DEVMODE dm;
|
|
|
- if (!find_acceptable_display_mode(dwWidth,dwHeight,dwFullScreenBitDepth,dm)) {
|
|
|
- wgldisplay_cat.fatal() << "Videocard has no supported display resolutions at specified res (" << dwWidth << " X " << dwHeight << " X " << dwFullScreenBitDepth <<")\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // I'd prefer to CreateWindow after DisplayChange in case it messes up GL somehow,
|
|
|
- // but I need the window's black background to cover up the desktop during the mode change
|
|
|
- _mwindow = CreateWindow(WGL_WINDOWCLASSNAME, _props._title.c_str(),
|
|
|
- window_style,0,0,dwWidth,dwHeight,hDesktopWindow, NULL, hinstance, 0);
|
|
|
-
|
|
|
- // move window to top of zorder,
|
|
|
- SetWindowPos(_mwindow, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE);
|
|
|
-
|
|
|
- ShowWindow(_mwindow, SW_SHOWNORMAL);
|
|
|
- ShowWindow(_mwindow, SW_SHOWNORMAL);
|
|
|
-
|
|
|
- if(!SetForegroundWindow(_mwindow)) {
|
|
|
- wgldisplay_cat.warning() << "SetForegroundWindow() failed!\n";
|
|
|
- }
|
|
|
-
|
|
|
- int chg_result = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
|
|
|
-
|
|
|
- if (chg_result!=DISP_CHANGE_SUCCESSFUL) {
|
|
|
- wgldisplay_cat.fatal() << "ChangeDisplaySettings failed (error code: " << chg_result <<") for specified res (" << dwWidth << " X " << dwHeight << " X " << dwFullScreenBitDepth <<"), " << dm.dmDisplayFrequency << "Hz\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- _pCurrent_display_settings = new(DEVMODE);
|
|
|
- memcpy(_pCurrent_display_settings,&dm,sizeof(DEVMODE));
|
|
|
-
|
|
|
- _props._xorg = 0;
|
|
|
- _props._yorg = 0;
|
|
|
- _props._xsize = dwWidth;
|
|
|
- _props._ysize = dwHeight;
|
|
|
- } else {
|
|
|
-
|
|
|
- RECT win_rect;
|
|
|
- SetRect(&win_rect, _props._xorg, _props._yorg, _props._xorg + _props._xsize,
|
|
|
- _props._yorg + _props._ysize);
|
|
|
-
|
|
|
- if (_props._border) {
|
|
|
- window_style |= WS_OVERLAPPEDWINDOW;
|
|
|
- }
|
|
|
-
|
|
|
- BOOL bRes = AdjustWindowRect(&win_rect, window_style, FALSE); //compute window size based on desired client area size
|
|
|
-
|
|
|
- if (!bRes) {
|
|
|
- wgldisplay_cat.fatal() << "AdjustWindowRect failed!" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // make sure origin is on screen, slide far bounds over if necessary
|
|
|
- if (win_rect.left < 0) {
|
|
|
- win_rect.right += abs(win_rect.left); win_rect.left = 0;
|
|
|
- }
|
|
|
- if (win_rect.top < 0) {
|
|
|
- win_rect.bottom += abs(win_rect.top); win_rect.top = 0;
|
|
|
- }
|
|
|
-
|
|
|
- _mwindow = CreateWindow(WGL_WINDOWCLASSNAME, _props._title.c_str(),
|
|
|
- window_style, win_rect.left, win_rect.top, win_rect.right-win_rect.left,
|
|
|
- win_rect.bottom-win_rect.top,
|
|
|
- NULL, NULL, hinstance, 0);
|
|
|
-
|
|
|
- SetForegroundWindow(_mwindow);
|
|
|
- }
|
|
|
-
|
|
|
- wgldisplay_cat.info() << "opening " << _props._xsize << "x" << _props._ysize
|
|
|
- << (_props._fullscreen ? " fullscreen" : " regular") << " window\n";
|
|
|
-
|
|
|
- if (!_mwindow) {
|
|
|
- wgldisplay_cat.fatal() << "CreateWindow() failed!" << endl;
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // Determine the initial open status of the IME.
|
|
|
- _ime_open = false;
|
|
|
- _ime_active = false;
|
|
|
- HIMC hIMC = ImmGetContext(_mwindow);
|
|
|
- if (hIMC != 0) {
|
|
|
- _ime_open = (ImmGetOpenStatus(hIMC) != 0);
|
|
|
- ImmReleaseContext(_mwindow, hIMC);
|
|
|
- }
|
|
|
-
|
|
|
- // Check the version of the OS we are running. If we are running
|
|
|
- // win2000, we must use ImmGetCompositionStringW() to report the
|
|
|
- // characters returned by the IME, since WM_CHAR and
|
|
|
- // ImmGetCompositionStringA() both just return question marks.
|
|
|
- // However, this function doesn't work for Win98; on this OS, we
|
|
|
- // have to use ImmGetCompositionStringA() instead, which returns an
|
|
|
- // encoded string in shift-jis (which we then have to decode).
|
|
|
-
|
|
|
- // For now, this is user-configurable, to allow testing of this code
|
|
|
- // on both OS's. After we verify that truth of the above claim, we
|
|
|
- // should base this decision on GetVersionEx() or maybe
|
|
|
- // VerifyVersionInfo().
|
|
|
- _ime_composition_w = ime_composition_w;
|
|
|
-
|
|
|
- hwnd_pandawin_map[_mwindow] = this;
|
|
|
- global_wglwinptr = NULL; // get rid of any reference to this obj
|
|
|
-
|
|
|
- // move window to top of zorder
|
|
|
- SetWindowPos(_mwindow, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER);
|
|
|
-
|
|
|
- _hdc = GetDC(_mwindow);
|
|
|
-
|
|
|
- // Configure the framebuffer according to parameters specified in _props
|
|
|
- // Initializes _pixelformat
|
|
|
- int pfnum=choose_visual();
|
|
|
-
|
|
|
- if (gl_forced_pixfmt!=0) {
|
|
|
- if (wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "overriding pixfmt choice algorithm (" << pfnum << ") with gl-force-pixfmt("<<gl_forced_pixfmt<< ")\n";
|
|
|
- pfnum=gl_forced_pixfmt;
|
|
|
- }
|
|
|
-
|
|
|
- // int pfnum=ChoosePixelFormat(_hdc, _pixelformat);
|
|
|
- if (wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "config() - picking pixfmt #"<< pfnum <<endl;
|
|
|
-
|
|
|
- if (!SetPixelFormat(_hdc, pfnum, &_pixelformat)) {
|
|
|
- wgldisplay_cat.fatal()
|
|
|
- << "config() - SetPixelFormat("<< pfnum << ") failed after window create" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // Initializes _colormap
|
|
|
- setup_colormap();
|
|
|
-
|
|
|
- _context = wglCreateContext(_hdc);
|
|
|
- if (!_context) {
|
|
|
- wgldisplay_cat.fatal()
|
|
|
- << "config() - failed to create Win32 rendering context" << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // need to do twice to override any minimized flags in StartProcessInfo
|
|
|
- ShowWindow(_mwindow, SW_SHOWNORMAL);
|
|
|
- ShowWindow(_mwindow, SW_SHOWNORMAL);
|
|
|
-
|
|
|
- // Now indicate that we have our keyboard/mouse device ready.
|
|
|
- GraphicsWindowInputDevice device =
|
|
|
- GraphicsWindowInputDevice::pointer_and_keyboard("keyboard/mouse");
|
|
|
- _input_devices.push_back(device);
|
|
|
-
|
|
|
- // Create a GSG to manage the graphics
|
|
|
- // First make the new context and window the current one so GL knows how
|
|
|
- // to configure itself in the gsg
|
|
|
- make_current();
|
|
|
- make_gsg();
|
|
|
-
|
|
|
- check_for_color_cursor_support();
|
|
|
-
|
|
|
-// _glgsg = DCAST(GLGraphicsStateGuardian, _gsg); dont need this now
|
|
|
-
|
|
|
- string tmpstr((char*)glGetString(GL_EXTENSIONS));
|
|
|
-
|
|
|
- _extensions_str = tmpstr;
|
|
|
-
|
|
|
- PFNWGLGETEXTENSIONSSTRINGEXTPROC wglGetExtensionsStringEXT = NULL;
|
|
|
- PFNWGLGETEXTENSIONSSTRINGARBPROC wglGetExtensionsStringARB = NULL;
|
|
|
-
|
|
|
- if (!support_wiregl) {
|
|
|
- wglGetExtensionsStringARB = (PFNWGLGETEXTENSIONSSTRINGARBPROC)wglGetProcAddress("wglGetExtensionsStringARB");
|
|
|
- wglGetExtensionsStringEXT = (PFNWGLGETEXTENSIONSSTRINGEXTPROC)wglGetProcAddress("wglGetExtensionsStringEXT");
|
|
|
- }
|
|
|
-
|
|
|
- if (wglGetExtensionsStringARB!=NULL) {
|
|
|
- _extensions_str += " ";
|
|
|
- const char *ARBextensions = wglGetExtensionsStringARB(wglGetCurrentDC());
|
|
|
- _extensions_str.append(ARBextensions);
|
|
|
- }
|
|
|
-
|
|
|
- if (wglGetExtensionsStringEXT!=NULL) {
|
|
|
- // usually this will be the same as ARB extensions, but whatever
|
|
|
- _extensions_str += " ";
|
|
|
- const char *EXTextensions = wglGetExtensionsStringEXT();
|
|
|
- _extensions_str.append(EXTextensions);
|
|
|
- }
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "GL extensions: " << _extensions_str << endl;
|
|
|
-
|
|
|
- if(gl_swapbuffer_framelock) {
|
|
|
- // utilize HW-assisted framelocking if available (3dLabs ext)
|
|
|
- WGLENABLEFRAMELOCKI3DFUNCPTR wglEnableFrameLock = (WGLENABLEFRAMELOCKI3DFUNCPTR) wglGetProcAddress("wglEnableFrameLockI3D");
|
|
|
-
|
|
|
- if(wglEnableFrameLock==NULL) {
|
|
|
- wgldisplay_cat.fatal() << "wglEnableFrameLockI3D not found in OpenGL ICD, cannot implement gl-swapbuffer-framelock!\n";
|
|
|
- exit(1);
|
|
|
- } else {
|
|
|
- BOOL result = wglEnableFrameLock();
|
|
|
- if(!result) {
|
|
|
- wgldisplay_cat.fatal() << "wglEnableFrameLockI3D failed, error=" << GetLastError() << endl;
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(wgldisplay_cat.is_debug()) {
|
|
|
- WGLQUERYFRAMELOCKMASTERI3DFUNCPTR wglQueryFrameLockMasterI3D = (WGLQUERYFRAMELOCKMASTERI3DFUNCPTR) wglGetProcAddress("wglQueryFrameLockMasterI3D");
|
|
|
- BOOL bIsMaster;
|
|
|
- if((wglQueryFrameLockMasterI3D!=NULL) && wglQueryFrameLockMasterI3D(&bIsMaster))
|
|
|
- wgldisplay_cat.debug() << "SwapBuffer Frame-locking Enabled, HW wired as framelock " << (bIsMaster ? "Master" : "Slave") << endl;
|
|
|
- }
|
|
|
-
|
|
|
- gl_sync_video=true; // you want gl_sync_video if you want framelock, right?
|
|
|
- }
|
|
|
-
|
|
|
- if (gl_sync_video) {
|
|
|
- // set swapbuffers to swap no more than once per monitor refresh
|
|
|
- // note sometimes the ICD advertises this ext, but it still doesn't seem to work
|
|
|
- if (_extensions_str.find("WGL_EXT_swap_control")!=_extensions_str.npos) {
|
|
|
- PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT;
|
|
|
- wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC) wglGetProcAddress("wglSwapIntervalEXT");
|
|
|
- if (wglSwapIntervalEXT!=NULL)
|
|
|
- wglSwapIntervalEXT(1);
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "setting swapbuffer interval to 1/refresh\n";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- gl_supports_bgr = (_extensions_str.find("GL_EXT_bgra")!=_extensions_str.npos);
|
|
|
-
|
|
|
- // hard to imagine a windows-based driver that doesnt support this ordering
|
|
|
- if(!gl_supports_bgr)
|
|
|
- wgldisplay_cat.info() << "Note GL_EXT_bgra not supported, textures must be swizzled!\n";
|
|
|
-
|
|
|
- if (gl_show_fps_meter) {
|
|
|
-
|
|
|
- _start_time = timeGetTime();
|
|
|
- _current_fps = 0.0;
|
|
|
- _start_frame_count = _cur_frame_count = 0;
|
|
|
-
|
|
|
- // 128 enough to handle all the ascii chars
|
|
|
- // this creates a display list for each char. displist numbering starts
|
|
|
- // at FONT_BITMAP_OGLDISPLAYLISTNUM. Might want to optimize just to save
|
|
|
- // mem by just allocing bitmaps for chars we need (0-9 fps,SPC)
|
|
|
- wglUseFontBitmaps(_hdc, 0, 128, FONT_BITMAP_OGLDISPLAYLISTNUM);
|
|
|
- }
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_info()) {
|
|
|
- const char *vendStr=(const char *) glGetString(GL_VENDOR);
|
|
|
- const char *rendStr=(const char *) glGetString(GL_RENDERER);
|
|
|
- const char *versStr=(const char *) glGetString(GL_VERSION);
|
|
|
-
|
|
|
- // Note: glGetString will never return a valid value until you do wglMakeCurrent
|
|
|
-
|
|
|
- if (vendStr!=NULL) {
|
|
|
- wgldisplay_cat.info()
|
|
|
- << "GL_VENDOR: " << vendStr
|
|
|
- << " GL_RENDERER: " << ((rendStr==NULL) ? "" : rendStr)
|
|
|
- << " GL_VERSION: " << ((versStr==NULL) ? "" : versStr) << endl;
|
|
|
- } else {
|
|
|
- wgldisplay_cat.info() << "glGetString(GL_VENDOR) returns NULL!\n";
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void wglGraphicsWindow::
|
|
|
-check_for_color_cursor_support() {
|
|
|
- // card support for non-black/white GDI cursors varies greatly. if the cursor is not supported,
|
|
|
- // it is rendered in software by GDI, which causes a flickering effect (because it's not synced
|
|
|
- // with flip?). GDI transparently masks what's happening so there is no easy way for app to detect
|
|
|
- // if HW cursor support exists. alternatives are to tie cursor motion to frame rate using DDraw blts
|
|
|
- // or overlays, or to have separate thread draw cursor (sync issues?). instead we do mono cursor
|
|
|
- // unless card is known to support 256 color cursors
|
|
|
-
|
|
|
- string windows_color_cursor_filename = get_color_cursor_filename_2().to_os_specific();
|
|
|
- if (windows_color_cursor_filename.empty())
|
|
|
- return;
|
|
|
-
|
|
|
- bool bSupportsColorCursor=false;
|
|
|
- const GLubyte *vendorname=glGetString(GL_VENDOR);
|
|
|
- if (vendorname==NULL) {
|
|
|
- return;
|
|
|
- }
|
|
|
- char vendorstr[500];
|
|
|
- strncpy(vendorstr,(const char *)vendorname,sizeof(vendorstr));
|
|
|
- _strlwr(vendorstr);
|
|
|
- if (strstr(vendorstr,"nvidia")!=NULL)
|
|
|
- bSupportsColorCursor=true;
|
|
|
-
|
|
|
- // for now, just assume only nvidia supports color. need to add more checks for other cards
|
|
|
- // like in DX l8r.
|
|
|
-
|
|
|
- if (bSupportsColorCursor) {
|
|
|
- // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings)
|
|
|
- // if icon is more than 8bpp (because it was 'mapping' 16bpp colors to the device?)
|
|
|
-
|
|
|
- DWORD load_flags = LR_LOADFROMFILE;
|
|
|
-
|
|
|
- if (_props._fullscreen) {
|
|
|
- // I think cursors should use LR_CREATEDIBSECTION since they should not be mapped to the device palette (in the case of 256-color cursors)
|
|
|
- // since they are not going to be used on the desktop
|
|
|
- load_flags |= LR_CREATEDIBSECTION;
|
|
|
-
|
|
|
- // note: this is still doing weird stuff when it loads 8bpp colors, even with LR_CREATEDIBSECTION
|
|
|
- // there is still a bug here BUGBUG
|
|
|
- }
|
|
|
-
|
|
|
- // loads a .cur fmt file
|
|
|
- HCURSOR hNewMouseCursor = (HCURSOR) LoadImage(NULL, windows_color_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags);
|
|
|
-
|
|
|
- if (hNewMouseCursor==NULL) {
|
|
|
- wgldisplay_cat.warning() << "windows color cursor filename '" << windows_color_cursor_filename << "' not found!!\n";
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- SetClassLongPtr(_mwindow, GCLP_HCURSOR, (LONG_PTR) hNewMouseCursor);
|
|
|
- SetCursor(hNewMouseCursor);
|
|
|
-
|
|
|
- if (_bLoadedCustomCursor)
|
|
|
- DestroyCursor(_hMouseCursor);
|
|
|
- _hMouseCursor = hNewMouseCursor;
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "loaded color cursor\n";
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Constructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wglGraphicsWindow::
|
|
|
-wglGraphicsWindow(GraphicsPipe* pipe) : GraphicsWindow(pipe) {
|
|
|
- config();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: Constructor
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-wglGraphicsWindow::
|
|
|
-wglGraphicsWindow(GraphicsPipe* pipe, const
|
|
|
- GraphicsWindow::Properties& props) : GraphicsWindow(pipe, props) {
|
|
|
- config();
|
|
|
-}
|
|
|
-
|
|
|
-#ifdef _DEBUG
|
|
|
-void PrintPFD(PIXELFORMATDESCRIPTOR *pfd,char *msg) {
|
|
|
-
|
|
|
- OGLDriverType drvtype;
|
|
|
- if ((pfd->dwFlags & PFD_GENERIC_ACCELERATED) && (pfd->dwFlags & PFD_GENERIC_FORMAT))
|
|
|
- drvtype=MCD;
|
|
|
- else if (!(pfd->dwFlags & PFD_GENERIC_ACCELERATED) && !(pfd->dwFlags & PFD_GENERIC_FORMAT))
|
|
|
- drvtype=ICD;
|
|
|
- else {
|
|
|
- drvtype=Software;
|
|
|
- }
|
|
|
-
|
|
|
-#define PrintFlag(FLG) ((pfd->dwFlags & PFD_##FLG) ? (" PFD_" #FLG "|") : "")
|
|
|
- wgldisplay_cat.spam() << "================================\n";
|
|
|
-
|
|
|
- wgldisplay_cat.spam() << msg << ", " << OGLDrvStrings[drvtype] << " driver\n"
|
|
|
- << "PFD flags: 0x" << (void*)pfd->dwFlags << " (" <<
|
|
|
- PrintFlag(GENERIC_ACCELERATED) <<
|
|
|
- PrintFlag(GENERIC_FORMAT) <<
|
|
|
- PrintFlag(DOUBLEBUFFER) <<
|
|
|
- PrintFlag(SUPPORT_OPENGL) <<
|
|
|
- PrintFlag(SUPPORT_GDI) <<
|
|
|
- PrintFlag(STEREO) <<
|
|
|
- PrintFlag(DRAW_TO_WINDOW) <<
|
|
|
- PrintFlag(DRAW_TO_BITMAP) <<
|
|
|
- PrintFlag(SWAP_EXCHANGE) <<
|
|
|
- PrintFlag(SWAP_COPY) <<
|
|
|
- PrintFlag(SWAP_LAYER_BUFFERS) <<
|
|
|
- PrintFlag(NEED_PALETTE) <<
|
|
|
- PrintFlag(NEED_SYSTEM_PALETTE) <<
|
|
|
- PrintFlag(SUPPORT_DIRECTDRAW) << ")\n"
|
|
|
- << "PFD iPixelType: " << ((pfd->iPixelType==PFD_TYPE_RGBA) ? "PFD_TYPE_RGBA":"PFD_TYPE_COLORINDEX") << endl
|
|
|
- << "PFD cColorBits: " << (DWORD)pfd->cColorBits << " R: " << (DWORD)pfd->cRedBits <<" G: " << (DWORD)pfd->cGreenBits <<" B: " << (DWORD)pfd->cBlueBits << endl
|
|
|
- << "PFD cAlphaBits: " << (DWORD)pfd->cAlphaBits << " DepthBits: " << (DWORD)pfd->cDepthBits <<" StencilBits: " << (DWORD)pfd->cStencilBits <<" AccumBits: " << (DWORD)pfd->cAccumBits << endl;
|
|
|
-}
|
|
|
-#endif
|
|
|
-
|
|
|
-// this helper routine looks for either HW-only or SW-only format, but not both
|
|
|
-// returns number of pixelformat
|
|
|
-int wglGraphicsWindow::find_pixfmtnum(bool bLookforHW) {
|
|
|
- int mask = _props._mask;
|
|
|
- int want_depth_bits = _props._want_depth_bits;
|
|
|
- int want_color_bits = _props._want_color_bits;
|
|
|
- OGLDriverType drvtype;
|
|
|
-
|
|
|
- if (mask & W_MULTISAMPLE) {
|
|
|
- wgldisplay_cat.error() << "config() - multisample not supported"<< endl;
|
|
|
- mask &= ~W_MULTISAMPLE;
|
|
|
- }
|
|
|
-
|
|
|
- if(wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "mask =0x" << (void*) mask << endl;
|
|
|
-
|
|
|
- PIXELFORMATDESCRIPTOR pfd;
|
|
|
- ZeroMemory(&pfd,sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
- pfd.nSize=sizeof(PIXELFORMATDESCRIPTOR);
|
|
|
- pfd.nVersion=1;
|
|
|
-
|
|
|
- // if (_props._fullscreen) {
|
|
|
- // do anything different for fullscrn?
|
|
|
-
|
|
|
- // just use the pixfmt of the current desktop
|
|
|
-
|
|
|
- int MaxPixFmtNum=DescribePixelFormat(_hdc, 1, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
|
|
|
- int cur_bpp=GetDeviceCaps(_hdc,BITSPIXEL);
|
|
|
- int pfnum;
|
|
|
-
|
|
|
- for(pfnum=1;pfnum<=MaxPixFmtNum;pfnum++) {
|
|
|
- DescribePixelFormat(_hdc, pfnum, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
|
|
|
-
|
|
|
- // official, nvidia sanctioned way. should be equiv to my algorithm
|
|
|
- if ((pfd.dwFlags & PFD_GENERIC_FORMAT) != 0)
|
|
|
- drvtype = Software;
|
|
|
- else if (pfd.dwFlags & PFD_GENERIC_ACCELERATED)
|
|
|
- drvtype = MCD;
|
|
|
- else drvtype = ICD;
|
|
|
-
|
|
|
- #if MY_OLD_ALGORITHM
|
|
|
- if ((pfd.dwFlags & PFD_GENERIC_ACCELERATED) && (pfd.dwFlags & PFD_GENERIC_FORMAT))
|
|
|
- drvtype=MCD;
|
|
|
- else if (!(pfd.dwFlags & PFD_GENERIC_ACCELERATED) && !(pfd.dwFlags & PFD_GENERIC_FORMAT))
|
|
|
- drvtype=ICD;
|
|
|
- else {
|
|
|
- drvtype=Software;
|
|
|
- continue; // skipping all SW fmts
|
|
|
- }
|
|
|
- #endif
|
|
|
-
|
|
|
- // skip driver types we are not looking for
|
|
|
- if(bLookforHW) {
|
|
|
- if(drvtype==Software)
|
|
|
- continue;
|
|
|
- } else {
|
|
|
- if(drvtype!=Software)
|
|
|
- continue;
|
|
|
- }
|
|
|
-
|
|
|
- if ((pfd.iPixelType == PFD_TYPE_COLORINDEX) && !(mask & W_INDEX))
|
|
|
- continue;
|
|
|
-
|
|
|
- DWORD dwReqFlags=(PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW);
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_debug()) {
|
|
|
- wgldisplay_cat->debug() << "----------------" << endl;
|
|
|
-
|
|
|
- if (mask & W_ALPHA)
|
|
|
- wgldisplay_cat->debug() << "want alpha, pfd says '"
|
|
|
- << (int)(pfd.cAlphaBits) << "'" << endl;
|
|
|
- if (mask & W_DEPTH)
|
|
|
- wgldisplay_cat->debug() << "want depth, pfd says '"
|
|
|
- << (int)(pfd.cDepthBits) << "'" << endl;
|
|
|
- if (mask & W_STENCIL)
|
|
|
- wgldisplay_cat->debug() << "want stencil, pfd says '"
|
|
|
- << (int)(pfd.cStencilBits) << "'" << endl;
|
|
|
- wgldisplay_cat->debug() << "final flag check "
|
|
|
- << (int)(pfd.dwFlags & dwReqFlags) << " =? "
|
|
|
- << (int)dwReqFlags << endl;
|
|
|
- wgldisplay_cat->debug() << "pfd bits = " << (int)(pfd.cColorBits)
|
|
|
- << endl;
|
|
|
- wgldisplay_cat->debug() << "cur_bpp = " << cur_bpp << endl;
|
|
|
- }
|
|
|
-
|
|
|
- if (mask & W_DOUBLE)
|
|
|
- dwReqFlags|= PFD_DOUBLEBUFFER;
|
|
|
- if ((mask & W_ALPHA) && (pfd.cAlphaBits==0))
|
|
|
- continue;
|
|
|
- if ((mask & W_DEPTH) && (pfd.cDepthBits==0))
|
|
|
- continue;
|
|
|
- if ((mask & W_STENCIL) && (pfd.cStencilBits==0))
|
|
|
- continue;
|
|
|
-
|
|
|
- if ((pfd.dwFlags & dwReqFlags)!=dwReqFlags)
|
|
|
- continue;
|
|
|
-
|
|
|
- // now we ignore the specified want_color_bits for windowed mode
|
|
|
- // instead we use the current screen depth
|
|
|
-
|
|
|
- if ((pfd.cColorBits!=cur_bpp) && (!((cur_bpp==16) && (pfd.cColorBits==15)))
|
|
|
- && (!((cur_bpp==32) && (pfd.cColorBits==24))))
|
|
|
- continue;
|
|
|
- // we've passed all the tests, go ahead and pick this fmt
|
|
|
- // note: could go continue looping looking for more alpha bits or more depth bits
|
|
|
- // so this would pick 16bpp depth buffer, probably not 24bpp
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- if(pfnum>MaxPixFmtNum)
|
|
|
- pfnum=0;
|
|
|
-
|
|
|
- return pfnum;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: choose visual
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-int wglGraphicsWindow::choose_visual(void) {
|
|
|
- int pfnum;
|
|
|
- bool bUsingSoftware=false;
|
|
|
-
|
|
|
- if(wgl_force_sw_renderer) {
|
|
|
- pfnum=find_pixfmtnum(false);
|
|
|
-
|
|
|
- if(pfnum==0) {
|
|
|
- wgldisplay_cat.error() << "ERROR: couldn't find compatible software-renderer OpenGL pixfmt, check your window properties!\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- bUsingSoftware=true;
|
|
|
- } else {
|
|
|
- pfnum=find_pixfmtnum(true);
|
|
|
- if(pfnum==0) {
|
|
|
- if(wgl_allow_sw_renderer) {
|
|
|
- pfnum=find_pixfmtnum(false);
|
|
|
- if(pfnum==0) {
|
|
|
- wgldisplay_cat.error() << "ERROR: couldn't find HW or Software OpenGL pixfmt appropriate for this desktop!!\n";
|
|
|
- }
|
|
|
- } else {
|
|
|
- wgldisplay_cat.error() << "ERROR: couldn't find HW-accelerated OpenGL pixfmt appropriate for this desktop!!\n";
|
|
|
- }
|
|
|
-
|
|
|
- if(pfnum==0) {
|
|
|
- wgldisplay_cat.error()
|
|
|
- << "make sure OpenGL driver is installed, and try reducing the screen size, reducing the\n"
|
|
|
- << "desktop screen pixeldepth to 16bpp,and check your panda window properties\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
- bUsingSoftware=true;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if(wgl_allow_sw_renderer && bUsingSoftware) {
|
|
|
- wgldisplay_cat.info() << "Couldn't find compatible OGL HW pixelformat, using software rendering...\n";
|
|
|
- }
|
|
|
-
|
|
|
- DescribePixelFormat(_hdc, pfnum, sizeof(PIXELFORMATDESCRIPTOR), &_pixelformat);
|
|
|
-
|
|
|
- #ifdef _DEBUG
|
|
|
- char msg[200];
|
|
|
- sprintf(msg,"Selected GL PixelFormat is #%d",pfnum);
|
|
|
- PrintPFD(&_pixelformat,msg);
|
|
|
- #endif
|
|
|
-
|
|
|
- return pfnum;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: setup_colormap
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::setup_colormap() {
|
|
|
-
|
|
|
- PIXELFORMATDESCRIPTOR pfd;
|
|
|
- LOGPALETTE *logical;
|
|
|
- int n;
|
|
|
-
|
|
|
- /* grab the pixel format */
|
|
|
- memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
- DescribePixelFormat(_hdc, GetPixelFormat(_hdc),
|
|
|
- sizeof(PIXELFORMATDESCRIPTOR), &pfd);
|
|
|
-
|
|
|
- if (!(pfd.dwFlags & PFD_NEED_PALETTE ||
|
|
|
- pfd.iPixelType == PFD_TYPE_COLORINDEX))
|
|
|
- return;
|
|
|
-
|
|
|
- n = 1 << pfd.cColorBits;
|
|
|
-
|
|
|
- /* allocate a bunch of memory for the logical palette (assume 256
|
|
|
- colors in a Win32 palette */
|
|
|
- logical = (LOGPALETTE*)malloc(sizeof(LOGPALETTE) +
|
|
|
- sizeof(PALETTEENTRY) * n);
|
|
|
- memset(logical, 0, sizeof(LOGPALETTE) + sizeof(PALETTEENTRY) * n);
|
|
|
-
|
|
|
- /* set the entries in the logical palette */
|
|
|
- logical->palVersion = 0x300;
|
|
|
- logical->palNumEntries = n;
|
|
|
-
|
|
|
- /* start with a copy of the current system palette */
|
|
|
- GetSystemPaletteEntries(_hdc, 0, 256, &logical->palPalEntry[0]);
|
|
|
-
|
|
|
- if (pfd.iPixelType == PFD_TYPE_RGBA) {
|
|
|
- int redMask = (1 << pfd.cRedBits) - 1;
|
|
|
- int greenMask = (1 << pfd.cGreenBits) - 1;
|
|
|
- int blueMask = (1 << pfd.cBlueBits) - 1;
|
|
|
- int i;
|
|
|
-
|
|
|
- /* fill in an RGBA color palette */
|
|
|
- for (i = 0; i < n; ++i) {
|
|
|
- logical->palPalEntry[i].peRed =
|
|
|
- (((i >> pfd.cRedShift) & redMask) * 255) / redMask;
|
|
|
- logical->palPalEntry[i].peGreen =
|
|
|
- (((i >> pfd.cGreenShift) & greenMask) * 255) / greenMask;
|
|
|
- logical->palPalEntry[i].peBlue =
|
|
|
- (((i >> pfd.cBlueShift) & blueMask) * 255) / blueMask;
|
|
|
- logical->palPalEntry[i].peFlags = 0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- _colormap = CreatePalette(logical);
|
|
|
- free(logical);
|
|
|
-
|
|
|
- SelectPalette(_hdc, _colormap, FALSE);
|
|
|
- RealizePalette(_hdc);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: end_frame
|
|
|
-// Access:
|
|
|
-// Description: Swaps the front and back buffers.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::end_frame() {
|
|
|
- if (gl_show_fps_meter) {
|
|
|
- DO_PSTATS_STUFF(PStatTimer timer(_show_fps_pcollector);)
|
|
|
- DWORD now = timeGetTime(); // this is win32 fn
|
|
|
-
|
|
|
- float time_delta = (now - _start_time) * 0.001f;
|
|
|
-
|
|
|
- if (time_delta > gl_fps_meter_update_interval) {
|
|
|
- // didnt use global clock object, it wasnt working properly when
|
|
|
- // I tried, its probably slower due to cache faults, and I can
|
|
|
- // easily track all the info I need in dxgsg
|
|
|
- DWORD num_frames = _cur_frame_count - _start_frame_count;
|
|
|
-
|
|
|
- _current_fps = num_frames / time_delta;
|
|
|
- _start_time = now;
|
|
|
- _start_frame_count = _cur_frame_count;
|
|
|
- }
|
|
|
-
|
|
|
- char fps_msg[15];
|
|
|
- sprintf(fps_msg, "%.02f fps", _current_fps);
|
|
|
-
|
|
|
- // Note: we cant use simple GDI TextOut calls to draw FPS meter
|
|
|
- // chars (like DX fps meter) because WGL doesnt support GDI in
|
|
|
- // double-buffered mode. Instead we have to use glBitMap display
|
|
|
- // lists created by wglUseFontBitmaps
|
|
|
-
|
|
|
- GLfloat saved_color[4];
|
|
|
- glGetFloatv(GL_CURRENT_COLOR,saved_color);
|
|
|
- glColor3f(0.0f,1.0f,1.0f);
|
|
|
-
|
|
|
- GLboolean tex_was_on = glIsEnabled(GL_TEXTURE_2D);
|
|
|
-
|
|
|
- if (tex_was_on)
|
|
|
- glDisable(GL_TEXTURE_2D);
|
|
|
-
|
|
|
- glMatrixMode(GL_MODELVIEW);
|
|
|
- glPushMatrix();
|
|
|
- glLoadIdentity();
|
|
|
- glMatrixMode(GL_PROJECTION);
|
|
|
- glPushMatrix();
|
|
|
- glLoadIdentity();
|
|
|
-
|
|
|
- glOrtho(0.0f,_props._xsize,
|
|
|
- 0.0f,_props._ysize,
|
|
|
- -1.0f,1.0f);
|
|
|
-
|
|
|
- // problem to not restore the rasterPos state?
|
|
|
- glRasterPos2f(_props._xsize-70,_props._ysize-20); // these seem to be good for default font
|
|
|
-
|
|
|
- // set up for a string-drawing display list call
|
|
|
- glListBase(FONT_BITMAP_OGLDISPLAYLISTNUM);
|
|
|
-
|
|
|
- // draw a string using font display lists. chars index their
|
|
|
- // corresponding displist name
|
|
|
- glCallLists(strlen(fps_msg), GL_UNSIGNED_BYTE, fps_msg);
|
|
|
-
|
|
|
- // restore original gl state
|
|
|
- glPopMatrix();
|
|
|
- glMatrixMode(GL_MODELVIEW);
|
|
|
- glPopMatrix();
|
|
|
- glColor4fv(saved_color);
|
|
|
- if (tex_was_on)
|
|
|
- glEnable(GL_TEXTURE_2D);
|
|
|
-
|
|
|
- _cur_frame_count++; // only used by fps meter right now
|
|
|
- }
|
|
|
-
|
|
|
- {
|
|
|
- DO_PSTATS_STUFF(PStatTimer timer(_swap_pcollector);)
|
|
|
- if (_is_synced)
|
|
|
- glFinish();
|
|
|
- else SwapBuffers(_hdc);
|
|
|
- }
|
|
|
- GraphicsWindow::end_frame();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: swap
|
|
|
-// Access:
|
|
|
-// Description: Swaps the front and back buffers explicitly.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::swap() {
|
|
|
- if (_is_synced)
|
|
|
- SwapBuffers(_hdc);
|
|
|
-}
|
|
|
-
|
|
|
-bool wglGraphicsWindow::resize(unsigned int xsize,unsigned int ysize) {
|
|
|
- if (!_props._fullscreen) {
|
|
|
- // resizing windowed mode is easy
|
|
|
- SetWindowPos(_mwindow, NULL, 0,0, xsize,ysize, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSENDCHANGING);
|
|
|
- } else {
|
|
|
- DWORD dwWidth = xsize;
|
|
|
- DWORD dwHeight = ysize;
|
|
|
-
|
|
|
- HWND hDesktopWindow = GetDesktopWindow();
|
|
|
- HDC scrnDC=GetDC(hDesktopWindow);
|
|
|
- DWORD dwFullScreenBitDepth=GetDeviceCaps(scrnDC,BITSPIXEL);
|
|
|
- ReleaseDC(hDesktopWindow,scrnDC);
|
|
|
-
|
|
|
- // resize will always leave screen bitdepth unchanged
|
|
|
-
|
|
|
- // allowing resizing of lowvidmem cards to > 640x480. why? I'll assume
|
|
|
- // check was already done by caller, so he knows what he wants
|
|
|
-
|
|
|
- DEVMODE dm;
|
|
|
- if (!find_acceptable_display_mode(dwWidth,dwHeight,dwFullScreenBitDepth,dm)) {
|
|
|
- wgldisplay_cat.fatal() << "window resize(" << xsize << "," << ysize << ") failed, no compatible fullscreen display mode found!\n";
|
|
|
- return false;
|
|
|
- }
|
|
|
-
|
|
|
- // this causes WM_SIZE msg to be produced
|
|
|
- SetWindowPos(_mwindow, NULL, 0,0, xsize, ysize, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSENDCHANGING);
|
|
|
-
|
|
|
- int chg_result = ChangeDisplaySettings(&dm, CDS_FULLSCREEN);
|
|
|
-
|
|
|
- if (chg_result!=DISP_CHANGE_SUCCESSFUL) {
|
|
|
- wgldisplay_cat.fatal() << "resize ChangeDisplaySettings failed (error code: " << chg_result <<") for specified res (" << dwWidth << " X " << dwHeight << " X " << dwFullScreenBitDepth <<"), " << dm.dmDisplayFrequency << "Hz\n";
|
|
|
- exit(1);
|
|
|
- }
|
|
|
-
|
|
|
- // this assertion could be violated if we eventually allow dynamic fullscrn/windowed mode switching
|
|
|
- assert(_pCurrent_display_settings!=NULL);
|
|
|
- memcpy(_pCurrent_display_settings,&dm,sizeof(DEVMODE));
|
|
|
- }
|
|
|
- return true;
|
|
|
-}
|
|
|
-
|
|
|
-unsigned int wglGraphicsWindow::
|
|
|
-verify_window_sizes(unsigned int numsizes,unsigned int *dimen) {
|
|
|
- // see if window sizes are supported (i.e. in fullscrn mode)
|
|
|
- // dimen is an array containing contiguous x,y pairs specifying
|
|
|
- // possible display sizes, it is numsizes*2 long. fn will zero
|
|
|
- // out any invalid x,y size pairs. return value is number of valid
|
|
|
- // sizes that were found.
|
|
|
- //
|
|
|
- // note: it might be better to implement some sort of query
|
|
|
- // interface that returns an array of supported sizes,
|
|
|
- // but this way is somewhat simpler and will do the job
|
|
|
- // on most cards, assuming they handle the std sizes the app
|
|
|
- // knows about.
|
|
|
-
|
|
|
- if (!_props._fullscreen || (numsizes==0)) {
|
|
|
- return numsizes;
|
|
|
- }
|
|
|
-
|
|
|
- assert(dimen!=NULL);
|
|
|
-
|
|
|
- HWND hDesktopWindow = GetDesktopWindow();
|
|
|
- HDC scrnDC=GetDC(hDesktopWindow);
|
|
|
- DWORD dwFullScreenBitDepth=GetDeviceCaps(scrnDC,BITSPIXEL);
|
|
|
- ReleaseDC(hDesktopWindow,scrnDC);
|
|
|
-
|
|
|
- // gonna do an n^2 loop alg for simplicity. if speed is necessary,
|
|
|
- // could do linear time with some kind of STL hash container I guess
|
|
|
-
|
|
|
- DEVMODE dm;
|
|
|
- uint modenum=0;
|
|
|
- uint goodmodes=0;
|
|
|
- unsigned int *cur_dim_pair=dimen;
|
|
|
- for(;modenum<numsizes;modenum++,cur_dim_pair+=2) {
|
|
|
- bool bIsGoodmode;
|
|
|
- DWORD dwWidth=cur_dim_pair[0];
|
|
|
- DWORD dwHeight=cur_dim_pair[1];
|
|
|
-
|
|
|
- if ((dwWidth==0)||(dwHeight==0)) {
|
|
|
- bIsGoodmode=false;
|
|
|
- } else {
|
|
|
- if (_bIsLowVidMemCard) {
|
|
|
- bIsGoodmode=((float)(dwWidth*(float)dwHeight)<=(float)(640*480));
|
|
|
- } else {
|
|
|
- bIsGoodmode = find_acceptable_display_mode(dwWidth,dwHeight,dwFullScreenBitDepth,dm);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (bIsGoodmode) {
|
|
|
- goodmodes++;
|
|
|
- } else {
|
|
|
- // zero out the bad mode
|
|
|
- cur_dim_pair[0]=0;
|
|
|
- cur_dim_pair[1]=0;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return goodmodes;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_reshape
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::handle_reshape() {
|
|
|
- RECT view_rect;
|
|
|
- GetClientRect(_mwindow, &view_rect);
|
|
|
- ClientToScreen(_mwindow, (POINT*)&view_rect.left); // translates top,left pnt
|
|
|
- ClientToScreen(_mwindow, (POINT*)&view_rect.right); // translates right,bottom pnt
|
|
|
-
|
|
|
- // change _props xsize,ysize
|
|
|
- resized((view_rect.right - view_rect.left),(view_rect.bottom - view_rect.top));
|
|
|
-
|
|
|
- _props._xorg = view_rect.left; // _props origin should reflect upper left of view rectangle
|
|
|
- _props._yorg = view_rect.top;
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_spam()) {
|
|
|
- wgldisplay_cat.spam() << "reshape to origin: (" << _props._xorg << "," << _props._yorg << "), size: (" << _props._xsize << "," << _props._ysize << ")\n";
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_mouse_motion
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::handle_mouse_motion(int x, int y) {
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- _input_devices[0].set_pointer_in_window(x, y);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_mouse_exit
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::handle_mouse_exit(void) {
|
|
|
- // note: 'mouse_motion' is considered the 'entry' event
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- _input_devices[0].set_pointer_out_of_window();
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_keypress
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::
|
|
|
-handle_keypress(ButtonHandle key, int x, int y) {
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- _input_devices[0].set_pointer_in_window(x, y);
|
|
|
- if (key != ButtonHandle::none()) {
|
|
|
- _input_devices[0].button_down(key);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: handle_keyrelease
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::
|
|
|
-handle_keyrelease(ButtonHandle key) {
|
|
|
- if (key != ButtonHandle::none()) {
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- _input_devices[0].button_up(key);
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void INLINE process_1_event() {
|
|
|
- MSG msg;
|
|
|
-
|
|
|
- if (!GetMessage(&msg, NULL, 0, 0)) {
|
|
|
- // WM_QUIT received
|
|
|
- DestroyAllWindows(false);
|
|
|
- exit(msg.wParam); // this will invoke AtExitFn
|
|
|
- }
|
|
|
-
|
|
|
- // Translate virtual key messages
|
|
|
- TranslateMessage(&msg);
|
|
|
- // Call window_proc
|
|
|
- DispatchMessage(&msg);
|
|
|
-}
|
|
|
-
|
|
|
-void INLINE wglGraphicsWindow::process_events() {
|
|
|
- if (!_window_active) {
|
|
|
- // Get 1 msg at a time until no more are left and we block and sleep,
|
|
|
- // or message changes _return_control_to_app or !_window_active status
|
|
|
-
|
|
|
- while(!_window_active && (!_return_control_to_app)) {
|
|
|
- process_1_event();
|
|
|
- }
|
|
|
- _return_control_to_app = false;
|
|
|
-
|
|
|
- } else {
|
|
|
- MSG msg;
|
|
|
-
|
|
|
- // handle all msgs on queue in a row
|
|
|
- while(PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE)) {
|
|
|
- process_1_event();
|
|
|
- }
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: make_current
|
|
|
-// Access: Public
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::make_current() {
|
|
|
- if ((_hdc==NULL)||(_context==NULL)||(!_window_active)) {
|
|
|
- return; // we're only allow unmake_current() to set this to NULL
|
|
|
- }
|
|
|
-
|
|
|
- DO_PSTATS_STUFF(PStatTimer timer(_make_current_pcollector);)
|
|
|
- HGLRC current_context = wglGetCurrentContext();
|
|
|
- HDC current_dc = wglGetCurrentDC();
|
|
|
-
|
|
|
- if ((current_context != _context) || (current_dc != _hdc)) {
|
|
|
- if (!wglMakeCurrent(_hdc, _context)) {
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- report_errors();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: unmake_current
|
|
|
-// Access: Public
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::unmake_current() {
|
|
|
- report_errors();
|
|
|
-
|
|
|
- if (!wglMakeCurrent(NULL, NULL)) {
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-int wglGraphicsWindow::get_depth_bitwidth() {
|
|
|
- return _pixelformat.cDepthBits;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: wglGraphicsWindow::get_gsg_type
|
|
|
-// Access: Public, Virtual
|
|
|
-// Description: Returns the TypeHandle of the kind of GSG preferred
|
|
|
-// by this kind of window.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-TypeHandle wglGraphicsWindow::
|
|
|
-get_gsg_type() const {
|
|
|
- return GLGraphicsStateGuardian::get_class_type();
|
|
|
-}
|
|
|
-
|
|
|
-GraphicsWindow *wglGraphicsWindow::
|
|
|
-make_wglGraphicsWindow(const FactoryParams ¶ms) {
|
|
|
- GraphicsWindow::WindowPipe *pipe_param;
|
|
|
- if (!get_param_into(pipe_param, params)) {
|
|
|
- wgldisplay_cat.error()
|
|
|
- << "No pipe specified for window creation!" << endl;
|
|
|
- return NULL;
|
|
|
- }
|
|
|
-
|
|
|
- GraphicsPipe *pipe = pipe_param->get_pipe();
|
|
|
-
|
|
|
- GraphicsWindow::WindowProps *props_param;
|
|
|
- if (!get_param_into(props_param, params)) {
|
|
|
- return new wglGraphicsWindow(pipe);
|
|
|
- } else {
|
|
|
- return new wglGraphicsWindow(pipe, props_param->get_properties());
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-TypeHandle wglGraphicsWindow::get_class_type() {
|
|
|
- return _type_handle;
|
|
|
-}
|
|
|
-
|
|
|
-void wglGraphicsWindow::init_type() {
|
|
|
- GraphicsWindow::init_type();
|
|
|
- register_type(_type_handle, "wglGraphicsWindow",
|
|
|
- GraphicsWindow::get_class_type());
|
|
|
-}
|
|
|
-
|
|
|
-TypeHandle wglGraphicsWindow::get_type() const {
|
|
|
- return get_class_type();
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: static_window_proc
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-LONG WINAPI static_window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
|
|
|
- HWND_PANDAWIN_MAP::iterator pwin;
|
|
|
- pwin=hwnd_pandawin_map.find(hwnd);
|
|
|
-
|
|
|
- if (pwin!=hwnd_pandawin_map.end()) {
|
|
|
- wglGraphicsWindow *wglwinptr=(*pwin).second;
|
|
|
- return wglwinptr->window_proc(hwnd, msg, wparam, lparam);
|
|
|
- } else if (global_wglwinptr!=NULL){
|
|
|
- // this stuff should only be used during CreateWindow()
|
|
|
- return global_wglwinptr->window_proc(hwnd, msg, wparam, lparam);
|
|
|
- } else {
|
|
|
- // should never need this?? (maybe at shutdwn?)
|
|
|
- return DefWindowProc(hwnd, msg, wparam, lparam);
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void wglGraphicsWindow::deactivate_window() {
|
|
|
- // current policy is to suspend minimized or deactivated fullscreen windows, but leave
|
|
|
- // regular windows running normally
|
|
|
-
|
|
|
- if ((!_props._fullscreen) || _exiting_window || !_window_active || _active_minimized_fullscreen) {
|
|
|
- #ifdef _DEBUG
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "deactivate_window called, but ignored in current mode" << endl;
|
|
|
- #endif
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- throw_event("PandaPaused"); // right now this is used to signal python event handler to disable audio
|
|
|
-
|
|
|
- if (!bResponsive_minimized_fullscreen_window) {
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "WGL window deactivated, releasing gl context and waiting...\n";
|
|
|
-
|
|
|
- _window_active = false;
|
|
|
- unmake_current();
|
|
|
- } else {
|
|
|
- _active_minimized_fullscreen = true;
|
|
|
- assert(_props._fullscreen);
|
|
|
-
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "WGL window minimized from fullscreen mode, remaining active...\n";
|
|
|
- }
|
|
|
-
|
|
|
- // make sure window is minimized
|
|
|
-
|
|
|
- WINDOWPLACEMENT wndpl;
|
|
|
- wndpl.length=sizeof(WINDOWPLACEMENT);
|
|
|
-
|
|
|
- if (!GetWindowPlacement(_mwindow,&wndpl)) {
|
|
|
- wgldisplay_cat.error() << "GetWindowPlacement failed!\n";
|
|
|
- return;
|
|
|
- }
|
|
|
-
|
|
|
- if ((wndpl.showCmd!=SW_MINIMIZE)&&(wndpl.showCmd!=SW_SHOWMINIMIZED)) {
|
|
|
- ShowWindow(_mwindow, SW_MINIMIZE);
|
|
|
- }
|
|
|
-
|
|
|
- // revert to default display mode
|
|
|
- ChangeDisplaySettings(NULL,0x0);
|
|
|
-
|
|
|
- if (!bResponsive_minimized_fullscreen_window) {
|
|
|
- _PandaPausedTimer = SetTimer(_mwindow,PAUSED_TIMER_ID,1500,NULL);
|
|
|
- if (_PandaPausedTimer!=PAUSED_TIMER_ID) {
|
|
|
- wgldisplay_cat.error() << "Error in SetTimer!\n";
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- if (_props._fullscreen) {
|
|
|
- throw_event("PandaRestarted"); // right now this is used to signal python event handler to re-enable audio
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-void wglGraphicsWindow::reactivate_window() {
|
|
|
- if (!_window_active) {
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "WGL window re-activated...\n";
|
|
|
-
|
|
|
- _window_active = true;
|
|
|
-
|
|
|
- if (_PandaPausedTimer!=NULL) {
|
|
|
- KillTimer(_mwindow,_PandaPausedTimer);
|
|
|
- _PandaPausedTimer = NULL;
|
|
|
- }
|
|
|
-
|
|
|
- // move window to top of zorder,
|
|
|
- SetWindowPos(_mwindow, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER);
|
|
|
-
|
|
|
- ChangeDisplaySettings(_pCurrent_display_settings,CDS_FULLSCREEN);
|
|
|
-
|
|
|
- GdiFlush();
|
|
|
- make_current();
|
|
|
- } else if (_active_minimized_fullscreen) {
|
|
|
- if (wgldisplay_cat.is_spam())
|
|
|
- wgldisplay_cat.spam() << "redisplaying minimized fullscrn active WGL window...\n";
|
|
|
-
|
|
|
- // move window to top of zorder,
|
|
|
- SetWindowPos(_mwindow, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER);
|
|
|
-
|
|
|
- ChangeDisplaySettings(_pCurrent_display_settings,CDS_FULLSCREEN);
|
|
|
-
|
|
|
- GdiFlush();
|
|
|
- make_current();
|
|
|
- _active_minimized_fullscreen = false;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// Note: could use _TrackMouseEvent in comctrl32.dll (part of IE 3.0+) which emulates
|
|
|
-// TrackMouseEvent on w95, but that requires another 500K of memory to hold that DLL,
|
|
|
-// which is lame just to support w95, which probably has other issues anyway
|
|
|
-INLINE void wglGraphicsWindow::
|
|
|
-track_mouse_leaving(HWND hwnd) {
|
|
|
- if(_pfnTrackMouseEvent==NULL)
|
|
|
- return;
|
|
|
-
|
|
|
- TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT),TME_LEAVE,hwnd,0};
|
|
|
- BOOL bSucceeded = _pfnTrackMouseEvent(&tme); // tell win32 to post WM_MOUSELEAVE msgs
|
|
|
-
|
|
|
- if((!bSucceeded) && wgldisplay_cat.is_debug())
|
|
|
- wgldisplay_cat.debug() << "TrackMouseEvent failed!, LastError=" << GetLastError() << endl;
|
|
|
-
|
|
|
- _tracking_mouse_leaving=true;
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: window_proc
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-LONG WINAPI wglGraphicsWindow::
|
|
|
-window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) {
|
|
|
- int button = -1;
|
|
|
- int x, y;
|
|
|
-
|
|
|
- switch (msg) {
|
|
|
-
|
|
|
- case WM_MOUSEMOVE: {
|
|
|
- // Win32 doesn't return the same numbers as X does when the mouse
|
|
|
- // goes beyond the upper or left side of the window
|
|
|
- #define SET_MOUSE_COORD(iVal,VAL) { \
|
|
|
- iVal = VAL; \
|
|
|
- if(iVal & 0x8000) \
|
|
|
- iVal -= 0x10000; \
|
|
|
- }
|
|
|
-
|
|
|
- if(!_tracking_mouse_leaving) {
|
|
|
- // need to re-call TrackMouseEvent every time mouse re-enters window
|
|
|
- track_mouse_leaving(hwnd);
|
|
|
- }
|
|
|
-
|
|
|
- SET_MOUSE_COORD(x,LOWORD(lparam));
|
|
|
- SET_MOUSE_COORD(y,HIWORD(lparam));
|
|
|
-
|
|
|
- handle_mouse_motion(x, y);
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- // if cursor is invisible, make it visible when moving in the window bars,etc
|
|
|
- case WM_NCMOUSEMOVE: {
|
|
|
- if(!_props._bCursorIsVisible) {
|
|
|
- if(!_cursor_in_windowclientarea) {
|
|
|
- // wgldisplay_cat.error() << "NCMOUSEMOVE show=true\n";
|
|
|
- ShowCursor(true);
|
|
|
- _cursor_in_windowclientarea=true;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_NCMOUSELEAVE: {
|
|
|
- if(!_props._bCursorIsVisible) {
|
|
|
- // wgldisplay_cat.error() << "NCMOUSELEAVE show=false\n";
|
|
|
- ShowCursor(false);
|
|
|
- _cursor_in_windowclientarea=false;
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_MOUSELEAVE: {
|
|
|
- _tracking_mouse_leaving=false;
|
|
|
- handle_mouse_exit();
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_CREATE: {
|
|
|
- track_mouse_leaving(hwnd);
|
|
|
-
|
|
|
- _cursor_in_windowclientarea=false;
|
|
|
- if(!_props._bCursorIsVisible)
|
|
|
- ShowCursor(false);
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_CLOSE:
|
|
|
- close_window();
|
|
|
-
|
|
|
- // BUGBUG: right now there is no way to tell the panda app the graphics window is invalid or
|
|
|
- // has been closed by the user, to prevent further methods from being called on the window.
|
|
|
- // this needs to be added to panda for multiple windows to work. in the meantime, just
|
|
|
- // trigger an exit here if numwindows==0, since that is the expected behavior when all
|
|
|
- // windows are closed (should be done by the app though, and it assumes you only make this
|
|
|
- // type of panda gfx window)
|
|
|
-
|
|
|
- if (hwnd_pandawin_map.size()==0) {
|
|
|
- exit(0);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_MOVE:
|
|
|
- // handle all this stuff in EXITSIZEMOVE. will rendering work during moving? do we care?
|
|
|
- //_props._xorg = LOWORD(lparam);
|
|
|
- //_props._yorg = HIWORD(lparam);
|
|
|
- break;
|
|
|
-
|
|
|
-
|
|
|
- case WM_ACTIVATEAPP: {
|
|
|
- #ifdef _DEBUG
|
|
|
- wgldisplay_cat.spam() << "WM_ACTIVATEAPP(" << (bool)(wparam!=0) <<") received\n";
|
|
|
- #endif
|
|
|
-
|
|
|
- if (!wparam) {
|
|
|
- deactivate_window();
|
|
|
- return 0;
|
|
|
- } // dont want to reactivate until window is actually un-minimized (see WM_SIZE)
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_EXITSIZEMOVE:
|
|
|
- #ifdef _DEBUG
|
|
|
- wgldisplay_cat.spam() << "WM_EXITSIZEMOVE received" << endl;
|
|
|
- #endif
|
|
|
-
|
|
|
- reactivate_window();
|
|
|
- handle_reshape();
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_ENTERSIZEMOVE:
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SIZE: {
|
|
|
- DWORD width,height;
|
|
|
-
|
|
|
- width = LOWORD(lparam); height = HIWORD(lparam);
|
|
|
- #ifdef _DEBUG
|
|
|
- {
|
|
|
- wgldisplay_cat.spam() << "WM_SIZE received with width:" << width << " height: " << height << " flags: " <<
|
|
|
- ((wparam == SIZE_MAXHIDE)? "SIZE_MAXHIDE " : "") << ((wparam == SIZE_MAXSHOW)? "SIZE_MAXSHOW " : "") <<
|
|
|
- ((wparam == SIZE_MINIMIZED)? "SIZE_MINIMIZED " : "") << ((wparam == SIZE_RESTORED)? "SIZE_RESTORED " : "") <<
|
|
|
- ((wparam == SIZE_MAXIMIZED)? "SIZE_MAXIMIZED " : "") << endl;
|
|
|
- }
|
|
|
- #endif
|
|
|
- if (_mwindow==NULL)
|
|
|
- break;
|
|
|
-
|
|
|
- if ((wparam==SIZE_MAXIMIZED) || (wparam==SIZE_RESTORED)) { // old comment -- added SIZE_RESTORED to handle 3dfx case (what does this mean?)
|
|
|
- reactivate_window();
|
|
|
-
|
|
|
-// if ((_props._xsize != width) || (_props._ysize != height))
|
|
|
- handle_reshape();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_PAINT: {
|
|
|
- PAINTSTRUCT ps;
|
|
|
- BeginPaint(hwnd, &ps);
|
|
|
- // glReadBuffer(GL_BACK); need to copy current rendering to front buffer, a la wdxdisplay?
|
|
|
- EndPaint(hwnd, &ps);
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_IME_NOTIFY:
|
|
|
- if (wparam == IMN_SETOPENSTATUS) {
|
|
|
- HIMC hIMC = ImmGetContext(hwnd);
|
|
|
- nassertr(hIMC != 0, 0);
|
|
|
- _ime_open = (ImmGetOpenStatus(hIMC) != 0);
|
|
|
- if (!_ime_open) {
|
|
|
- _ime_active = false; // Sanity enforcement.
|
|
|
- }
|
|
|
- ImmReleaseContext(hwnd, hIMC);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_STARTCOMPOSITION:
|
|
|
- _ime_active = true;
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_ENDCOMPOSITION:
|
|
|
- _ime_active = false;
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_IME_COMPOSITION:
|
|
|
- if (lparam & GCS_RESULTSTR) {
|
|
|
- if (!_input_devices.empty()) {
|
|
|
- HIMC hIMC = ImmGetContext(hwnd);
|
|
|
- nassertr(hIMC != 0, 0);
|
|
|
-
|
|
|
- static const int max_ime_result = 128;
|
|
|
- static char ime_result[max_ime_result];
|
|
|
-
|
|
|
- if (_ime_composition_w) {
|
|
|
- // Since ImmGetCompositionStringA() doesn't seem to work
|
|
|
- // for Win2000 (it always returns question mark
|
|
|
- // characters), we have to use ImmGetCompositionStringW()
|
|
|
- // on this OS. This is actually the easier of the two
|
|
|
- // functions to use.
|
|
|
-
|
|
|
- DWORD result_size =
|
|
|
- ImmGetCompositionStringW(hIMC, GCS_RESULTSTR,
|
|
|
- ime_result, max_ime_result);
|
|
|
-
|
|
|
- // Add this string into the text buffer of the application.
|
|
|
-
|
|
|
- // ImmGetCompositionStringW() returns a string, but it's
|
|
|
- // filled in with wstring data: every two characters defines a
|
|
|
- // 16-bit unicode char. The docs aren't clear on the
|
|
|
- // endianness of this. I guess it's safe to assume all Win32
|
|
|
- // machines are little-endian.
|
|
|
- for (DWORD i = 0; i < result_size; i += 2) {
|
|
|
- int result =
|
|
|
- ((int)(unsigned char)ime_result[i + 1] << 8) |
|
|
|
- (unsigned char)ime_result[i];
|
|
|
- _input_devices[0].keystroke(result);
|
|
|
- }
|
|
|
- } else {
|
|
|
- // On the other hand, ImmGetCompositionStringW() doesn't
|
|
|
- // work on Win95 or Win98; for these OS's we must use
|
|
|
- // ImmGetCompositionStringA().
|
|
|
- DWORD result_size =
|
|
|
- ImmGetCompositionStringA(hIMC, GCS_RESULTSTR,
|
|
|
- ime_result, max_ime_result);
|
|
|
-
|
|
|
- // ImmGetCompositionStringA() returns an encoded ANSI
|
|
|
- // string, which we now have to map to wide-character
|
|
|
- // Unicode.
|
|
|
- static const int max_wide_result = 128;
|
|
|
- static wchar_t wide_result[max_wide_result];
|
|
|
-
|
|
|
- int wide_size =
|
|
|
- MultiByteToWideChar(CP_ACP, 0,
|
|
|
- ime_result, result_size,
|
|
|
- wide_result, max_wide_result);
|
|
|
- if (wide_size == 0) {
|
|
|
- PrintErrorMessage(LAST_ERROR);
|
|
|
- }
|
|
|
- for (int i = 0; i < wide_size; i++) {
|
|
|
- _input_devices[0].keystroke(wide_result[i]);
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- ImmReleaseContext(hwnd, hIMC);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_CHAR:
|
|
|
- // Ignore WM_CHAR messages if we have the IME open, since
|
|
|
- // everything will come in through WM_IME_COMPOSITION. (It's
|
|
|
- // supposed to come in through WM_CHAR, too, but there seems to
|
|
|
- // be a bug in Win2000 in that it only sends question mark
|
|
|
- // characters through here.)
|
|
|
- if (!_ime_open && !_input_devices.empty()) {
|
|
|
- _input_devices[0].keystroke(wparam);
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SYSKEYDOWN: {
|
|
|
- // Alt and F10 are sent as WM_SYSKEYDOWN instead of WM_KEYDOWN
|
|
|
- // want to use defwindproc on Alt syskey so std windows cmd Alt-F4 works, etc
|
|
|
- POINT point;
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
- handle_keypress(lookup_key(wparam), point.x, point.y);
|
|
|
- if (wparam == VK_F10) {
|
|
|
- //bypass default windproc F10 behavior (it activates the main menu, but we have none)
|
|
|
- return 0;
|
|
|
- }
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SYSCOMMAND:
|
|
|
- if(wparam==SC_KEYMENU) {
|
|
|
- // if Alt is released (alone w/o other keys), defwindproc will send
|
|
|
- // this command, which will 'activate' the title bar menu (we have none)
|
|
|
- // and give focus to it. we dont want this to happen, so kill this msg
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_KEYDOWN: {
|
|
|
- POINT point;
|
|
|
-
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
- handle_keypress(lookup_key(wparam), point.x, point.y);
|
|
|
-
|
|
|
- // Handle Cntrl-V paste from clipboard. Is there a better way
|
|
|
- // to detect this hotkey?
|
|
|
- if ((wparam=='V') && (GetKeyState(VK_CONTROL) < 0) &&
|
|
|
- !_input_devices.empty()) {
|
|
|
- HGLOBAL hglb;
|
|
|
- char *lptstr;
|
|
|
-
|
|
|
- if (!IsClipboardFormatAvailable(CF_TEXT))
|
|
|
- return 0;
|
|
|
-
|
|
|
- if (!OpenClipboard(NULL))
|
|
|
- return 0;
|
|
|
-
|
|
|
- // Maybe we should support CF_UNICODETEXT if it is available
|
|
|
- // too?
|
|
|
- hglb = GetClipboardData(CF_TEXT);
|
|
|
- if (hglb!=NULL) {
|
|
|
- lptstr = (char *) GlobalLock(hglb);
|
|
|
- if (lptstr != NULL) {
|
|
|
- char *pChar;
|
|
|
- for(pChar=lptstr;*pChar!=NULL;pChar++) {
|
|
|
- _input_devices[0].keystroke((uchar)*pChar);
|
|
|
- }
|
|
|
- GlobalUnlock(hglb);
|
|
|
- }
|
|
|
- }
|
|
|
- CloseClipboard();
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_SYSKEYUP:
|
|
|
- case WM_KEYUP:
|
|
|
- handle_keyrelease(lookup_key(wparam));
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_LBUTTONDOWN:
|
|
|
- button = 0;
|
|
|
- case WM_MBUTTONDOWN:
|
|
|
- if (button < 0)
|
|
|
- button = 1;
|
|
|
-
|
|
|
- case WM_RBUTTONDOWN:
|
|
|
- if (button < 0)
|
|
|
- button = 2;
|
|
|
- SetCapture(hwnd);
|
|
|
- SET_MOUSE_COORD(x,LOWORD(lparam));
|
|
|
- SET_MOUSE_COORD(y,HIWORD(lparam));
|
|
|
- handle_keypress(MouseButton::button(button), x, y);
|
|
|
- break;
|
|
|
- case WM_LBUTTONUP:
|
|
|
- button = 0;
|
|
|
- case WM_MBUTTONUP:
|
|
|
- if (button < 0)
|
|
|
- button = 1;
|
|
|
- case WM_RBUTTONUP:
|
|
|
- if (button < 0)
|
|
|
- button = 2;
|
|
|
- ReleaseCapture();
|
|
|
- #if 0
|
|
|
- SET_MOUSE_COORD(x,LOWORD(lparam));
|
|
|
- SET_MOUSE_COORD(y,HIWORD(lparam));
|
|
|
- #endif
|
|
|
- handle_keyrelease(MouseButton::button(button));
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_SETFOCUS: {
|
|
|
- // wgldisplay_cat.info() << "got WM_SETFOCUS\n";
|
|
|
-
|
|
|
- // make_current(); causes errors when Alt-tabbing?
|
|
|
-
|
|
|
- POINT point;
|
|
|
- GetCursorPos(&point);
|
|
|
- ScreenToClient(hwnd, &point);
|
|
|
-
|
|
|
- // this is a hack to make sure common modifier keys have proper state
|
|
|
- // since at focus loss, app may never receive key-up event corresponding to
|
|
|
- // a key-down. it would be better to know the exact set of ModifierButtons the
|
|
|
- // user is using, since we may miss some here
|
|
|
-
|
|
|
- for(int i=0;i<NUM_MODIFIER_KEYS;i++) {
|
|
|
- if (GetKeyState(hardcoded_modifier_buttons[i]) < 0)
|
|
|
- handle_keypress(lookup_key(hardcoded_modifier_buttons[i]),point.x,point.y);
|
|
|
- }
|
|
|
- return 0;
|
|
|
- }
|
|
|
-
|
|
|
- case WM_KILLFOCUS: {
|
|
|
- for(int i=0;i<NUM_MODIFIER_KEYS;i++) {
|
|
|
- if (GetKeyState(hardcoded_modifier_buttons[i]) < 0)
|
|
|
- handle_keyrelease(lookup_key(hardcoded_modifier_buttons[i]));
|
|
|
- }
|
|
|
-
|
|
|
- return 0;
|
|
|
- }
|
|
|
- break;
|
|
|
-
|
|
|
- case WM_TIMER:
|
|
|
- if ((wparam==_PandaPausedTimer) && !_window_active) {
|
|
|
- //wgldisplay_cat.spam() << "returning control to app\n";
|
|
|
- _return_control_to_app = true;
|
|
|
- // throw_event("PandaPaused");
|
|
|
- // do we still need to do this since I return control to app periodically using timer msgs?
|
|
|
- // does app need to know to avoid major computation?
|
|
|
- }
|
|
|
-
|
|
|
- break;
|
|
|
- }
|
|
|
-
|
|
|
- return DefWindowProc(hwnd, msg, wparam, lparam);
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: lookup_key
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-ButtonHandle wglGraphicsWindow::
|
|
|
-lookup_key(WPARAM wparam) const {
|
|
|
- // First, check for a few buttons that we filter out when the IME
|
|
|
- // window is open.
|
|
|
- if (!_ime_active) {
|
|
|
- switch(wparam) {
|
|
|
- case VK_BACK: return KeyboardButton::backspace();
|
|
|
- case VK_DELETE: return KeyboardButton::del();
|
|
|
- case VK_ESCAPE: return KeyboardButton::escape();
|
|
|
- case VK_SPACE: return KeyboardButton::space();
|
|
|
- case VK_UP: return KeyboardButton::up();
|
|
|
- case VK_DOWN: return KeyboardButton::down();
|
|
|
- case VK_LEFT: return KeyboardButton::left();
|
|
|
- case VK_RIGHT: return KeyboardButton::right();
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Now check for the rest of the buttons, including the ones that
|
|
|
- // we allow through even when the IME window is open.
|
|
|
- switch(wparam) {
|
|
|
- case VK_TAB: return KeyboardButton::tab();
|
|
|
- case VK_PRIOR: return KeyboardButton::page_up();
|
|
|
- case VK_NEXT: return KeyboardButton::page_down();
|
|
|
- case VK_HOME: return KeyboardButton::home();
|
|
|
- case VK_END: return KeyboardButton::end();
|
|
|
- case VK_F1: return KeyboardButton::f1();
|
|
|
- case VK_F2: return KeyboardButton::f2();
|
|
|
- case VK_F3: return KeyboardButton::f3();
|
|
|
- case VK_F4: return KeyboardButton::f4();
|
|
|
- case VK_F5: return KeyboardButton::f5();
|
|
|
- case VK_F6: return KeyboardButton::f6();
|
|
|
- case VK_F7: return KeyboardButton::f7();
|
|
|
- case VK_F8: return KeyboardButton::f8();
|
|
|
- case VK_F9: return KeyboardButton::f9();
|
|
|
- case VK_F10: return KeyboardButton::f10();
|
|
|
- case VK_F11: return KeyboardButton::f11();
|
|
|
- case VK_F12: return KeyboardButton::f12();
|
|
|
- case VK_INSERT: return KeyboardButton::insert();
|
|
|
- case VK_CAPITAL: return KeyboardButton::caps_lock();
|
|
|
- case VK_NUMLOCK: return KeyboardButton::num_lock();
|
|
|
- case VK_SCROLL: return KeyboardButton::scroll_lock();
|
|
|
- case VK_SNAPSHOT: return KeyboardButton::print_screen();
|
|
|
-
|
|
|
- case VK_SHIFT:
|
|
|
- case VK_LSHIFT:
|
|
|
- case VK_RSHIFT:
|
|
|
- return KeyboardButton::shift();
|
|
|
-
|
|
|
- case VK_CONTROL:
|
|
|
- case VK_LCONTROL:
|
|
|
- case VK_RCONTROL:
|
|
|
- return KeyboardButton::control();
|
|
|
-
|
|
|
- case VK_MENU:
|
|
|
- case VK_LMENU:
|
|
|
- case VK_RMENU:
|
|
|
- return KeyboardButton::alt();
|
|
|
-
|
|
|
- default:
|
|
|
- int key = MapVirtualKey(wparam, 2);
|
|
|
- if (isascii(key) && key != 0) {
|
|
|
- // We used to try to remap lowercase to uppercase keys
|
|
|
- // here based on the state of the shift and/or caps lock
|
|
|
- // keys. But that's a mistake, and doesn't allow for
|
|
|
- // international or user-defined keyboards; let Windows
|
|
|
- // do that mapping.
|
|
|
-
|
|
|
- // Nowadays, we make a distinction between a "button"
|
|
|
- // and a "keystroke". A button corresponds to a
|
|
|
- // physical button on the keyboard and has a down and up
|
|
|
- // event associated. A keystroke may or may not
|
|
|
- // correspond to a physical button, but will be some
|
|
|
- // Unicode character and will not have a corresponding
|
|
|
- // up event.
|
|
|
- return KeyboardButton::ascii_key(tolower(key));
|
|
|
- }
|
|
|
- break;
|
|
|
- }
|
|
|
- return ButtonHandle::none();
|
|
|
-}
|
|
|
-
|
|
|
-#if 0
|
|
|
-// old fns
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: get_config
|
|
|
-// Access:
|
|
|
-// Description:
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-void wglGraphicsWindow::
|
|
|
-get_config(PIXELFORMATDESCRIPTOR *visual, int attrib, int *value) {
|
|
|
- if (visual == NULL)
|
|
|
- return;
|
|
|
-
|
|
|
- switch (attrib) {
|
|
|
- case GLX_USE_GL:
|
|
|
- if (visual->dwFlags & (PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW)) {
|
|
|
- if (visual->iPixelType == PFD_TYPE_COLORINDEX &&
|
|
|
- visual->cColorBits >= 24) {
|
|
|
- *value = 0;
|
|
|
- } else {
|
|
|
- *value = 1;
|
|
|
- }
|
|
|
- } else {
|
|
|
- *value = 0;
|
|
|
- }
|
|
|
- break;
|
|
|
- case GLX_BUFFER_SIZE:
|
|
|
- if (visual->iPixelType == PFD_TYPE_RGBA)
|
|
|
- *value = visual->cColorBits;
|
|
|
- else
|
|
|
- *value = 8;
|
|
|
- break;
|
|
|
- case GLX_LEVEL:
|
|
|
- *value = visual->bReserved;
|
|
|
- break;
|
|
|
- case GLX_RGBA:
|
|
|
- *value = visual->iPixelType == PFD_TYPE_RGBA;
|
|
|
- break;
|
|
|
- case GLX_DOUBLEBUFFER:
|
|
|
- *value = visual->dwFlags & PFD_DOUBLEBUFFER;
|
|
|
- break;
|
|
|
- case GLX_STEREO:
|
|
|
- *value = visual->dwFlags & PFD_STEREO;
|
|
|
- break;
|
|
|
- case GLX_AUX_BUFFERS:
|
|
|
- *value = visual->cAuxBuffers;
|
|
|
- break;
|
|
|
- case GLX_RED_SIZE:
|
|
|
- *value = visual->cRedBits;
|
|
|
- break;
|
|
|
- case GLX_GREEN_SIZE:
|
|
|
- *value = visual->cGreenBits;
|
|
|
- break;
|
|
|
- case GLX_BLUE_SIZE:
|
|
|
- *value = visual->cBlueBits;
|
|
|
- break;
|
|
|
- case GLX_ALPHA_SIZE:
|
|
|
- *value = visual->cAlphaBits;
|
|
|
- break;
|
|
|
- case GLX_DEPTH_SIZE:
|
|
|
- *value = visual->cDepthBits;
|
|
|
- break;
|
|
|
- case GLX_STENCIL_SIZE:
|
|
|
- *value = visual->cStencilBits;
|
|
|
- break;
|
|
|
- case GLX_ACCUM_RED_SIZE:
|
|
|
- *value = visual->cAccumRedBits;
|
|
|
- break;
|
|
|
- case GLX_ACCUM_GREEN_SIZE:
|
|
|
- *value = visual->cAccumGreenBits;
|
|
|
- break;
|
|
|
- case GLX_ACCUM_BLUE_SIZE:
|
|
|
- *value = visual->cAccumBlueBits;
|
|
|
- break;
|
|
|
- case GLX_ACCUM_ALPHA_SIZE:
|
|
|
- *value = visual->cAccumAlphaBits;
|
|
|
- break;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-// Function: try_for_visual
|
|
|
-// Description: This is a static function that attempts to get the
|
|
|
-// requested visual, if it is available. It's just a
|
|
|
-// wrapper around glXChooseVisual(). It returns the
|
|
|
-// visual information if possible, or NULL if it is not.
|
|
|
-////////////////////////////////////////////////////////////////////
|
|
|
-PIXELFORMATDESCRIPTOR* wglGraphicsWindow::
|
|
|
-try_for_visual(wglGraphicsPipe *pipe, int mask,
|
|
|
- int want_depth_bits, int want_color_bits) {
|
|
|
- static const int max_attrib_list = 32;
|
|
|
- int attrib_list[max_attrib_list];
|
|
|
- int n=0;
|
|
|
-
|
|
|
- wgldisplay_cat.debug()
|
|
|
- << "Trying for visual with: RGB(" << want_color_bits << ")";
|
|
|
-
|
|
|
- int want_color_component_bits;
|
|
|
- if (mask & W_ALPHA) {
|
|
|
- want_color_component_bits = max(want_color_bits / 4, 1);
|
|
|
- } else {
|
|
|
- want_color_component_bits = max(want_color_bits / 3, 1);
|
|
|
- }
|
|
|
-
|
|
|
- attrib_list[n++] = GLX_RGBA;
|
|
|
- attrib_list[n++] = GLX_RED_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- attrib_list[n++] = GLX_GREEN_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- attrib_list[n++] = GLX_BLUE_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
-
|
|
|
- if (mask & W_ALPHA) {
|
|
|
- wgldisplay_cat.debug(false) << " ALPHA";
|
|
|
- attrib_list[n++] = GLX_ALPHA_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- }
|
|
|
- if (mask & W_DOUBLE) {
|
|
|
- wgldisplay_cat.debug(false) << " DOUBLEBUFFER";
|
|
|
- attrib_list[n++] = GLX_DOUBLEBUFFER;
|
|
|
- }
|
|
|
- if (mask & W_STEREO) {
|
|
|
- wgldisplay_cat.debug(false) << " STEREO";
|
|
|
- attrib_list[n++] = GLX_STEREO;
|
|
|
- }
|
|
|
- if (mask & W_DEPTH) {
|
|
|
- wgldisplay_cat.debug(false) << " DEPTH(" << want_depth_bits << ")";
|
|
|
- attrib_list[n++] = GLX_DEPTH_SIZE;
|
|
|
- attrib_list[n++] = want_depth_bits;
|
|
|
- }
|
|
|
- if (mask & W_STENCIL) {
|
|
|
- wgldisplay_cat.debug(false) << " STENCIL";
|
|
|
- attrib_list[n++] = GLX_STENCIL_SIZE;
|
|
|
- attrib_list[n++] = 1;
|
|
|
- }
|
|
|
- if (mask & W_ACCUM) {
|
|
|
- wgldisplay_cat.debug(false) << " ACCUM";
|
|
|
- attrib_list[n++] = GLX_ACCUM_RED_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- attrib_list[n++] = GLX_ACCUM_GREEN_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- attrib_list[n++] = GLX_ACCUM_BLUE_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- if (mask & W_ALPHA) {
|
|
|
- attrib_list[n++] = GLX_ACCUM_ALPHA_SIZE;
|
|
|
- attrib_list[n++] = want_color_component_bits;
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- // Terminate the list
|
|
|
- nassertr(n < max_attrib_list, NULL);
|
|
|
- attrib_list[n] = 0L;
|
|
|
-
|
|
|
- PIXELFORMATDESCRIPTOR pfd;
|
|
|
- PIXELFORMATDESCRIPTOR *match = NULL;
|
|
|
- bool stereo = false;
|
|
|
-
|
|
|
- memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
- pfd.nSize = (sizeof(PIXELFORMATDESCRIPTOR));
|
|
|
- pfd.nVersion = 1;
|
|
|
-
|
|
|
- // Defaults
|
|
|
- pfd.dwFlags = PFD_SUPPORT_OPENGL | PFD_DRAW_TO_WINDOW;
|
|
|
- pfd.iPixelType = PFD_TYPE_COLORINDEX;
|
|
|
- pfd.cColorBits = 32;
|
|
|
- pfd.cDepthBits = 0;
|
|
|
-
|
|
|
- int *p = attrib_list;
|
|
|
- while (*p) {
|
|
|
- switch (*p) {
|
|
|
- case GLX_USE_GL:
|
|
|
- pfd.dwFlags |= PFD_SUPPORT_OPENGL;
|
|
|
- break;
|
|
|
- case GLX_LEVEL:
|
|
|
- pfd.bReserved = *(++p);
|
|
|
- break;
|
|
|
- case GLX_RGBA:
|
|
|
- pfd.iPixelType = PFD_TYPE_RGBA;
|
|
|
- break;
|
|
|
- case GLX_DOUBLEBUFFER:
|
|
|
- pfd.dwFlags |= PFD_DOUBLEBUFFER;
|
|
|
- break;
|
|
|
- case GLX_STEREO:
|
|
|
- stereo = true;
|
|
|
- pfd.dwFlags |= PFD_STEREO;
|
|
|
- break;
|
|
|
- case GLX_AUX_BUFFERS:
|
|
|
- pfd.cAuxBuffers = *(++p);
|
|
|
- break;
|
|
|
- case GLX_RED_SIZE:
|
|
|
- pfd.cRedBits = 8; // Try to get the maximum
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- case GLX_GREEN_SIZE:
|
|
|
- pfd.cGreenBits = 8; // Try to get the maximum
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- case GLX_BLUE_SIZE:
|
|
|
- pfd.cBlueBits = 8; // Try to get the maximum
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- case GLX_ALPHA_SIZE:
|
|
|
- pfd.cAlphaBits = 8; // Try to get the maximum
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- case GLX_DEPTH_SIZE:
|
|
|
- pfd.cDepthBits = 32; // Try to get the maximum
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- case GLX_STENCIL_SIZE:
|
|
|
- pfd.cStencilBits = *(++p);
|
|
|
- break;
|
|
|
- case GLX_ACCUM_RED_SIZE:
|
|
|
- case GLX_ACCUM_GREEN_SIZE:
|
|
|
- case GLX_ACCUM_BLUE_SIZE:
|
|
|
- case GLX_ACCUM_ALPHA_SIZE:
|
|
|
- // Only cAccumBits is used for requesting accum buffer
|
|
|
- pfd.cAccumBits = 1;
|
|
|
- ++p;
|
|
|
- break;
|
|
|
- }
|
|
|
- ++p;
|
|
|
- }
|
|
|
-
|
|
|
- int pf = ChoosePixelFormat(_hdc, &pfd);
|
|
|
- if (pf > 0) {
|
|
|
- DescribePixelFormat(_hdc, pf, sizeof(PIXELFORMATDESCRIPTOR), &_pixelformat);
|
|
|
-
|
|
|
- // ChoosePixelFormat is dumb about stereo
|
|
|
- if (stereo) {
|
|
|
- if (!(_pixelformat->dwFlags & PFD_STEREO)) {
|
|
|
- wgldisplay_cat.info() << "try_for_visual() - request for stereo failed" << endl;
|
|
|
- }
|
|
|
- }
|
|
|
- }
|
|
|
-
|
|
|
- return match;
|
|
|
-}
|
|
|
-
|
|
|
-#endif
|
|
|
-
|
|
|
-extern char *ConvDDErrorToString(const HRESULT &error) {
|
|
|
- switch(error) {
|
|
|
- case E_FAIL:
|
|
|
- return "Unspecified error E_FAIL";
|
|
|
-
|
|
|
- case DD_OK:
|
|
|
- return "No error.\0";
|
|
|
-
|
|
|
- case DDERR_ALREADYINITIALIZED : // (5)
|
|
|
- return "DDERR_ALREADYINITIALIZED ";//: // (5)
|
|
|
- case DDERR_CANNOTATTACHSURFACE : // (10)
|
|
|
- return "DDERR_CANNOTATTACHSURFACE ";//: // (10)
|
|
|
- case DDERR_CANNOTDETACHSURFACE : // (20)
|
|
|
- return "DDERR_CANNOTDETACHSURFACE ";//: // (20)
|
|
|
- case DDERR_CURRENTLYNOTAVAIL : // (40)
|
|
|
- return "DDERR_CURRENTLYNOTAVAIL ";//: // (40)
|
|
|
- case DDERR_EXCEPTION : // (55)
|
|
|
- return "DDERR_EXCEPTION ";//: // (55)
|
|
|
- case DDERR_HEIGHTALIGN : // (90)
|
|
|
- return "DDERR_HEIGHTALIGN ";//: // (90)
|
|
|
- case DDERR_INCOMPATIBLEPRIMARY : // (95)
|
|
|
- return "DDERR_INCOMPATIBLEPRIMARY ";//: // (95)
|
|
|
- case DDERR_INVALIDCAPS : // (100)
|
|
|
- return "DDERR_INVALIDCAPS ";//: // (100)
|
|
|
- case DDERR_INVALIDCLIPLIST : // (110)
|
|
|
- return "DDERR_INVALIDCLIPLIST ";//: // (110)
|
|
|
- case DDERR_INVALIDMODE : // (120)
|
|
|
- return "DDERR_INVALIDMODE ";//: // (120)
|
|
|
- case DDERR_INVALIDOBJECT : // (130)
|
|
|
- return "DDERR_INVALIDOBJECT ";//: // (130)
|
|
|
- case DDERR_INVALIDPIXELFORMAT : // (145)
|
|
|
- return "DDERR_INVALIDPIXELFORMAT ";//: // (145)
|
|
|
- case DDERR_INVALIDRECT : // (150)
|
|
|
- return "DDERR_INVALIDRECT ";//: // (150)
|
|
|
- case DDERR_LOCKEDSURFACES : // (160)
|
|
|
- return "DDERR_LOCKEDSURFACES ";//: // (160)
|
|
|
- case DDERR_NO3D : // (170)
|
|
|
- return "DDERR_NO3D ";//: // (170)
|
|
|
- case DDERR_NOALPHAHW : // (180)
|
|
|
- return "DDERR_NOALPHAHW ";//: // (180)
|
|
|
- case DDERR_NOCLIPLIST : // (205)
|
|
|
- return "DDERR_NOCLIPLIST ";//: // (205)
|
|
|
- case DDERR_NOCOLORCONVHW : // (210)
|
|
|
- return "DDERR_NOCOLORCONVHW ";//: // (210)
|
|
|
- case DDERR_NOCOOPERATIVELEVELSET : // (212)
|
|
|
- return "DDERR_NOCOOPERATIVELEVELSET ";//: // (212)
|
|
|
- case DDERR_NOCOLORKEY : // (215)
|
|
|
- return "DDERR_NOCOLORKEY ";//: // (215)
|
|
|
- case DDERR_NOCOLORKEYHW : // (220)
|
|
|
- return "DDERR_NOCOLORKEYHW ";//: // (220)
|
|
|
- case DDERR_NODIRECTDRAWSUPPORT : // (222)
|
|
|
- return "DDERR_NODIRECTDRAWSUPPORT ";//: // (222)
|
|
|
- case DDERR_NOEXCLUSIVEMODE : // (225)
|
|
|
- return "DDERR_NOEXCLUSIVEMODE ";//: // (225)
|
|
|
- case DDERR_NOFLIPHW : // (230)
|
|
|
- return "DDERR_NOFLIPHW ";//: // (230)
|
|
|
- case DDERR_NOGDI : // (240)
|
|
|
- return "DDERR_NOGDI ";//: // (240)
|
|
|
- case DDERR_NOMIRRORHW : // (250)
|
|
|
- return "DDERR_NOMIRRORHW ";//: // (250)
|
|
|
- case DDERR_NOTFOUND : // (255)
|
|
|
- return "DDERR_NOTFOUND ";//: // (255)
|
|
|
- case DDERR_NOOVERLAYHW : // (260)
|
|
|
- return "DDERR_NOOVERLAYHW ";//: // (260)
|
|
|
- case DDERR_NORASTEROPHW : // (280)
|
|
|
- return "DDERR_NORASTEROPHW ";//: // (280)
|
|
|
- case DDERR_NOROTATIONHW : // (290)
|
|
|
- return "DDERR_NOROTATIONHW ";//: // (290)
|
|
|
- case DDERR_NOSTRETCHHW : // (310)
|
|
|
- return "DDERR_NOSTRETCHHW ";//: // (310)
|
|
|
- case DDERR_NOT4BITCOLOR : // (316)
|
|
|
- return "DDERR_NOT4BITCOLOR ";//: // (316)
|
|
|
- case DDERR_NOT4BITCOLORINDEX : // (317)
|
|
|
- return "DDERR_NOT4BITCOLORINDEX ";//: // (317)
|
|
|
- case DDERR_NOT8BITCOLOR : // (320)
|
|
|
- return "DDERR_NOT8BITCOLOR ";//: // (320)
|
|
|
- case DDERR_NOTEXTUREHW : // (330)
|
|
|
- return "DDERR_NOTEXTUREHW ";//: // (330)
|
|
|
- case DDERR_NOVSYNCHW : // (335)
|
|
|
- return "DDERR_NOVSYNCHW ";//: // (335)
|
|
|
- case DDERR_NOZBUFFERHW : // (340)
|
|
|
- return "DDERR_NOZBUFFERHW ";//: // (340)
|
|
|
- case DDERR_NOZOVERLAYHW : // (350)
|
|
|
- return "DDERR_NOZOVERLAYHW ";//: // (350)
|
|
|
- case DDERR_OUTOFCAPS : // (360)
|
|
|
- return "DDERR_OUTOFCAPS ";//: // (360)
|
|
|
- case DDERR_OUTOFVIDEOMEMORY : // (380)
|
|
|
- return "DDERR_OUTOFVIDEOMEMORY ";//: // (380)
|
|
|
- case DDERR_OVERLAYCANTCLIP : // (382)
|
|
|
- return "DDERR_OVERLAYCANTCLIP ";//: // (382)
|
|
|
- case DDERR_OVERLAYCOLORKEYONLYONEACTIVE : // (384)
|
|
|
- return "DDERR_OVERLAYCOLORKEYONLYONEACTIVE ";//: // (384)
|
|
|
- case DDERR_PALETTEBUSY : // (387)
|
|
|
- return "DDERR_PALETTEBUSY ";//: // (387)
|
|
|
- case DDERR_COLORKEYNOTSET : // (400)
|
|
|
- return "DDERR_COLORKEYNOTSET ";//: // (400)
|
|
|
- case DDERR_SURFACEALREADYATTACHED : // (410)
|
|
|
- return "DDERR_SURFACEALREADYATTACHED ";//: // (410)
|
|
|
- case DDERR_SURFACEALREADYDEPENDENT : // (420)
|
|
|
- return "DDERR_SURFACEALREADYDEPENDENT ";//: // (420)
|
|
|
- case DDERR_SURFACEBUSY : // (430)
|
|
|
- return "DDERR_SURFACEBUSY ";//: // (430)
|
|
|
- case DDERR_CANTLOCKSURFACE : // (435)
|
|
|
- return "DDERR_CANTLOCKSURFACE";//: // (435)
|
|
|
- case DDERR_SURFACEISOBSCURED : // (440)
|
|
|
- return "DDERR_SURFACEISOBSCURED ";//: // (440)
|
|
|
- case DDERR_SURFACELOST : // (450)
|
|
|
- return "DDERR_SURFACELOST ";//: // (450)
|
|
|
- case DDERR_SURFACENOTATTACHED : // (460)
|
|
|
- return "DDERR_SURFACENOTATTACHED ";//: // (460)
|
|
|
- case DDERR_TOOBIGHEIGHT : // (470)
|
|
|
- return "DDERR_TOOBIGHEIGHT ";//: // (470)
|
|
|
- case DDERR_TOOBIGSIZE : // (480)
|
|
|
- return "DDERR_TOOBIGSIZE ";//: // (480)
|
|
|
- case DDERR_TOOBIGWIDTH : // (490)
|
|
|
- return "DDERR_TOOBIGWIDTH ";//: // (490)
|
|
|
- case DDERR_UNSUPPORTEDFORMAT : // (510)
|
|
|
- return "DDERR_UNSUPPORTEDFORMAT ";//: // (510)
|
|
|
- case DDERR_UNSUPPORTEDMASK : // (520)
|
|
|
- return "DDERR_UNSUPPORTEDMASK ";//: // (520)
|
|
|
- case DDERR_VERTICALBLANKINPROGRESS : // (537)
|
|
|
- return "DDERR_VERTICALBLANKINPROGRESS ";//: // (537)
|
|
|
- case DDERR_WASSTILLDRAWING : // (540)
|
|
|
- return "DDERR_WASSTILLDRAWING ";//: // (540)
|
|
|
- case DDERR_XALIGN : // (560)
|
|
|
- return "DDERR_XALIGN ";//: // (560)
|
|
|
- case DDERR_INVALIDDIRECTDRAWGUID : // (561)
|
|
|
- return "DDERR_INVALIDDIRECTDRAWGUID ";//: // (561)
|
|
|
- case DDERR_DIRECTDRAWALREADYCREATED : // (562)
|
|
|
- return "DDERR_DIRECTDRAWALREADYCREATED ";//: // (562)
|
|
|
- case DDERR_NODIRECTDRAWHW : // (563)
|
|
|
- return "DDERR_NODIRECTDRAWHW ";//: // (563)
|
|
|
- case DDERR_PRIMARYSURFACEALREADYEXISTS : // (564)
|
|
|
- return "DDERR_PRIMARYSURFACEALREADYEXISTS ";//: // (564)
|
|
|
- case DDERR_NOEMULATION : // (565)
|
|
|
- return "DDERR_NOEMULATION ";//: // (565)
|
|
|
- case DDERR_REGIONTOOSMALL : // (566)
|
|
|
- return "DDERR_REGIONTOOSMALL ";//: // (566)
|
|
|
- case DDERR_CLIPPERISUSINGHWND : // (567)
|
|
|
- return "DDERR_CLIPPERISUSINGHWND ";//: // (567)
|
|
|
- case DDERR_NOCLIPPERATTACHED : // (568)
|
|
|
- return "DDERR_NOCLIPPERATTACHED ";//: // (568)
|
|
|
- case DDERR_NOHWND : // (569)
|
|
|
- return "DDERR_NOHWND ";//: // (569)
|
|
|
- case DDERR_HWNDSUBCLASSED : // (570)
|
|
|
- return "DDERR_HWNDSUBCLASSED ";//: // (570)
|
|
|
- case DDERR_HWNDALREADYSET : // (571)
|
|
|
- return "DDERR_HWNDALREADYSET ";//: // (571)
|
|
|
- case DDERR_NOPALETTEATTACHED : // (572)
|
|
|
- return "DDERR_NOPALETTEATTACHED ";//: // (572)
|
|
|
- case DDERR_NOPALETTEHW : // (573)
|
|
|
- return "DDERR_NOPALETTEHW ";//: // (573)
|
|
|
- case DDERR_BLTFASTCANTCLIP : // (574)
|
|
|
- return "DDERR_BLTFASTCANTCLIP ";//: // (574)
|
|
|
- case DDERR_NOBLTHW : // (575)
|
|
|
- return "DDERR_NOBLTHW ";//: // (575)
|
|
|
- case DDERR_NODDROPSHW : // (576)
|
|
|
- return "DDERR_NODDROPSHW ";//: // (576)
|
|
|
- case DDERR_OVERLAYNOTVISIBLE : // (577)
|
|
|
- return "DDERR_OVERLAYNOTVISIBLE ";//: // (577)
|
|
|
- case DDERR_NOOVERLAYDEST : // (578)
|
|
|
- return "DDERR_NOOVERLAYDEST ";//: // (578)
|
|
|
- case DDERR_INVALIDPOSITION : // (579)
|
|
|
- return "DDERR_INVALIDPOSITION ";//: // (579)
|
|
|
- case DDERR_NOTAOVERLAYSURFACE : // (580)
|
|
|
- return "DDERR_NOTAOVERLAYSURFACE ";//: // (580)
|
|
|
- case DDERR_EXCLUSIVEMODEALREADYSET : // (581)
|
|
|
- return "DDERR_EXCLUSIVEMODEALREADYSET ";//: // (581)
|
|
|
- case DDERR_NOTFLIPPABLE : // (582)
|
|
|
- return "DDERR_NOTFLIPPABLE ";//: // (582)
|
|
|
- case DDERR_CANTDUPLICATE : // (583)
|
|
|
- return "DDERR_CANTDUPLICATE ";//: // (583)
|
|
|
- case DDERR_NOTLOCKED : // (584)
|
|
|
- return "DDERR_NOTLOCKED ";//: // (584)
|
|
|
- case DDERR_CANTCREATEDC : // (585)
|
|
|
- return "DDERR_CANTCREATEDC ";//: // (585)
|
|
|
- case DDERR_NODC : // (586)
|
|
|
- return "DDERR_NODC ";//: // (586)
|
|
|
- case DDERR_WRONGMODE : // (587)
|
|
|
- return "DDERR_WRONGMODE ";//: // (587)
|
|
|
- case DDERR_IMPLICITLYCREATED : // (588)
|
|
|
- return "DDERR_IMPLICITLYCREATED ";//: // (588)
|
|
|
- case DDERR_NOTPALETTIZED : // (589)
|
|
|
- return "DDERR_NOTPALETTIZED ";//: // (589)
|
|
|
- case DDERR_UNSUPPORTEDMODE : // (590)
|
|
|
- return "DDERR_UNSUPPORTEDMODE ";//: // (590)
|
|
|
- case DDERR_NOMIPMAPHW : // (591)
|
|
|
- return "DDERR_NOMIPMAPHW ";//: // (591)
|
|
|
- case DDERR_INVALIDSURFACETYPE : // (592)
|
|
|
- return "DDERR_INVALIDSURFACETYPE";//: // (592)
|
|
|
- case DDERR_NOOPTIMIZEHW : // (600)
|
|
|
- return "DDERR_NOOPTIMIZEHW";//: // (600)
|
|
|
- case DDERR_NOTLOADED : // (601)
|
|
|
- return "DDERR_NOTLOADED";//: // (601)
|
|
|
- case DDERR_NOFOCUSWINDOW : // (602)
|
|
|
- return "DDERR_NOFOCUSWINDOW";//: // (602)
|
|
|
- case DDERR_DCALREADYCREATED : // (620)
|
|
|
- return "DDERR_DCALREADYCREATED ";//: // (620)
|
|
|
- case DDERR_NONONLOCALVIDMEM : // (630)
|
|
|
- return "DDERR_NONONLOCALVIDMEM";//: // (630)
|
|
|
- case DDERR_CANTPAGELOCK : // (640)
|
|
|
- return "DDERR_CANTPAGELOCK ";//: // (640)
|
|
|
- case DDERR_CANTPAGEUNLOCK : // (660)
|
|
|
- return "DDERR_CANTPAGEUNLOCK ";//: // (660)
|
|
|
- case DDERR_NOTPAGELOCKED : // (680)
|
|
|
- return "DDERR_NOTPAGELOCKED ";//: // (680)
|
|
|
- case DDERR_MOREDATA : // (690)
|
|
|
- return "DDERR_MOREDATA ";//: // (690)
|
|
|
- case DDERR_VIDEONOTACTIVE : // (695)
|
|
|
- return "DDERR_VIDEONOTACTIVE ";//: // (695)
|
|
|
- case DDERR_DEVICEDOESNTOWNSURFACE : // (699)
|
|
|
- return "DDERR_DEVICEDOESNTOWNSURFACE ";//: // (699)
|
|
|
-
|
|
|
- case E_UNEXPECTED :
|
|
|
- return "E_UNEXPECTED ";
|
|
|
- case E_NOTIMPL :
|
|
|
- return "E_NOTIMPL ";
|
|
|
- case E_OUTOFMEMORY :
|
|
|
- return "E_OUTOFMEMORY ";
|
|
|
- case E_INVALIDARG :
|
|
|
- return "E_INVALIDARG or DDERR_INVALIDPARAMS";
|
|
|
- case E_NOINTERFACE :
|
|
|
- return "E_NOINTERFACE ";
|
|
|
- case E_POINTER :
|
|
|
- return "E_POINTER ";
|
|
|
- case E_HANDLE :
|
|
|
- return "E_HANDLE ";
|
|
|
- case E_ABORT :
|
|
|
- return "E_ABORT ";
|
|
|
-// case E_FAIL :
|
|
|
-// return "E_FAIL ";
|
|
|
- case E_ACCESSDENIED :
|
|
|
- return "E_ACCESSDENIED ";
|
|
|
- case E_PENDING :
|
|
|
- return "E_PENDING ";
|
|
|
- case CO_E_INIT_TLS :
|
|
|
- return "CO_E_INIT_TLS ";
|
|
|
- case CO_E_INIT_SHARED_ALLOCATOR :
|
|
|
- return "CO_E_INIT_SHARED_ALLOCATOR ";
|
|
|
- case CO_E_INIT_MEMORY_ALLOCATOR :
|
|
|
- return "CO_E_INIT_MEMORY_ALLOCATOR ";
|
|
|
- case CO_E_INIT_CLASS_CACHE :
|
|
|
- return "CO_E_INIT_CLASS_CACHE ";
|
|
|
- case CO_E_INIT_RPC_CHANNEL :
|
|
|
- return "CO_E_INIT_RPC_CHANNEL ";
|
|
|
- case CO_E_INIT_TLS_SET_CHANNEL_CONTROL :
|
|
|
- return "CO_E_INIT_TLS_SET_CHANNEL_CONTROL ";
|
|
|
- case CO_E_INIT_TLS_CHANNEL_CONTROL :
|
|
|
- return "CO_E_INIT_TLS_CHANNEL_CONTROL ";
|
|
|
- case CO_E_INIT_UNACCEPTED_USER_ALLOCATOR :
|
|
|
- return "CO_E_INIT_UNACCEPTED_USER_ALLOCATOR ";
|
|
|
- case CO_E_INIT_SCM_MUTEX_EXISTS :
|
|
|
- return "CO_E_INIT_SCM_MUTEX_EXISTS ";
|
|
|
- case CO_E_INIT_SCM_FILE_MAPPING_EXISTS :
|
|
|
- return "CO_E_INIT_SCM_FILE_MAPPING_EXISTS ";
|
|
|
- case CO_E_INIT_SCM_MAP_VIEW_OF_FILE :
|
|
|
- return "CO_E_INIT_SCM_MAP_VIEW_OF_FILE ";
|
|
|
- case CO_E_INIT_SCM_EXEC_FAILURE :
|
|
|
- return "CO_E_INIT_SCM_EXEC_FAILURE ";
|
|
|
- case CO_E_INIT_ONLY_SINGLE_THREADED :
|
|
|
- return "CO_E_INIT_ONLY_SINGLE_THREADED ";
|
|
|
- case CO_E_CANT_REMOTE :
|
|
|
- return "CO_E_CANT_REMOTE ";
|
|
|
- case CO_E_BAD_SERVER_NAME :
|
|
|
- return "CO_E_BAD_SERVER_NAME ";
|
|
|
- case CO_E_WRONG_SERVER_IDENTITY :
|
|
|
- return "CO_E_WRONG_SERVER_IDENTITY ";
|
|
|
- case CO_E_OLE1DDE_DISABLED :
|
|
|
- return "CO_E_OLE1DDE_DISABLED ";
|
|
|
- case CO_E_RUNAS_SYNTAX :
|
|
|
- return "CO_E_RUNAS_SYNTAX ";
|
|
|
- case CO_E_CREATEPROCESS_FAILURE :
|
|
|
- return "CO_E_CREATEPROCESS_FAILURE ";
|
|
|
- case CO_E_RUNAS_CREATEPROCESS_FAILURE :
|
|
|
- return "CO_E_RUNAS_CREATEPROCESS_FAILURE ";
|
|
|
- case CO_E_RUNAS_LOGON_FAILURE :
|
|
|
- return "CO_E_RUNAS_LOGON_FAILURE ";
|
|
|
- case CO_E_LAUNCH_PERMSSION_DENIED :
|
|
|
- return "CO_E_LAUNCH_PERMSSION_DENIED ";
|
|
|
- case CO_E_START_SERVICE_FAILURE :
|
|
|
- return "CO_E_START_SERVICE_FAILURE ";
|
|
|
- case CO_E_REMOTE_COMMUNICATION_FAILURE :
|
|
|
- return "CO_E_REMOTE_COMMUNICATION_FAILURE ";
|
|
|
- case CO_E_SERVER_START_TIMEOUT :
|
|
|
- return "CO_E_SERVER_START_TIMEOUT ";
|
|
|
- case CO_E_CLSREG_INCONSISTENT :
|
|
|
- return "CO_E_CLSREG_INCONSISTENT ";
|
|
|
- case CO_E_IIDREG_INCONSISTENT :
|
|
|
- return "CO_E_IIDREG_INCONSISTENT ";
|
|
|
- case CO_E_NOT_SUPPORTED :
|
|
|
- return "CO_E_NOT_SUPPORTED ";
|
|
|
- case CO_E_RELOAD_DLL :
|
|
|
- return "CO_E_RELOAD_DLL ";
|
|
|
- case CO_E_MSI_ERROR :
|
|
|
- return "CO_E_MSI_ERROR ";
|
|
|
- case OLE_E_OLEVERB :
|
|
|
- return "OLE_E_OLEVERB ";
|
|
|
- case OLE_E_ADVF :
|
|
|
- return "OLE_E_ADVF ";
|
|
|
- case OLE_E_ENUM_NOMORE :
|
|
|
- return "OLE_E_ENUM_NOMORE ";
|
|
|
- case OLE_E_ADVISENOTSUPPORTED :
|
|
|
- return "OLE_E_ADVISENOTSUPPORTED ";
|
|
|
- case OLE_E_NOCONNECTION :
|
|
|
- return "OLE_E_NOCONNECTION ";
|
|
|
- case OLE_E_NOTRUNNING :
|
|
|
- return "OLE_E_NOTRUNNING ";
|
|
|
- case OLE_E_NOCACHE :
|
|
|
- return "OLE_E_NOCACHE ";
|
|
|
- case OLE_E_BLANK :
|
|
|
- return "OLE_E_BLANK ";
|
|
|
- case OLE_E_CLASSDIFF :
|
|
|
- return "OLE_E_CLASSDIFF ";
|
|
|
- case OLE_E_CANT_GETMONIKER :
|
|
|
- return "OLE_E_CANT_GETMONIKER ";
|
|
|
- case OLE_E_CANT_BINDTOSOURCE :
|
|
|
- return "OLE_E_CANT_BINDTOSOURCE ";
|
|
|
- case OLE_E_STATIC :
|
|
|
- return "OLE_E_STATIC ";
|
|
|
- case OLE_E_PROMPTSAVECANCELLED :
|
|
|
- return "OLE_E_PROMPTSAVECANCELLED ";
|
|
|
- case OLE_E_INVALIDRECT :
|
|
|
- return "OLE_E_INVALIDRECT ";
|
|
|
- case OLE_E_WRONGCOMPOBJ :
|
|
|
- return "OLE_E_WRONGCOMPOBJ ";
|
|
|
- case OLE_E_INVALIDHWND :
|
|
|
- return "OLE_E_INVALIDHWND ";
|
|
|
- case OLE_E_NOT_INPLACEACTIVE :
|
|
|
- return "OLE_E_NOT_INPLACEACTIVE ";
|
|
|
- case OLE_E_CANTCONVERT :
|
|
|
- return "OLE_E_CANTCONVERT ";
|
|
|
- case OLE_E_NOSTORAGE :
|
|
|
- return "OLE_E_NOSTORAGE ";
|
|
|
- case DV_E_FORMATETC :
|
|
|
- return "DV_E_FORMATETC ";
|
|
|
- case DV_E_DVTARGETDEVICE :
|
|
|
- return "DV_E_DVTARGETDEVICE ";
|
|
|
- case DV_E_STGMEDIUM :
|
|
|
- return "DV_E_STGMEDIUM ";
|
|
|
- case DV_E_STATDATA :
|
|
|
- return "DV_E_STATDATA ";
|
|
|
- case DV_E_LINDEX :
|
|
|
- return "DV_E_LINDEX ";
|
|
|
- case DV_E_TYMED :
|
|
|
- return "DV_E_TYMED ";
|
|
|
- case DV_E_CLIPFORMAT :
|
|
|
- return "DV_E_CLIPFORMAT ";
|
|
|
- case DV_E_DVASPECT :
|
|
|
- return "DV_E_DVASPECT ";
|
|
|
- case DV_E_DVTARGETDEVICE_SIZE :
|
|
|
- return "DV_E_DVTARGETDEVICE_SIZE ";
|
|
|
- case DV_E_NOIVIEWOBJECT :
|
|
|
- return "DV_E_NOIVIEWOBJECT ";
|
|
|
- case DRAGDROP_E_NOTREGISTERED :
|
|
|
- return "DRAGDROP_E_NOTREGISTERED ";
|
|
|
- case DRAGDROP_E_ALREADYREGISTERED :
|
|
|
- return "DRAGDROP_E_ALREADYREGISTERED ";
|
|
|
- case DRAGDROP_E_INVALIDHWND :
|
|
|
- return "DRAGDROP_E_INVALIDHWND ";
|
|
|
- case CLASS_E_NOAGGREGATION :
|
|
|
- return "CLASS_E_NOAGGREGATION ";
|
|
|
- case CLASS_E_CLASSNOTAVAILABLE :
|
|
|
- return "CLASS_E_CLASSNOTAVAILABLE ";
|
|
|
- case CLASS_E_NOTLICENSED :
|
|
|
- return "CLASS_E_NOTLICENSED ";
|
|
|
- case VIEW_E_DRAW :
|
|
|
- return "VIEW_E_DRAW ";
|
|
|
- case REGDB_E_READREGDB :
|
|
|
- return "REGDB_E_READREGDB ";
|
|
|
- case REGDB_E_WRITEREGDB :
|
|
|
- return "REGDB_E_WRITEREGDB ";
|
|
|
- case REGDB_E_KEYMISSING :
|
|
|
- return "REGDB_E_KEYMISSING ";
|
|
|
- case REGDB_E_INVALIDVALUE :
|
|
|
- return "REGDB_E_INVALIDVALUE ";
|
|
|
- case REGDB_E_CLASSNOTREG :
|
|
|
- return "REGDB_E_CLASSNOTREG ";
|
|
|
- case REGDB_E_IIDNOTREG :
|
|
|
- return "REGDB_E_IIDNOTREG ";
|
|
|
- case CAT_E_CATIDNOEXIST :
|
|
|
- return "CAT_E_CATIDNOEXIST ";
|
|
|
- case CAT_E_NODESCRIPTION :
|
|
|
- return "CAT_E_NODESCRIPTION ";
|
|
|
- case CS_E_PACKAGE_NOTFOUND :
|
|
|
- return "CS_E_PACKAGE_NOTFOUND ";
|
|
|
- case CS_E_NOT_DELETABLE :
|
|
|
- return "CS_E_NOT_DELETABLE ";
|
|
|
- case CS_E_CLASS_NOTFOUND :
|
|
|
- return "CS_E_CLASS_NOTFOUND ";
|
|
|
- case CS_E_INVALID_VERSION :
|
|
|
- return "CS_E_INVALID_VERSION ";
|
|
|
- case CS_E_NO_CLASSSTORE :
|
|
|
- return "CS_E_NO_CLASSSTORE ";
|
|
|
- case CACHE_E_NOCACHE_UPDATED :
|
|
|
- return "CACHE_E_NOCACHE_UPDATED ";
|
|
|
- case OLEOBJ_E_NOVERBS :
|
|
|
- return "OLEOBJ_E_NOVERBS ";
|
|
|
- case OLEOBJ_E_INVALIDVERB :
|
|
|
- return "OLEOBJ_E_INVALIDVERB ";
|
|
|
- case INPLACE_E_NOTUNDOABLE :
|
|
|
- return "INPLACE_E_NOTUNDOABLE ";
|
|
|
- case INPLACE_E_NOTOOLSPACE :
|
|
|
- return "INPLACE_E_NOTOOLSPACE ";
|
|
|
- case CONVERT10_E_OLESTREAM_GET :
|
|
|
- return "CONVERT10_E_OLESTREAM_GET ";
|
|
|
- case CONVERT10_E_OLESTREAM_PUT :
|
|
|
- return "CONVERT10_E_OLESTREAM_PUT ";
|
|
|
- case CONVERT10_E_OLESTREAM_FMT :
|
|
|
- return "CONVERT10_E_OLESTREAM_FMT ";
|
|
|
- case CONVERT10_E_OLESTREAM_BITMAP_TO_DIB :
|
|
|
- return "CONVERT10_E_OLESTREAM_BITMAP_TO_DIB ";
|
|
|
- case CONVERT10_E_STG_FMT :
|
|
|
- return "CONVERT10_E_STG_FMT ";
|
|
|
- case CONVERT10_E_STG_NO_STD_STREAM :
|
|
|
- return "CONVERT10_E_STG_NO_STD_STREAM ";
|
|
|
- case CONVERT10_E_STG_DIB_TO_BITMAP :
|
|
|
- return "CONVERT10_E_STG_DIB_TO_BITMAP ";
|
|
|
- case CLIPBRD_E_CANT_OPEN :
|
|
|
- return "CLIPBRD_E_CANT_OPEN ";
|
|
|
- case CLIPBRD_E_CANT_EMPTY :
|
|
|
- return "CLIPBRD_E_CANT_EMPTY ";
|
|
|
- case CLIPBRD_E_CANT_SET :
|
|
|
- return "CLIPBRD_E_CANT_SET ";
|
|
|
- case CLIPBRD_E_BAD_DATA :
|
|
|
- return "CLIPBRD_E_BAD_DATA ";
|
|
|
- case CLIPBRD_E_CANT_CLOSE :
|
|
|
- return "CLIPBRD_E_CANT_CLOSE ";
|
|
|
- case MK_E_CONNECTMANUALLY :
|
|
|
- return "MK_E_CONNECTMANUALLY ";
|
|
|
- case MK_E_EXCEEDEDDEADLINE :
|
|
|
- return "MK_E_EXCEEDEDDEADLINE ";
|
|
|
- case MK_E_NEEDGENERIC :
|
|
|
- return "MK_E_NEEDGENERIC ";
|
|
|
- case MK_E_UNAVAILABLE :
|
|
|
- return "MK_E_UNAVAILABLE ";
|
|
|
- case MK_E_SYNTAX :
|
|
|
- return "MK_E_SYNTAX ";
|
|
|
- case MK_E_NOOBJECT :
|
|
|
- return "MK_E_NOOBJECT ";
|
|
|
- case MK_E_INVALIDEXTENSION :
|
|
|
- return "MK_E_INVALIDEXTENSION ";
|
|
|
- case MK_E_INTERMEDIATEINTERFACENOTSUPPORTED :
|
|
|
- return "MK_E_INTERMEDIATEINTERFACENOTSUPPORTED ";
|
|
|
- case MK_E_NOTBINDABLE :
|
|
|
- return "MK_E_NOTBINDABLE ";
|
|
|
- case MK_E_NOTBOUND :
|
|
|
- return "MK_E_NOTBOUND ";
|
|
|
- case MK_E_CANTOPENFILE :
|
|
|
- return "MK_E_CANTOPENFILE ";
|
|
|
- case MK_E_MUSTBOTHERUSER :
|
|
|
- return "MK_E_MUSTBOTHERUSER ";
|
|
|
- case MK_E_NOINVERSE :
|
|
|
- return "MK_E_NOINVERSE ";
|
|
|
- case MK_E_NOSTORAGE :
|
|
|
- return "MK_E_NOSTORAGE ";
|
|
|
- case MK_E_NOPREFIX :
|
|
|
- return "MK_E_NOPREFIX ";
|
|
|
- case MK_E_ENUMERATION_FAILED :
|
|
|
- return "MK_E_ENUMERATION_FAILED ";
|
|
|
- case CO_E_NOTINITIALIZED :
|
|
|
- return "CO_E_NOTINITIALIZED ";
|
|
|
- case CO_E_ALREADYINITIALIZED :
|
|
|
- return "CO_E_ALREADYINITIALIZED ";
|
|
|
- case CO_E_CANTDETERMINECLASS :
|
|
|
- return "CO_E_CANTDETERMINECLASS ";
|
|
|
- case CO_E_CLASSSTRING :
|
|
|
- return "CO_E_CLASSSTRING ";
|
|
|
- case CO_E_IIDSTRING :
|
|
|
- return "CO_E_IIDSTRING ";
|
|
|
- case CO_E_APPNOTFOUND :
|
|
|
- return "CO_E_APPNOTFOUND ";
|
|
|
- case CO_E_APPSINGLEUSE :
|
|
|
- return "CO_E_APPSINGLEUSE ";
|
|
|
- case CO_E_ERRORINAPP :
|
|
|
- return "CO_E_ERRORINAPP ";
|
|
|
- case CO_E_DLLNOTFOUND :
|
|
|
- return "CO_E_DLLNOTFOUND ";
|
|
|
- case CO_E_ERRORINDLL :
|
|
|
- return "CO_E_ERRORINDLL ";
|
|
|
- case CO_E_WRONGOSFORAPP :
|
|
|
- return "CO_E_WRONGOSFORAPP ";
|
|
|
- case CO_E_OBJNOTREG :
|
|
|
- return "CO_E_OBJNOTREG ";
|
|
|
- case CO_E_OBJISREG :
|
|
|
- return "CO_E_OBJISREG ";
|
|
|
- case CO_E_OBJNOTCONNECTED :
|
|
|
- return "CO_E_OBJNOTCONNECTED ";
|
|
|
- case CO_E_APPDIDNTREG :
|
|
|
- return "CO_E_APPDIDNTREG ";
|
|
|
- case CO_E_RELEASED :
|
|
|
- return "CO_E_RELEASED ";
|
|
|
- case CO_E_FAILEDTOIMPERSONATE :
|
|
|
- return "CO_E_FAILEDTOIMPERSONATE ";
|
|
|
- case CO_E_FAILEDTOGETSECCTX :
|
|
|
- return "CO_E_FAILEDTOGETSECCTX ";
|
|
|
- case CO_E_FAILEDTOOPENTHREADTOKEN :
|
|
|
- return "CO_E_FAILEDTOOPENTHREADTOKEN ";
|
|
|
- case CO_E_FAILEDTOGETTOKENINFO :
|
|
|
- return "CO_E_FAILEDTOGETTOKENINFO ";
|
|
|
- case CO_E_TRUSTEEDOESNTMATCHCLIENT :
|
|
|
- return "CO_E_TRUSTEEDOESNTMATCHCLIENT ";
|
|
|
- case CO_E_FAILEDTOQUERYCLIENTBLANKET :
|
|
|
- return "CO_E_FAILEDTOQUERYCLIENTBLANKET ";
|
|
|
- case CO_E_FAILEDTOSETDACL :
|
|
|
- return "CO_E_FAILEDTOSETDACL ";
|
|
|
- case CO_E_ACCESSCHECKFAILED :
|
|
|
- return "CO_E_ACCESSCHECKFAILED ";
|
|
|
- case CO_E_NETACCESSAPIFAILED :
|
|
|
- return "CO_E_NETACCESSAPIFAILED ";
|
|
|
- case CO_E_WRONGTRUSTEENAMESYNTAX :
|
|
|
- return "CO_E_WRONGTRUSTEENAMESYNTAX ";
|
|
|
- case CO_E_INVALIDSID :
|
|
|
- return "CO_E_INVALIDSID ";
|
|
|
- case CO_E_CONVERSIONFAILED :
|
|
|
- return "CO_E_CONVERSIONFAILED ";
|
|
|
- case CO_E_NOMATCHINGSIDFOUND :
|
|
|
- return "CO_E_NOMATCHINGSIDFOUND ";
|
|
|
- case CO_E_LOOKUPACCSIDFAILED :
|
|
|
- return "CO_E_LOOKUPACCSIDFAILED ";
|
|
|
- case CO_E_NOMATCHINGNAMEFOUND :
|
|
|
- return "CO_E_NOMATCHINGNAMEFOUND ";
|
|
|
- case CO_E_LOOKUPACCNAMEFAILED :
|
|
|
- return "CO_E_LOOKUPACCNAMEFAILED ";
|
|
|
- case CO_E_SETSERLHNDLFAILED :
|
|
|
- return "CO_E_SETSERLHNDLFAILED ";
|
|
|
- case CO_E_FAILEDTOGETWINDIR :
|
|
|
- return "CO_E_FAILEDTOGETWINDIR ";
|
|
|
- case CO_E_PATHTOOLONG :
|
|
|
- return "CO_E_PATHTOOLONG ";
|
|
|
- case CO_E_FAILEDTOGENUUID :
|
|
|
- return "CO_E_FAILEDTOGENUUID ";
|
|
|
- case CO_E_FAILEDTOCREATEFILE :
|
|
|
- return "CO_E_FAILEDTOCREATEFILE ";
|
|
|
- case CO_E_FAILEDTOCLOSEHANDLE :
|
|
|
- return "CO_E_FAILEDTOCLOSEHANDLE ";
|
|
|
- case CO_E_EXCEEDSYSACLLIMIT :
|
|
|
- return "CO_E_EXCEEDSYSACLLIMIT ";
|
|
|
- case CO_E_ACESINWRONGORDER :
|
|
|
- return "CO_E_ACESINWRONGORDER ";
|
|
|
- case CO_E_INCOMPATIBLESTREAMVERSION :
|
|
|
- return "CO_E_INCOMPATIBLESTREAMVERSION ";
|
|
|
- case CO_E_FAILEDTOOPENPROCESSTOKEN :
|
|
|
- return "CO_E_FAILEDTOOPENPROCESSTOKEN ";
|
|
|
- case CO_E_DECODEFAILED :
|
|
|
- return "CO_E_DECODEFAILED ";
|
|
|
- case CO_E_ACNOTINITIALIZED :
|
|
|
- return "CO_E_ACNOTINITIALIZED ";
|
|
|
- case OLE_S_USEREG :
|
|
|
- return "OLE_S_USEREG ";
|
|
|
- case OLE_S_STATIC :
|
|
|
- return "OLE_S_STATIC ";
|
|
|
- case OLE_S_MAC_CLIPFORMAT :
|
|
|
- return "OLE_S_MAC_CLIPFORMAT ";
|
|
|
- case DRAGDROP_S_DROP :
|
|
|
- return "DRAGDROP_S_DROP ";
|
|
|
- case DRAGDROP_S_CANCEL :
|
|
|
- return "DRAGDROP_S_CANCEL ";
|
|
|
- case DRAGDROP_S_USEDEFAULTCURSORS :
|
|
|
- return "DRAGDROP_S_USEDEFAULTCURSORS ";
|
|
|
- case DATA_S_SAMEFORMATETC :
|
|
|
- return "DATA_S_SAMEFORMATETC ";
|
|
|
- case VIEW_S_ALREADY_FROZEN :
|
|
|
- return "VIEW_S_ALREADY_FROZEN ";
|
|
|
- case CACHE_S_FORMATETC_NOTSUPPORTED :
|
|
|
- return "CACHE_S_FORMATETC_NOTSUPPORTED ";
|
|
|
- case CACHE_S_SAMECACHE :
|
|
|
- return "CACHE_S_SAMECACHE ";
|
|
|
- case CACHE_S_SOMECACHES_NOTUPDATED :
|
|
|
- return "CACHE_S_SOMECACHES_NOTUPDATED ";
|
|
|
- case OLEOBJ_S_INVALIDVERB :
|
|
|
- return "OLEOBJ_S_INVALIDVERB ";
|
|
|
- case OLEOBJ_S_CANNOT_DOVERB_NOW :
|
|
|
- return "OLEOBJ_S_CANNOT_DOVERB_NOW ";
|
|
|
- case OLEOBJ_S_INVALIDHWND :
|
|
|
- return "OLEOBJ_S_INVALIDHWND ";
|
|
|
- case INPLACE_S_TRUNCATED :
|
|
|
- return "INPLACE_S_TRUNCATED ";
|
|
|
- case CONVERT10_S_NO_PRESENTATION :
|
|
|
- return "CONVERT10_S_NO_PRESENTATION ";
|
|
|
- case MK_S_REDUCED_TO_SELF :
|
|
|
- return "MK_S_REDUCED_TO_SELF ";
|
|
|
- case MK_S_ME :
|
|
|
- return "MK_S_ME ";
|
|
|
- case MK_S_HIM :
|
|
|
- return "MK_S_HIM ";
|
|
|
- case MK_S_US :
|
|
|
- return "MK_S_US ";
|
|
|
- case MK_S_MONIKERALREADYREGISTERED :
|
|
|
- return "MK_S_MONIKERALREADYREGISTERED ";
|
|
|
- case CO_E_CLASS_CREATE_FAILED :
|
|
|
- return "CO_E_CLASS_CREATE_FAILED ";
|
|
|
- case CO_E_SCM_ERROR :
|
|
|
- return "CO_E_SCM_ERROR ";
|
|
|
- case CO_E_SCM_RPC_FAILURE :
|
|
|
- return "CO_E_SCM_RPC_FAILURE ";
|
|
|
- case CO_E_BAD_PATH :
|
|
|
- return "CO_E_BAD_PATH ";
|
|
|
- case CO_E_SERVER_EXEC_FAILURE :
|
|
|
- return "CO_E_SERVER_EXEC_FAILURE ";
|
|
|
- case CO_E_OBJSRV_RPC_FAILURE :
|
|
|
- return "CO_E_OBJSRV_RPC_FAILURE ";
|
|
|
- case MK_E_NO_NORMALIZED :
|
|
|
- return "MK_E_NO_NORMALIZED ";
|
|
|
- case CO_E_SERVER_STOPPING :
|
|
|
- return "CO_E_SERVER_STOPPING ";
|
|
|
- case MEM_E_INVALID_ROOT :
|
|
|
- return "MEM_E_INVALID_ROOT ";
|
|
|
- case MEM_E_INVALID_LINK :
|
|
|
- return "MEM_E_INVALID_LINK ";
|
|
|
- case MEM_E_INVALID_SIZE :
|
|
|
- return "MEM_E_INVALID_SIZE ";
|
|
|
- case CO_S_NOTALLINTERFACES :
|
|
|
- return "CO_S_NOTALLINTERFACES ";
|
|
|
- case DISP_E_UNKNOWNINTERFACE :
|
|
|
- return "DISP_E_UNKNOWNINTERFACE ";
|
|
|
- case DISP_E_MEMBERNOTFOUND :
|
|
|
- return "DISP_E_MEMBERNOTFOUND ";
|
|
|
- case DISP_E_PARAMNOTFOUND :
|
|
|
- return "DISP_E_PARAMNOTFOUND ";
|
|
|
- case DISP_E_TYPEMISMATCH :
|
|
|
- return "DISP_E_TYPEMISMATCH ";
|
|
|
- case DISP_E_UNKNOWNNAME :
|
|
|
- return "DISP_E_UNKNOWNNAME ";
|
|
|
- case DISP_E_NONAMEDARGS :
|
|
|
- return "DISP_E_NONAMEDARGS ";
|
|
|
- case DISP_E_BADVARTYPE :
|
|
|
- return "DISP_E_BADVARTYPE ";
|
|
|
- case DISP_E_EXCEPTION :
|
|
|
- return "DISP_E_EXCEPTION ";
|
|
|
- case DISP_E_OVERFLOW :
|
|
|
- return "DISP_E_OVERFLOW ";
|
|
|
- case DISP_E_BADINDEX :
|
|
|
- return "DISP_E_BADINDEX ";
|
|
|
- case DISP_E_UNKNOWNLCID :
|
|
|
- return "DISP_E_UNKNOWNLCID ";
|
|
|
- case DISP_E_ARRAYISLOCKED :
|
|
|
- return "DISP_E_ARRAYISLOCKED ";
|
|
|
- case DISP_E_BADPARAMCOUNT :
|
|
|
- return "DISP_E_BADPARAMCOUNT ";
|
|
|
- case DISP_E_PARAMNOTOPTIONAL :
|
|
|
- return "DISP_E_PARAMNOTOPTIONAL ";
|
|
|
- case DISP_E_BADCALLEE :
|
|
|
- return "DISP_E_BADCALLEE ";
|
|
|
- case DISP_E_NOTACOLLECTION :
|
|
|
- return "DISP_E_NOTACOLLECTION ";
|
|
|
- case DISP_E_DIVBYZERO :
|
|
|
- return "DISP_E_DIVBYZERO ";
|
|
|
- case TYPE_E_BUFFERTOOSMALL :
|
|
|
- return "TYPE_E_BUFFERTOOSMALL ";
|
|
|
- case TYPE_E_FIELDNOTFOUND :
|
|
|
- return "TYPE_E_FIELDNOTFOUND ";
|
|
|
- case TYPE_E_INVDATAREAD :
|
|
|
- return "TYPE_E_INVDATAREAD ";
|
|
|
- case TYPE_E_UNSUPFORMAT :
|
|
|
- return "TYPE_E_UNSUPFORMAT ";
|
|
|
- case TYPE_E_REGISTRYACCESS :
|
|
|
- return "TYPE_E_REGISTRYACCESS ";
|
|
|
- case TYPE_E_LIBNOTREGISTERED :
|
|
|
- return "TYPE_E_LIBNOTREGISTERED ";
|
|
|
- case TYPE_E_UNDEFINEDTYPE :
|
|
|
- return "TYPE_E_UNDEFINEDTYPE ";
|
|
|
- case TYPE_E_QUALIFIEDNAMEDISALLOWED :
|
|
|
- return "TYPE_E_QUALIFIEDNAMEDISALLOWED ";
|
|
|
- case TYPE_E_INVALIDSTATE :
|
|
|
- return "TYPE_E_INVALIDSTATE ";
|
|
|
- case TYPE_E_WRONGTYPEKIND :
|
|
|
- return "TYPE_E_WRONGTYPEKIND ";
|
|
|
- case TYPE_E_ELEMENTNOTFOUND :
|
|
|
- return "TYPE_E_ELEMENTNOTFOUND ";
|
|
|
- case TYPE_E_AMBIGUOUSNAME :
|
|
|
- return "TYPE_E_AMBIGUOUSNAME ";
|
|
|
- case TYPE_E_NAMECONFLICT :
|
|
|
- return "TYPE_E_NAMECONFLICT ";
|
|
|
- case TYPE_E_UNKNOWNLCID :
|
|
|
- return "TYPE_E_UNKNOWNLCID ";
|
|
|
- case TYPE_E_DLLFUNCTIONNOTFOUND :
|
|
|
- return "TYPE_E_DLLFUNCTIONNOTFOUND ";
|
|
|
- case TYPE_E_BADMODULEKIND :
|
|
|
- return "TYPE_E_BADMODULEKIND ";
|
|
|
- case TYPE_E_SIZETOOBIG :
|
|
|
- return "TYPE_E_SIZETOOBIG ";
|
|
|
- case TYPE_E_DUPLICATEID :
|
|
|
- return "TYPE_E_DUPLICATEID ";
|
|
|
- case TYPE_E_INVALIDID :
|
|
|
- return "TYPE_E_INVALIDID ";
|
|
|
- case TYPE_E_TYPEMISMATCH :
|
|
|
- return "TYPE_E_TYPEMISMATCH ";
|
|
|
- case TYPE_E_OUTOFBOUNDS :
|
|
|
- return "TYPE_E_OUTOFBOUNDS ";
|
|
|
- case TYPE_E_IOERROR :
|
|
|
- return "TYPE_E_IOERROR ";
|
|
|
- case TYPE_E_CANTCREATETMPFILE :
|
|
|
- return "TYPE_E_CANTCREATETMPFILE ";
|
|
|
- case TYPE_E_CANTLOADLIBRARY :
|
|
|
- return "TYPE_E_CANTLOADLIBRARY ";
|
|
|
- case TYPE_E_INCONSISTENTPROPFUNCS :
|
|
|
- return "TYPE_E_INCONSISTENTPROPFUNCS ";
|
|
|
- case TYPE_E_CIRCULARTYPE :
|
|
|
- return "TYPE_E_CIRCULARTYPE ";
|
|
|
- case STG_E_INVALIDFUNCTION :
|
|
|
- return "STG_E_INVALIDFUNCTION ";
|
|
|
- case STG_E_FILENOTFOUND :
|
|
|
- return "STG_E_FILENOTFOUND ";
|
|
|
- case STG_E_PATHNOTFOUND :
|
|
|
- return "STG_E_PATHNOTFOUND ";
|
|
|
- case STG_E_TOOMANYOPENFILES :
|
|
|
- return "STG_E_TOOMANYOPENFILES ";
|
|
|
- case STG_E_ACCESSDENIED :
|
|
|
- return "STG_E_ACCESSDENIED ";
|
|
|
- case STG_E_INVALIDHANDLE :
|
|
|
- return "STG_E_INVALIDHANDLE ";
|
|
|
- case STG_E_INSUFFICIENTMEMORY :
|
|
|
- return "STG_E_INSUFFICIENTMEMORY ";
|
|
|
- case STG_E_INVALIDPOINTER :
|
|
|
- return "STG_E_INVALIDPOINTER ";
|
|
|
- case STG_E_NOMOREFILES :
|
|
|
- return "STG_E_NOMOREFILES ";
|
|
|
- case STG_E_DISKISWRITEPROTECTED :
|
|
|
- return "STG_E_DISKISWRITEPROTECTED ";
|
|
|
- case STG_E_SEEKERROR :
|
|
|
- return "STG_E_SEEKERROR ";
|
|
|
- case STG_E_WRITEFAULT :
|
|
|
- return "STG_E_WRITEFAULT ";
|
|
|
- case STG_E_READFAULT :
|
|
|
- return "STG_E_READFAULT ";
|
|
|
- case STG_E_SHAREVIOLATION :
|
|
|
- return "STG_E_SHAREVIOLATION ";
|
|
|
- case STG_E_LOCKVIOLATION :
|
|
|
- return "STG_E_LOCKVIOLATION ";
|
|
|
- case STG_E_FILEALREADYEXISTS :
|
|
|
- return "STG_E_FILEALREADYEXISTS ";
|
|
|
- case STG_E_INVALIDPARAMETER :
|
|
|
- return "STG_E_INVALIDPARAMETER ";
|
|
|
- case STG_E_MEDIUMFULL :
|
|
|
- return "STG_E_MEDIUMFULL ";
|
|
|
- case STG_E_PROPSETMISMATCHED :
|
|
|
- return "STG_E_PROPSETMISMATCHED ";
|
|
|
- case STG_E_ABNORMALAPIEXIT :
|
|
|
- return "STG_E_ABNORMALAPIEXIT ";
|
|
|
- case STG_E_INVALIDHEADER :
|
|
|
- return "STG_E_INVALIDHEADER ";
|
|
|
- case STG_E_INVALIDNAME :
|
|
|
- return "STG_E_INVALIDNAME ";
|
|
|
- case STG_E_UNKNOWN :
|
|
|
- return "STG_E_UNKNOWN ";
|
|
|
- case STG_E_UNIMPLEMENTEDFUNCTION :
|
|
|
- return "STG_E_UNIMPLEMENTEDFUNCTION ";
|
|
|
- case STG_E_INVALIDFLAG :
|
|
|
- return "STG_E_INVALIDFLAG ";
|
|
|
- case STG_E_INUSE :
|
|
|
- return "STG_E_INUSE ";
|
|
|
- case STG_E_NOTCURRENT :
|
|
|
- return "STG_E_NOTCURRENT ";
|
|
|
- case STG_E_REVERTED :
|
|
|
- return "STG_E_REVERTED ";
|
|
|
- case STG_E_CANTSAVE :
|
|
|
- return "STG_E_CANTSAVE ";
|
|
|
- case STG_E_OLDFORMAT :
|
|
|
- return "STG_E_OLDFORMAT ";
|
|
|
- case STG_E_OLDDLL :
|
|
|
- return "STG_E_OLDDLL ";
|
|
|
- case STG_E_SHAREREQUIRED :
|
|
|
- return "STG_E_SHAREREQUIRED ";
|
|
|
- case STG_E_NOTFILEBASEDSTORAGE :
|
|
|
- return "STG_E_NOTFILEBASEDSTORAGE ";
|
|
|
- case STG_E_EXTANTMARSHALLINGS :
|
|
|
- return "STG_E_EXTANTMARSHALLINGS ";
|
|
|
- case STG_E_DOCFILECORRUPT :
|
|
|
- return "STG_E_DOCFILECORRUPT ";
|
|
|
- case STG_E_BADBASEADDRESS :
|
|
|
- return "STG_E_BADBASEADDRESS ";
|
|
|
- case STG_E_INCOMPLETE :
|
|
|
- return "STG_E_INCOMPLETE ";
|
|
|
- case STG_E_TERMINATED :
|
|
|
- return "STG_E_TERMINATED ";
|
|
|
- case STG_S_CONVERTED :
|
|
|
- return "STG_S_CONVERTED ";
|
|
|
- case STG_S_BLOCK :
|
|
|
- return "STG_S_BLOCK ";
|
|
|
- case STG_S_RETRYNOW :
|
|
|
- return "STG_S_RETRYNOW ";
|
|
|
- case STG_S_MONITORING :
|
|
|
- return "STG_S_MONITORING ";
|
|
|
- case STG_S_MULTIPLEOPENS :
|
|
|
- return "STG_S_MULTIPLEOPENS ";
|
|
|
- case STG_S_CONSOLIDATIONFAILED :
|
|
|
- return "STG_S_CONSOLIDATIONFAILED ";
|
|
|
- case STG_S_CANNOTCONSOLIDATE :
|
|
|
- return "STG_S_CANNOTCONSOLIDATE ";
|
|
|
- case RPC_E_CALL_REJECTED :
|
|
|
- return "RPC_E_CALL_REJECTED ";
|
|
|
- case RPC_E_CALL_CANCELED :
|
|
|
- return "RPC_E_CALL_CANCELED ";
|
|
|
- case RPC_E_CANTPOST_INSENDCALL :
|
|
|
- return "RPC_E_CANTPOST_INSENDCALL ";
|
|
|
- case RPC_E_CANTCALLOUT_INASYNCCALL :
|
|
|
- return "RPC_E_CANTCALLOUT_INASYNCCALL ";
|
|
|
- case RPC_E_CANTCALLOUT_INEXTERNALCALL :
|
|
|
- return "RPC_E_CANTCALLOUT_INEXTERNALCALL ";
|
|
|
- case RPC_E_CONNECTION_TERMINATED :
|
|
|
- return "RPC_E_CONNECTION_TERMINATED ";
|
|
|
- case RPC_E_SERVER_DIED :
|
|
|
- return "RPC_E_SERVER_DIED ";
|
|
|
- case RPC_E_CLIENT_DIED :
|
|
|
- return "RPC_E_CLIENT_DIED ";
|
|
|
- case RPC_E_INVALID_DATAPACKET :
|
|
|
- return "RPC_E_INVALID_DATAPACKET ";
|
|
|
- case RPC_E_CANTTRANSMIT_CALL :
|
|
|
- return "RPC_E_CANTTRANSMIT_CALL ";
|
|
|
- case RPC_E_CLIENT_CANTMARSHAL_DATA :
|
|
|
- return "RPC_E_CLIENT_CANTMARSHAL_DATA ";
|
|
|
- case RPC_E_CLIENT_CANTUNMARSHAL_DATA :
|
|
|
- return "RPC_E_CLIENT_CANTUNMARSHAL_DATA ";
|
|
|
- case RPC_E_SERVER_CANTMARSHAL_DATA :
|
|
|
- return "RPC_E_SERVER_CANTMARSHAL_DATA ";
|
|
|
- case RPC_E_SERVER_CANTUNMARSHAL_DATA :
|
|
|
- return "RPC_E_SERVER_CANTUNMARSHAL_DATA ";
|
|
|
- case RPC_E_INVALID_DATA :
|
|
|
- return "RPC_E_INVALID_DATA ";
|
|
|
- case RPC_E_INVALID_PARAMETER :
|
|
|
- return "RPC_E_INVALID_PARAMETER ";
|
|
|
- case RPC_E_CANTCALLOUT_AGAIN :
|
|
|
- return "RPC_E_CANTCALLOUT_AGAIN ";
|
|
|
- case RPC_E_SERVER_DIED_DNE :
|
|
|
- return "RPC_E_SERVER_DIED_DNE ";
|
|
|
- case RPC_E_SYS_CALL_FAILED :
|
|
|
- return "RPC_E_SYS_CALL_FAILED ";
|
|
|
- case RPC_E_OUT_OF_RESOURCES :
|
|
|
- return "RPC_E_OUT_OF_RESOURCES ";
|
|
|
- case RPC_E_ATTEMPTED_MULTITHREAD :
|
|
|
- return "RPC_E_ATTEMPTED_MULTITHREAD ";
|
|
|
- case RPC_E_NOT_REGISTERED :
|
|
|
- return "RPC_E_NOT_REGISTERED ";
|
|
|
- case RPC_E_FAULT :
|
|
|
- return "RPC_E_FAULT ";
|
|
|
- case RPC_E_SERVERFAULT :
|
|
|
- return "RPC_E_SERVERFAULT ";
|
|
|
- case RPC_E_CHANGED_MODE :
|
|
|
- return "RPC_E_CHANGED_MODE ";
|
|
|
- case RPC_E_INVALIDMETHOD :
|
|
|
- return "RPC_E_INVALIDMETHOD ";
|
|
|
- case RPC_E_DISCONNECTED :
|
|
|
- return "RPC_E_DISCONNECTED ";
|
|
|
- case RPC_E_RETRY :
|
|
|
- return "RPC_E_RETRY ";
|
|
|
- case RPC_E_SERVERCALL_RETRYLATER :
|
|
|
- return "RPC_E_SERVERCALL_RETRYLATER ";
|
|
|
- case RPC_E_SERVERCALL_REJECTED :
|
|
|
- return "RPC_E_SERVERCALL_REJECTED ";
|
|
|
- case RPC_E_INVALID_CALLDATA :
|
|
|
- return "RPC_E_INVALID_CALLDATA ";
|
|
|
- case RPC_E_CANTCALLOUT_ININPUTSYNCCALL :
|
|
|
- return "RPC_E_CANTCALLOUT_ININPUTSYNCCALL ";
|
|
|
- case RPC_E_WRONG_THREAD :
|
|
|
- return "RPC_E_WRONG_THREAD ";
|
|
|
- case RPC_E_THREAD_NOT_INIT :
|
|
|
- return "RPC_E_THREAD_NOT_INIT ";
|
|
|
- case RPC_E_VERSION_MISMATCH :
|
|
|
- return "RPC_E_VERSION_MISMATCH ";
|
|
|
- case RPC_E_INVALID_HEADER :
|
|
|
- return "RPC_E_INVALID_HEADER ";
|
|
|
- case RPC_E_INVALID_EXTENSION :
|
|
|
- return "RPC_E_INVALID_EXTENSION ";
|
|
|
- case RPC_E_INVALID_IPID :
|
|
|
- return "RPC_E_INVALID_IPID ";
|
|
|
- case RPC_E_INVALID_OBJECT :
|
|
|
- return "RPC_E_INVALID_OBJECT ";
|
|
|
- case RPC_S_CALLPENDING :
|
|
|
- return "RPC_S_CALLPENDING ";
|
|
|
- case RPC_S_WAITONTIMER :
|
|
|
- return "RPC_S_WAITONTIMER ";
|
|
|
- case RPC_E_CALL_COMPLETE :
|
|
|
- return "RPC_E_CALL_COMPLETE ";
|
|
|
- case RPC_E_UNSECURE_CALL :
|
|
|
- return "RPC_E_UNSECURE_CALL ";
|
|
|
- case RPC_E_TOO_LATE :
|
|
|
- return "RPC_E_TOO_LATE ";
|
|
|
- case RPC_E_NO_GOOD_SECURITY_PACKAGES :
|
|
|
- return "RPC_E_NO_GOOD_SECURITY_PACKAGES ";
|
|
|
- case RPC_E_ACCESS_DENIED :
|
|
|
- return "RPC_E_ACCESS_DENIED ";
|
|
|
- case RPC_E_REMOTE_DISABLED :
|
|
|
- return "RPC_E_REMOTE_DISABLED ";
|
|
|
- case RPC_E_INVALID_OBJREF :
|
|
|
- return "RPC_E_INVALID_OBJREF ";
|
|
|
- case RPC_E_NO_CONTEXT :
|
|
|
- return "RPC_E_NO_CONTEXT ";
|
|
|
- case RPC_E_TIMEOUT :
|
|
|
- return "RPC_E_TIMEOUT ";
|
|
|
- case RPC_E_NO_SYNC :
|
|
|
- return "RPC_E_NO_SYNC ";
|
|
|
- case RPC_E_UNEXPECTED :
|
|
|
- return "RPC_E_UNEXPECTED ";
|
|
|
- case NTE_BAD_UID :
|
|
|
- return "NTE_BAD_UID ";
|
|
|
- case NTE_BAD_HASH :
|
|
|
- return "NTE_BAD_HASH ";
|
|
|
- //case NTE_BAD_HASH :
|
|
|
- //return "NTE_BAD_HASH ";
|
|
|
- case NTE_BAD_KEY :
|
|
|
- return "NTE_BAD_KEY ";
|
|
|
- case NTE_BAD_LEN :
|
|
|
- return "NTE_BAD_LEN ";
|
|
|
- case NTE_BAD_DATA :
|
|
|
- return "NTE_BAD_DATA ";
|
|
|
- case NTE_BAD_SIGNATURE :
|
|
|
- return "NTE_BAD_SIGNATURE ";
|
|
|
- case NTE_BAD_VER :
|
|
|
- return "NTE_BAD_VER ";
|
|
|
- case NTE_BAD_ALGID :
|
|
|
- return "NTE_BAD_ALGID ";
|
|
|
- case NTE_BAD_FLAGS :
|
|
|
- return "NTE_BAD_FLAGS ";
|
|
|
- case NTE_BAD_TYPE :
|
|
|
- return "NTE_BAD_TYPE ";
|
|
|
- case NTE_BAD_KEY_STATE :
|
|
|
- return "NTE_BAD_KEY_STATE ";
|
|
|
- case NTE_BAD_HASH_STATE :
|
|
|
- return "NTE_BAD_HASH_STATE ";
|
|
|
- case NTE_NO_KEY :
|
|
|
- return "NTE_NO_KEY ";
|
|
|
- case NTE_NO_MEMORY :
|
|
|
- return "NTE_NO_MEMORY ";
|
|
|
- case NTE_EXISTS :
|
|
|
- return "NTE_EXISTS ";
|
|
|
- case NTE_PERM :
|
|
|
- return "NTE_PERM ";
|
|
|
- case NTE_NOT_FOUND :
|
|
|
- return "NTE_NOT_FOUND ";
|
|
|
- case NTE_DOUBLE_ENCRYPT :
|
|
|
- return "NTE_DOUBLE_ENCRYPT ";
|
|
|
- case NTE_BAD_PROVIDER :
|
|
|
- return "NTE_BAD_PROVIDER ";
|
|
|
- case NTE_BAD_PROV_TYPE :
|
|
|
- return "NTE_BAD_PROV_TYPE ";
|
|
|
- case NTE_BAD_PUBLIC_KEY :
|
|
|
- return "NTE_BAD_PUBLIC_KEY ";
|
|
|
- case NTE_BAD_KEYSET :
|
|
|
- return "NTE_BAD_KEYSET ";
|
|
|
- case NTE_PROV_TYPE_NOT_DEF :
|
|
|
- return "NTE_PROV_TYPE_NOT_DEF ";
|
|
|
- case NTE_PROV_TYPE_ENTRY_BAD :
|
|
|
- return "NTE_PROV_TYPE_ENTRY_BAD ";
|
|
|
- case NTE_KEYSET_NOT_DEF :
|
|
|
- return "NTE_KEYSET_NOT_DEF ";
|
|
|
- case NTE_KEYSET_ENTRY_BAD :
|
|
|
- return "NTE_KEYSET_ENTRY_BAD ";
|
|
|
- case NTE_PROV_TYPE_NO_MATCH :
|
|
|
- return "NTE_PROV_TYPE_NO_MATCH ";
|
|
|
- case NTE_SIGNATURE_FILE_BAD :
|
|
|
- return "NTE_SIGNATURE_FILE_BAD ";
|
|
|
- case NTE_PROVIDER_DLL_FAIL :
|
|
|
- return "NTE_PROVIDER_DLL_FAIL ";
|
|
|
- case NTE_PROV_DLL_NOT_FOUND :
|
|
|
- return "NTE_PROV_DLL_NOT_FOUND ";
|
|
|
- case NTE_BAD_KEYSET_PARAM :
|
|
|
- return "NTE_BAD_KEYSET_PARAM ";
|
|
|
- case NTE_FAIL :
|
|
|
- return "NTE_FAIL ";
|
|
|
- case NTE_SYS_ERR :
|
|
|
- return "NTE_SYS_ERR ";
|
|
|
- case CRYPT_E_MSG_ERROR :
|
|
|
- return "CRYPT_E_MSG_ERROR ";
|
|
|
- case CRYPT_E_UNKNOWN_ALGO :
|
|
|
- return "CRYPT_E_UNKNOWN_ALGO ";
|
|
|
- case CRYPT_E_OID_FORMAT :
|
|
|
- return "CRYPT_E_OID_FORMAT ";
|
|
|
- case CRYPT_E_INVALID_MSG_TYPE :
|
|
|
- return "CRYPT_E_INVALID_MSG_TYPE ";
|
|
|
- case CRYPT_E_UNEXPECTED_ENCODING :
|
|
|
- return "CRYPT_E_UNEXPECTED_ENCODING ";
|
|
|
- case CRYPT_E_AUTH_ATTR_MISSING :
|
|
|
- return "CRYPT_E_AUTH_ATTR_MISSING ";
|
|
|
- case CRYPT_E_HASH_VALUE :
|
|
|
- return "CRYPT_E_HASH_VALUE ";
|
|
|
- case CRYPT_E_INVALID_INDEX :
|
|
|
- return "CRYPT_E_INVALID_INDEX ";
|
|
|
- case CRYPT_E_ALREADY_DECRYPTED :
|
|
|
- return "CRYPT_E_ALREADY_DECRYPTED ";
|
|
|
- case CRYPT_E_NOT_DECRYPTED :
|
|
|
- return "CRYPT_E_NOT_DECRYPTED ";
|
|
|
- case CRYPT_E_RECIPIENT_NOT_FOUND :
|
|
|
- return "CRYPT_E_RECIPIENT_NOT_FOUND ";
|
|
|
- case CRYPT_E_CONTROL_TYPE :
|
|
|
- return "CRYPT_E_CONTROL_TYPE ";
|
|
|
- case CRYPT_E_ISSUER_SERIALNUMBER :
|
|
|
- return "CRYPT_E_ISSUER_SERIALNUMBER ";
|
|
|
- case CRYPT_E_SIGNER_NOT_FOUND :
|
|
|
- return "CRYPT_E_SIGNER_NOT_FOUND ";
|
|
|
- case CRYPT_E_ATTRIBUTES_MISSING :
|
|
|
- return "CRYPT_E_ATTRIBUTES_MISSING ";
|
|
|
- case CRYPT_E_STREAM_MSG_NOT_READY :
|
|
|
- return "CRYPT_E_STREAM_MSG_NOT_READY ";
|
|
|
- case CRYPT_E_STREAM_INSUFFICIENT_DATA :
|
|
|
- return "CRYPT_E_STREAM_INSUFFICIENT_DATA ";
|
|
|
- case CRYPT_E_BAD_LEN :
|
|
|
- return "CRYPT_E_BAD_LEN ";
|
|
|
- case CRYPT_E_BAD_ENCODE :
|
|
|
- return "CRYPT_E_BAD_ENCODE ";
|
|
|
- case CRYPT_E_FILE_ERROR :
|
|
|
- return "CRYPT_E_FILE_ERROR ";
|
|
|
- case CRYPT_E_NOT_FOUND :
|
|
|
- return "CRYPT_E_NOT_FOUND ";
|
|
|
- case CRYPT_E_EXISTS :
|
|
|
- return "CRYPT_E_EXISTS ";
|
|
|
- case CRYPT_E_NO_PROVIDER :
|
|
|
- return "CRYPT_E_NO_PROVIDER ";
|
|
|
- case CRYPT_E_SELF_SIGNED :
|
|
|
- return "CRYPT_E_SELF_SIGNED ";
|
|
|
- case CRYPT_E_DELETED_PREV :
|
|
|
- return "CRYPT_E_DELETED_PREV ";
|
|
|
- case CRYPT_E_NO_MATCH :
|
|
|
- return "CRYPT_E_NO_MATCH ";
|
|
|
- case CRYPT_E_UNEXPECTED_MSG_TYPE :
|
|
|
- return "CRYPT_E_UNEXPECTED_MSG_TYPE ";
|
|
|
- case CRYPT_E_NO_KEY_PROPERTY :
|
|
|
- return "CRYPT_E_NO_KEY_PROPERTY ";
|
|
|
- case CRYPT_E_NO_DECRYPT_CERT :
|
|
|
- return "CRYPT_E_NO_DECRYPT_CERT ";
|
|
|
- case CRYPT_E_BAD_MSG :
|
|
|
- return "CRYPT_E_BAD_MSG ";
|
|
|
- case CRYPT_E_NO_SIGNER :
|
|
|
- return "CRYPT_E_NO_SIGNER ";
|
|
|
- case CRYPT_E_PENDING_CLOSE :
|
|
|
- return "CRYPT_E_PENDING_CLOSE ";
|
|
|
- case CRYPT_E_REVOKED :
|
|
|
- return "CRYPT_E_REVOKED ";
|
|
|
- case CRYPT_E_NO_REVOCATION_DLL :
|
|
|
- return "CRYPT_E_NO_REVOCATION_DLL ";
|
|
|
- case CRYPT_E_NO_REVOCATION_CHECK :
|
|
|
- return "CRYPT_E_NO_REVOCATION_CHECK ";
|
|
|
- case CRYPT_E_REVOCATION_OFFLINE :
|
|
|
- return "CRYPT_E_REVOCATION_OFFLINE ";
|
|
|
- case CRYPT_E_NOT_IN_REVOCATION_DATABASE :
|
|
|
- return "CRYPT_E_NOT_IN_REVOCATION_DATABASE ";
|
|
|
- case CRYPT_E_INVALID_NUMERIC_STRING :
|
|
|
- return "CRYPT_E_INVALID_NUMERIC_STRING ";
|
|
|
- case CRYPT_E_INVALID_PRINTABLE_STRING :
|
|
|
- return "CRYPT_E_INVALID_PRINTABLE_STRING ";
|
|
|
- case CRYPT_E_INVALID_IA5_STRING :
|
|
|
- return "CRYPT_E_INVALID_IA5_STRING ";
|
|
|
- case CRYPT_E_INVALID_X500_STRING :
|
|
|
- return "CRYPT_E_INVALID_X500_STRING ";
|
|
|
- case CRYPT_E_NOT_CHAR_STRING :
|
|
|
- return "CRYPT_E_NOT_CHAR_STRING ";
|
|
|
- case CRYPT_E_FILERESIZED :
|
|
|
- return "CRYPT_E_FILERESIZED ";
|
|
|
- case CRYPT_E_SECURITY_SETTINGS :
|
|
|
- return "CRYPT_E_SECURITY_SETTINGS ";
|
|
|
- case CRYPT_E_NO_VERIFY_USAGE_DLL :
|
|
|
- return "CRYPT_E_NO_VERIFY_USAGE_DLL ";
|
|
|
- case CRYPT_E_NO_VERIFY_USAGE_CHECK :
|
|
|
- return "CRYPT_E_NO_VERIFY_USAGE_CHECK ";
|
|
|
- case CRYPT_E_VERIFY_USAGE_OFFLINE :
|
|
|
- return "CRYPT_E_VERIFY_USAGE_OFFLINE ";
|
|
|
- case CRYPT_E_NOT_IN_CTL :
|
|
|
- return "CRYPT_E_NOT_IN_CTL ";
|
|
|
- case CRYPT_E_NO_TRUSTED_SIGNER :
|
|
|
- return "CRYPT_E_NO_TRUSTED_SIGNER ";
|
|
|
- case CRYPT_E_OSS_ERROR :
|
|
|
- return "CRYPT_E_OSS_ERROR ";
|
|
|
- case CERTSRV_E_BAD_REQUESTSUBJECT :
|
|
|
- return "CERTSRV_E_BAD_REQUESTSUBJECT ";
|
|
|
- case CERTSRV_E_NO_REQUEST :
|
|
|
- return "CERTSRV_E_NO_REQUEST ";
|
|
|
- case CERTSRV_E_BAD_REQUESTSTATUS :
|
|
|
- return "CERTSRV_E_BAD_REQUESTSTATUS ";
|
|
|
- case CERTSRV_E_PROPERTY_EMPTY :
|
|
|
- return "CERTSRV_E_PROPERTY_EMPTY ";
|
|
|
- //case CERTDB_E_JET_ERROR :
|
|
|
- //return "CERTDB_E_JET_ERROR ";
|
|
|
- case TRUST_E_SYSTEM_ERROR :
|
|
|
- return "TRUST_E_SYSTEM_ERROR ";
|
|
|
- case TRUST_E_NO_SIGNER_CERT :
|
|
|
- return "TRUST_E_NO_SIGNER_CERT ";
|
|
|
- case TRUST_E_COUNTER_SIGNER :
|
|
|
- return "TRUST_E_COUNTER_SIGNER ";
|
|
|
- case TRUST_E_CERT_SIGNATURE :
|
|
|
- return "TRUST_E_CERT_SIGNATURE ";
|
|
|
- case TRUST_E_TIME_STAMP :
|
|
|
- return "TRUST_E_TIME_STAMP ";
|
|
|
- case TRUST_E_BAD_DIGEST :
|
|
|
- return "TRUST_E_BAD_DIGEST ";
|
|
|
- case TRUST_E_BASIC_CONSTRAINTS :
|
|
|
- return "TRUST_E_BASIC_CONSTRAINTS ";
|
|
|
- case TRUST_E_FINANCIAL_CRITERIA :
|
|
|
- return "TRUST_E_FINANCIAL_CRITERIA ";
|
|
|
- case TRUST_E_PROVIDER_UNKNOWN :
|
|
|
- return "TRUST_E_PROVIDER_UNKNOWN ";
|
|
|
- case TRUST_E_ACTION_UNKNOWN :
|
|
|
- return "TRUST_E_ACTION_UNKNOWN ";
|
|
|
- case TRUST_E_SUBJECT_FORM_UNKNOWN :
|
|
|
- return "TRUST_E_SUBJECT_FORM_UNKNOWN ";
|
|
|
- case TRUST_E_SUBJECT_NOT_TRUSTED :
|
|
|
- return "TRUST_E_SUBJECT_NOT_TRUSTED ";
|
|
|
- case DIGSIG_E_ENCODE :
|
|
|
- return "DIGSIG_E_ENCODE ";
|
|
|
- case DIGSIG_E_DECODE :
|
|
|
- return "DIGSIG_E_DECODE ";
|
|
|
- case DIGSIG_E_EXTENSIBILITY :
|
|
|
- return "DIGSIG_E_EXTENSIBILITY ";
|
|
|
- case DIGSIG_E_CRYPTO :
|
|
|
- return "DIGSIG_E_CRYPTO ";
|
|
|
- case PERSIST_E_SIZEDEFINITE :
|
|
|
- return "PERSIST_E_SIZEDEFINITE ";
|
|
|
- case PERSIST_E_SIZEINDEFINITE :
|
|
|
- return "PERSIST_E_SIZEINDEFINITE ";
|
|
|
- case PERSIST_E_NOTSELFSIZING :
|
|
|
- return "PERSIST_E_NOTSELFSIZING ";
|
|
|
- case TRUST_E_NOSIGNATURE :
|
|
|
- return "TRUST_E_NOSIGNATURE ";
|
|
|
- case CERT_E_EXPIRED :
|
|
|
- return "CERT_E_EXPIRED ";
|
|
|
- case CERT_E_VALIDITYPERIODNESTING :
|
|
|
- return "CERT_E_VALIDITYPERIODNESTING ";
|
|
|
- case CERT_E_ROLE :
|
|
|
- return "CERT_E_ROLE ";
|
|
|
- case CERT_E_PATHLENCONST :
|
|
|
- return "CERT_E_PATHLENCONST ";
|
|
|
- case CERT_E_CRITICAL :
|
|
|
- return "CERT_E_CRITICAL ";
|
|
|
- case CERT_E_PURPOSE :
|
|
|
- return "CERT_E_PURPOSE ";
|
|
|
- case CERT_E_ISSUERCHAINING :
|
|
|
- return "CERT_E_ISSUERCHAINING ";
|
|
|
- case CERT_E_MALFORMED :
|
|
|
- return "CERT_E_MALFORMED ";
|
|
|
- case CERT_E_UNTRUSTEDROOT :
|
|
|
- return "CERT_E_UNTRUSTEDROOT ";
|
|
|
- case CERT_E_CHAINING :
|
|
|
- return "CERT_E_CHAINING ";
|
|
|
- case TRUST_E_FAIL :
|
|
|
- return "TRUST_E_FAIL ";
|
|
|
- case CERT_E_REVOKED :
|
|
|
- return "CERT_E_REVOKED ";
|
|
|
- case CERT_E_UNTRUSTEDTESTROOT :
|
|
|
- return "CERT_E_UNTRUSTEDTESTROOT ";
|
|
|
- case CERT_E_REVOCATION_FAILURE :
|
|
|
- return "CERT_E_REVOCATION_FAILURE ";
|
|
|
- case CERT_E_CN_NO_MATCH :
|
|
|
- return "CERT_E_CN_NO_MATCH ";
|
|
|
- case CERT_E_WRONG_USAGE :
|
|
|
- return "CERT_E_WRONG_USAGE ";
|
|
|
- case SPAPI_E_EXPECTED_SECTION_NAME :
|
|
|
- return "SPAPI_E_EXPECTED_SECTION_NAME ";
|
|
|
- case SPAPI_E_BAD_SECTION_NAME_LINE :
|
|
|
- return "SPAPI_E_BAD_SECTION_NAME_LINE ";
|
|
|
- case SPAPI_E_SECTION_NAME_TOO_LONG :
|
|
|
- return "SPAPI_E_SECTION_NAME_TOO_LONG ";
|
|
|
- case SPAPI_E_GENERAL_SYNTAX :
|
|
|
- return "SPAPI_E_GENERAL_SYNTAX ";
|
|
|
- case SPAPI_E_WRONG_INF_STYLE :
|
|
|
- return "SPAPI_E_WRONG_INF_STYLE ";
|
|
|
- case SPAPI_E_SECTION_NOT_FOUND :
|
|
|
- return "SPAPI_E_SECTION_NOT_FOUND ";
|
|
|
- case SPAPI_E_LINE_NOT_FOUND :
|
|
|
- return "SPAPI_E_LINE_NOT_FOUND ";
|
|
|
- case SPAPI_E_NO_ASSOCIATED_CLASS :
|
|
|
- return "SPAPI_E_NO_ASSOCIATED_CLASS ";
|
|
|
- case SPAPI_E_CLASS_MISMATCH :
|
|
|
- return "SPAPI_E_CLASS_MISMATCH ";
|
|
|
- case SPAPI_E_DUPLICATE_FOUND :
|
|
|
- return "SPAPI_E_DUPLICATE_FOUND ";
|
|
|
- case SPAPI_E_NO_DRIVER_SELECTED :
|
|
|
- return "SPAPI_E_NO_DRIVER_SELECTED ";
|
|
|
- case SPAPI_E_KEY_DOES_NOT_EXIST :
|
|
|
- return "SPAPI_E_KEY_DOES_NOT_EXIST ";
|
|
|
- case SPAPI_E_INVALID_DEVINST_NAME :
|
|
|
- return "SPAPI_E_INVALID_DEVINST_NAME ";
|
|
|
- case SPAPI_E_INVALID_CLASS :
|
|
|
- return "SPAPI_E_INVALID_CLASS ";
|
|
|
- case SPAPI_E_DEVINST_ALREADY_EXISTS :
|
|
|
- return "SPAPI_E_DEVINST_ALREADY_EXISTS ";
|
|
|
- case SPAPI_E_DEVINFO_NOT_REGISTERED :
|
|
|
- return "SPAPI_E_DEVINFO_NOT_REGISTERED ";
|
|
|
- case SPAPI_E_INVALID_REG_PROPERTY :
|
|
|
- return "SPAPI_E_INVALID_REG_PROPERTY ";
|
|
|
- case SPAPI_E_NO_INF :
|
|
|
- return "SPAPI_E_NO_INF ";
|
|
|
- case SPAPI_E_NO_SUCH_DEVINST :
|
|
|
- return "SPAPI_E_NO_SUCH_DEVINST ";
|
|
|
- case SPAPI_E_CANT_LOAD_CLASS_ICON :
|
|
|
- return "SPAPI_E_CANT_LOAD_CLASS_ICON ";
|
|
|
- case SPAPI_E_INVALID_CLASS_INSTALLER :
|
|
|
- return "SPAPI_E_INVALID_CLASS_INSTALLER ";
|
|
|
- case SPAPI_E_DI_DO_DEFAULT :
|
|
|
- return "SPAPI_E_DI_DO_DEFAULT ";
|
|
|
- case SPAPI_E_DI_NOFILECOPY :
|
|
|
- return "SPAPI_E_DI_NOFILECOPY ";
|
|
|
- case SPAPI_E_INVALID_HWPROFILE :
|
|
|
- return "SPAPI_E_INVALID_HWPROFILE ";
|
|
|
- case SPAPI_E_NO_DEVICE_SELECTED :
|
|
|
- return "SPAPI_E_NO_DEVICE_SELECTED ";
|
|
|
- case SPAPI_E_DEVINFO_LIST_LOCKED :
|
|
|
- return "SPAPI_E_DEVINFO_LIST_LOCKED ";
|
|
|
- case SPAPI_E_DEVINFO_DATA_LOCKED :
|
|
|
- return "SPAPI_E_DEVINFO_DATA_LOCKED ";
|
|
|
- case SPAPI_E_DI_BAD_PATH :
|
|
|
- return "SPAPI_E_DI_BAD_PATH ";
|
|
|
- case SPAPI_E_NO_CLASSINSTALL_PARAMS :
|
|
|
- return "SPAPI_E_NO_CLASSINSTALL_PARAMS ";
|
|
|
- case SPAPI_E_FILEQUEUE_LOCKED :
|
|
|
- return "SPAPI_E_FILEQUEUE_LOCKED ";
|
|
|
- case SPAPI_E_BAD_SERVICE_INSTALLSECT :
|
|
|
- return "SPAPI_E_BAD_SERVICE_INSTALLSECT ";
|
|
|
- case SPAPI_E_NO_CLASS_DRIVER_LIST :
|
|
|
- return "SPAPI_E_NO_CLASS_DRIVER_LIST ";
|
|
|
- case SPAPI_E_NO_ASSOCIATED_SERVICE :
|
|
|
- return "SPAPI_E_NO_ASSOCIATED_SERVICE ";
|
|
|
- case SPAPI_E_NO_DEFAULT_DEVICE_INTERFACE :
|
|
|
- return "SPAPI_E_NO_DEFAULT_DEVICE_INTERFACE ";
|
|
|
- case SPAPI_E_DEVICE_INTERFACE_ACTIVE :
|
|
|
- return "SPAPI_E_DEVICE_INTERFACE_ACTIVE ";
|
|
|
- case SPAPI_E_DEVICE_INTERFACE_REMOVED :
|
|
|
- return "SPAPI_E_DEVICE_INTERFACE_REMOVED ";
|
|
|
- case SPAPI_E_BAD_INTERFACE_INSTALLSECT :
|
|
|
- return "SPAPI_E_BAD_INTERFACE_INSTALLSECT ";
|
|
|
- case SPAPI_E_NO_SUCH_INTERFACE_CLASS :
|
|
|
- return "SPAPI_E_NO_SUCH_INTERFACE_CLASS ";
|
|
|
- case SPAPI_E_INVALID_REFERENCE_STRING :
|
|
|
- return "SPAPI_E_INVALID_REFERENCE_STRING ";
|
|
|
- case SPAPI_E_INVALID_MACHINENAME :
|
|
|
- return "SPAPI_E_INVALID_MACHINENAME ";
|
|
|
- case SPAPI_E_REMOTE_COMM_FAILURE :
|
|
|
- return "SPAPI_E_REMOTE_COMM_FAILURE ";
|
|
|
- case SPAPI_E_MACHINE_UNAVAILABLE :
|
|
|
- return "SPAPI_E_MACHINE_UNAVAILABLE ";
|
|
|
- case SPAPI_E_NO_CONFIGMGR_SERVICES :
|
|
|
- return "SPAPI_E_NO_CONFIGMGR_SERVICES ";
|
|
|
- case SPAPI_E_INVALID_PROPPAGE_PROVIDER :
|
|
|
- return "SPAPI_E_INVALID_PROPPAGE_PROVIDER ";
|
|
|
- case SPAPI_E_NO_SUCH_DEVICE_INTERFACE :
|
|
|
- return "SPAPI_E_NO_SUCH_DEVICE_INTERFACE ";
|
|
|
- case SPAPI_E_DI_POSTPROCESSING_REQUIRED :
|
|
|
- return "SPAPI_E_DI_POSTPROCESSING_REQUIRED ";
|
|
|
- case SPAPI_E_INVALID_COINSTALLER :
|
|
|
- return "SPAPI_E_INVALID_COINSTALLER ";
|
|
|
- case SPAPI_E_NO_COMPAT_DRIVERS :
|
|
|
- return "SPAPI_E_NO_COMPAT_DRIVERS ";
|
|
|
- case SPAPI_E_NO_DEVICE_ICON :
|
|
|
- return "SPAPI_E_NO_DEVICE_ICON ";
|
|
|
- case SPAPI_E_INVALID_INF_LOGCONFIG :
|
|
|
- return "SPAPI_E_INVALID_INF_LOGCONFIG ";
|
|
|
- case SPAPI_E_DI_DONT_INSTALL :
|
|
|
- return "SPAPI_E_DI_DONT_INSTALL ";
|
|
|
- case SPAPI_E_INVALID_FILTER_DRIVER :
|
|
|
- return "SPAPI_E_INVALID_FILTER_DRIVER ";
|
|
|
- case SPAPI_E_ERROR_NOT_INSTALLED :
|
|
|
- return "SPAPI_E_ERROR_NOT_INSTALLED ";
|
|
|
-
|
|
|
- default:
|
|
|
- static char buff[1000];
|
|
|
- sprintf(buff, "Unrecognized error value: %08X\0", error);
|
|
|
-
|
|
|
- return buff;
|
|
|
- }
|
|
|
-}
|
|
|
-
|
|
|
-// Global system parameters we want to modify during our run
|
|
|
-static int iMouseTrails;
|
|
|
-static bool bCursorShadowOn,bMouseVanish;
|
|
|
-
|
|
|
-void set_global_parameters() {
|
|
|
- // turn off mousetrails and cursor shadow and mouse cursor vanish
|
|
|
- // cursor shadow causes cursor blink and reduced frame rate due to lack of driver support for
|
|
|
- // cursor alpha blending
|
|
|
-
|
|
|
- // this is a win2k/xp only param, could use GetVersionEx to do it just for win2k,
|
|
|
- // but since it is just a param it will just cause a silent error on other OS's
|
|
|
- // that should be ok
|
|
|
- SystemParametersInfo(SPI_GETCURSORSHADOW,NULL,&bCursorShadowOn,NULL);
|
|
|
- SystemParametersInfo(SPI_SETCURSORSHADOW,NULL,(PVOID)false,NULL);
|
|
|
-
|
|
|
- SystemParametersInfo(SPI_GETMOUSETRAILS,NULL,&iMouseTrails,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSETRAILS,NULL,(PVOID)0,NULL);
|
|
|
-
|
|
|
- // this is ME/XP only feature
|
|
|
- SystemParametersInfo(SPI_GETMOUSEVANISH,NULL,&bMouseVanish,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSEVANISH,NULL,(PVOID)false,NULL);
|
|
|
-}
|
|
|
-
|
|
|
-void restore_global_parameters() {
|
|
|
- SystemParametersInfo(SPI_SETCURSORSHADOW,NULL,(PVOID)bCursorShadowOn,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSETRAILS,NULL,(PVOID)iMouseTrails,NULL);
|
|
|
- SystemParametersInfo(SPI_SETMOUSEVANISH,NULL,(PVOID)bMouseVanish,NULL);
|
|
|
-}
|
|
|
-
|
David Rose