diff --git a/panda/src/dxgsg7/wdxGraphicsPipe.cxx.old b/panda/src/dxgsg7/wdxGraphicsPipe.cxx.old new file mode 100644 index 0000000000..824314621b --- /dev/null +++ b/panda/src/dxgsg7/wdxGraphicsPipe.cxx.old @@ -0,0 +1,1603 @@ +// Filename: wdxGraphicsPipe.cxx +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#include "wdxGraphicsPipe.h" +#include "config_wdxdisplay.h" +#include +#include +#include + +//////////////////////////////////////////////////////////////////// +// Static variables +//////////////////////////////////////////////////////////////////// +TypeHandle wdxGraphicsPipe::_type_handle; + +//wdxGraphicsPipe *global_pipe; + +wdxGraphicsPipe::wdxGraphicsPipe(const PipeSpecifier& spec) +: InteractiveGraphicsPipe(spec) { +// _width = GetSystemMetrics(SM_CXSCREEN); +// _height = GetSystemMetrics(SM_CYSCREEN); +// _shift = false; +// global_pipe = this; +} + +//////////////////////////////////////////////////////////////////// +// Function: wdxGraphicsPipe::get_window_type +// Access: Public, Virtual +// Description: Returns the TypeHandle of the kind of window +// preferred by this kind of pipe. +//////////////////////////////////////////////////////////////////// +TypeHandle wdxGraphicsPipe:: +get_window_type() const { + return wdxGraphicsWindow::get_class_type(); +} + +GraphicsPipe *wdxGraphicsPipe:: +make_wdxGraphicsPipe(const FactoryParams ¶ms) { + GraphicsPipe::PipeSpec *pipe_param; + if(!get_param_into(pipe_param, params)) { + return new wdxGraphicsPipe(PipeSpecifier()); + } else { + return new wdxGraphicsPipe(pipe_param->get_specifier()); + } +} + +TypeHandle wdxGraphicsPipe::get_class_type(void) { + return _type_handle; +} + +const char *pipe_type_name="wdxGraphicsPipe"; + +void wdxGraphicsPipe::init_type(void) { + InteractiveGraphicsPipe::init_type(); + register_type(_type_handle, pipe_type_name, + InteractiveGraphicsPipe::get_class_type()); +} + +TypeHandle wdxGraphicsPipe::get_type(void) const { + return get_class_type(); +} + +wdxGraphicsPipe::wdxGraphicsPipe(void) { + wdxdisplay_cat.error() + << pipe_type_name <<"s should not be created with the default constructor" << endl; +} + +wdxGraphicsPipe::wdxGraphicsPipe(const wdxGraphicsPipe&) { + wdxdisplay_cat.error() + << pipe_type_name << "s should not be copied" << endl; +} + +wdxGraphicsPipe& wdxGraphicsPipe::operator=(const wdxGraphicsPipe&) { + wdxdisplay_cat.error() + << pipe_type_name << "s should not be assigned" << endl; + return *this; +} + +//////////////////////////////////////////////////////////////////// +// Function: find_window +// Access: +// Description: Find the window that has the xwindow "win" in the +// window list for the pipe (if it exists) +//////////////////////////////////////////////////////////////////// +wdxGraphicsWindow *wdxGraphicsPipe:: +find_window(HWND win) { + int num_windows = get_num_windows(); + for(int w = 0; w < num_windows; w++) { + wdxGraphicsWindow *window = DCAST(wdxGraphicsWindow, get_window(w)); + if(window->_dxgsg->scrn.hWnd == win) + return window; + } + return NULL; +} + +extern char * ConvD3DErrorToString(const HRESULT &error) { + switch(error) { + case E_FAIL: + return "Unspecified error E_FAIL"; + + case DD_OK: + return "No error.\0"; + case D3DERR_BADMAJORVERSION : // (700) + return "D3DERR_BADMAJORVERSION";//: // (700) + case D3DERR_BADMINORVERSION : // (701) + return "D3DERR_BADMINORVERSION";//: // (701) + case D3DERR_INVALID_DEVICE : // (705) + return "D3DERR_INVALID_DEVICE";//: // (705) + case D3DERR_INITFAILED : // (706) + return "D3DERR_INITFAILED";//: // (706) + case D3DERR_DEVICEAGGREGATED : // (707) + return "D3DERR_DEVICEAGGREGATED";//: // (707) + case D3DERR_EXECUTE_CREATE_FAILED : // (710) + return "D3DERR_EXECUTE_CREATE_FAILED";//: // (710) + case D3DERR_EXECUTE_DESTROY_FAILED : // (711) + return "D3DERR_EXECUTE_DESTROY_FAILED";//: // (711) + case D3DERR_EXECUTE_LOCK_FAILED : // (712) + return "D3DERR_EXECUTE_LOCK_FAILED";//: // (712) + case D3DERR_EXECUTE_UNLOCK_FAILED : // (713) + return "D3DERR_EXECUTE_UNLOCK_FAILED";//: // (713) + case D3DERR_EXECUTE_LOCKED : // (714) + return "D3DERR_EXECUTE_LOCKED";//: // (714) + case D3DERR_EXECUTE_NOT_LOCKED : // (715) + return "D3DERR_EXECUTE_NOT_LOCKED";//: // (715) + case D3DERR_EXECUTE_FAILED : // (716) + return "D3DERR_EXECUTE_FAILED";//: // (716) + case D3DERR_EXECUTE_CLIPPED_FAILED : // (717) + return "D3DERR_EXECUTE_CLIPPED_FAILED";//: // (717) + case D3DERR_TEXTURE_NO_SUPPORT : // (720) + return "D3DERR_TEXTURE_NO_SUPPORT";//: // (720) + case D3DERR_TEXTURE_CREATE_FAILED : // (721) + return "D3DERR_TEXTURE_CREATE_FAILED";//: // (721) + case D3DERR_TEXTURE_DESTROY_FAILED : // (722) + return "D3DERR_TEXTURE_DESTROY_FAILED";//: // (722) + case D3DERR_TEXTURE_LOCK_FAILED : // (723) + return "D3DERR_TEXTURE_LOCK_FAILED";//: // (723) + case D3DERR_TEXTURE_UNLOCK_FAILED : // (724) + return "D3DERR_TEXTURE_UNLOCK_FAILED";//: // (724) + case D3DERR_TEXTURE_LOAD_FAILED : // (725) + return "D3DERR_TEXTURE_LOAD_FAILED";//: // (725) + case D3DERR_TEXTURE_SWAP_FAILED : // (726) + return "D3DERR_TEXTURE_SWAP_FAILED";//: // (726) + case D3DERR_TEXTURE_LOCKED : // (727) + return "D3DERR_TEXTURE_LOCKED";//: // (727) + case D3DERR_TEXTURE_NOT_LOCKED : // (728) + return "D3DERR_TEXTURE_NOT_LOCKED";//: // (728) + case D3DERR_TEXTURE_GETSURF_FAILED : // (729) + return "D3DERR_TEXTURE_GETSURF_FAILED";//: // (729) + case D3DERR_MATRIX_CREATE_FAILED : // (730) + return "D3DERR_MATRIX_CREATE_FAILED";//: // (730) + case D3DERR_MATRIX_DESTROY_FAILED : // (731) + return "D3DERR_MATRIX_DESTROY_FAILED";//: // (731) + case D3DERR_MATRIX_SETDATA_FAILED : // (732) + return "D3DERR_MATRIX_SETDATA_FAILED";//: // (732) + case D3DERR_MATRIX_GETDATA_FAILED : // (733) + return "D3DERR_MATRIX_GETDATA_FAILED";//: // (733) + case D3DERR_SETVIEWPORTDATA_FAILED : // (734) + return "D3DERR_SETVIEWPORTDATA_FAILED";//: // (734) + case D3DERR_INVALIDCURRENTVIEWPORT : // (735) + return "D3DERR_INVALIDCURRENTVIEWPORT";//: // (735) + case D3DERR_INVALIDPRIMITIVETYPE : // (736) + return "D3DERR_INVALIDPRIMITIVETYPE";//: // (736) + case D3DERR_INVALIDVERTEXTYPE : // (737) + return "D3DERR_INVALIDVERTEXTYPE";//: // (737) + case D3DERR_TEXTURE_BADSIZE : // (738) + return "D3DERR_TEXTURE_BADSIZE";//: // (738) + case D3DERR_INVALIDRAMPTEXTURE : // (739) + return "D3DERR_INVALIDRAMPTEXTURE";//: // (739) + case D3DERR_MATERIAL_CREATE_FAILED : // (740) + return "D3DERR_MATERIAL_CREATE_FAILED";//: // (740) + case D3DERR_MATERIAL_DESTROY_FAILED : // (741) + return "D3DERR_MATERIAL_DESTROY_FAILED";//: // (741) + case D3DERR_MATERIAL_SETDATA_FAILED : // (742) + return "D3DERR_MATERIAL_SETDATA_FAILED";//: // (742) + case D3DERR_MATERIAL_GETDATA_FAILED : // (743) + return "D3DERR_MATERIAL_GETDATA_FAILED";//: // (743) + case D3DERR_INVALIDPALETTE : // (744) + return "D3DERR_INVALIDPALETTE";//: // (744) + case D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY : // (745) + return "D3DERR_ZBUFF_NEEDS_SYSTEMMEMORY";//: // (745) + case D3DERR_ZBUFF_NEEDS_VIDEOMEMORY : // (746) + return "D3DERR_ZBUFF_NEEDS_VIDEOMEMORY";//: // (746) + case D3DERR_SURFACENOTINVIDMEM : // (747) + return "D3DERR_SURFACENOTINVIDMEM";//: // (747) + case D3DERR_LIGHT_SET_FAILED : // (750) + return "D3DERR_LIGHT_SET_FAILED";//: // (750) + case D3DERR_LIGHTHASVIEWPORT : // (751) + return "D3DERR_LIGHTHASVIEWPORT";//: // (751) + case D3DERR_LIGHTNOTINTHISVIEWPORT : // (752) + return "D3DERR_LIGHTNOTINTHISVIEWPORT";//: // (752) + case D3DERR_SCENE_IN_SCENE : // (760) + return "D3DERR_SCENE_IN_SCENE";//: // (760) + case D3DERR_SCENE_NOT_IN_SCENE : // (761) + return "D3DERR_SCENE_NOT_IN_SCENE";//: // (761) + case D3DERR_SCENE_BEGIN_FAILED : // (762) + return "D3DERR_SCENE_BEGIN_FAILED";//: // (762) + case D3DERR_SCENE_END_FAILED : // (763) + return "D3DERR_SCENE_END_FAILED";//: // (763) + case D3DERR_INBEGIN : // (770) + return "D3DERR_INBEGIN";//: // (770) + case D3DERR_NOTINBEGIN : // (771) + return "D3DERR_NOTINBEGIN";//: // (771) + case D3DERR_NOVIEWPORTS : // (772) + return "D3DERR_NOVIEWPORTS";//: // (772) + case D3DERR_VIEWPORTDATANOTSET : // (773) + return "D3DERR_VIEWPORTDATANOTSET";//: // (773) + case D3DERR_VIEWPORTHASNODEVICE : // (774) + return "D3DERR_VIEWPORTHASNODEVICE";//: // (774) + case D3DERR_NOCURRENTVIEWPORT : // (775) + return "D3DERR_NOCURRENTVIEWPORT";//: // (775) + case D3DERR_INVALIDVERTEXFORMAT : // (2048) + return "D3DERR_INVALIDVERTEXFORMAT";//: // (2048) + case D3DERR_COLORKEYATTACHED : // (2050) + return "D3DERR_COLORKEYATTACHED";//: // (2050) + case D3DERR_VERTEXBUFFEROPTIMIZED : // (2060) + return "D3DERR_VERTEXBUFFEROPTIMIZED";//: // (2060) + case D3DERR_VBUF_CREATE_FAILED : // (2061) + return "D3DERR_VBUF_CREATE_FAILED";//: // (2061) + case D3DERR_VERTEXBUFFERLOCKED : // (2062) + return "D3DERR_VERTEXBUFFERLOCKED";//: // (2062) + case D3DERR_ZBUFFER_NOTPRESENT : // (2070) + return "D3DERR_ZBUFFER_NOTPRESENT";//: // (2070) + case D3DERR_STENCILBUFFER_NOTPRESENT : // (2071) + return "D3DERR_STENCILBUFFER_NOTPRESENT";//: // (2071) + case D3DERR_WRONGTEXTUREFORMAT : // (2072) + return "D3DERR_WRONGTEXTUREFORMAT";//: // (2072) + case D3DERR_UNSUPPORTEDCOLOROPERATION : // (2073) + return "D3DERR_UNSUPPORTEDCOLOROPERATION";//: // (2073) + case D3DERR_UNSUPPORTEDCOLORARG : // (2074) + return "D3DERR_UNSUPPORTEDCOLORARG";//: // (2074) + case D3DERR_UNSUPPORTEDALPHAOPERATION : // (2075) + return "D3DERR_UNSUPPORTEDALPHAOPERATION";//: // (2075) + case D3DERR_UNSUPPORTEDALPHAARG : // (2076) + return "D3DERR_UNSUPPORTEDALPHAARG";//: // (2076) + case D3DERR_TOOMANYOPERATIONS : // (2077) + return "D3DERR_TOOMANYOPERATIONS";//: // (2077) + case D3DERR_CONFLICTINGTEXTUREFILTER : // (2078) + return "D3DERR_CONFLICTINGTEXTUREFILTER";//: // (2078) + case D3DERR_UNSUPPORTEDFACTORVALUE : // (2079) + return "D3DERR_UNSUPPORTEDFACTORVALUE";//: // (2079) + case D3DERR_CONFLICTINGRENDERSTATE : // (2081) + return "D3DERR_CONFLICTINGRENDERSTATE";//: // (2081) + case D3DERR_UNSUPPORTEDTEXTUREFILTER : // (2082) + return "D3DERR_UNSUPPORTEDTEXTUREFILTER";//: // (2082) + case D3DERR_TOOMANYPRIMITIVES : // (2083) + return "D3DERR_TOOMANYPRIMITIVES";//: // (2083) + case D3DERR_INVALIDMATRIX : // (2084) + return "D3DERR_INVALIDMATRIX";//: // (2084) + case D3DERR_TOOMANYVERTICES : // (2085) + return "D3DERR_TOOMANYVERTICES";//: // (2085) + case D3DERR_CONFLICTINGTEXTUREPALETTE : // (2086) + return "D3DERR_CONFLICTINGTEXTUREPALETTE";//: // (2086) +//#if DX7 + case D3DERR_VERTEXBUFFERUNLOCKFAILED : // (2063) + return "D3DERR_VERTEXBUFFERUNLOCKFAILED";//: // (2063) + case D3DERR_INVALIDSTATEBLOCK : // (2100) + return "D3DERR_INVALIDSTATEBLOCK";//: // (2100) + case D3DERR_INBEGINSTATEBLOCK : // (2101) + return "D3DERR_INBEGINSTATEBLOCK";//: // (2101) + case D3DERR_NOTINBEGINSTATEBLOCK : // (2102) + return "D3DERR_NOTINBEGINSTATEBLOCK";//: // (2102) + //case D3DERR_INOVERLAYSTATEBLOCK : // (2103) + // return "D3DERR_INOVERLAYSTATEBLOCK";//: // (2103) + case DDERR_NOSTEREOHARDWARE : // ( 181 ) + return "DDERR_NOSTEREOHARDWARE ";//: // ( 181 ) + case DDERR_NOSURFACELEFT : // ( 182 ) + return "DDERR_NOSURFACELEFT ";//: // ( 182 ) + case DDERR_DDSCAPSCOMPLEXREQUIRED : // ( 542 ) + return "DDERR_DDSCAPSCOMPLEXREQUIRED";//: // ( 542 ) + case DDERR_NOTONMIPMAPSUBLEVEL : // ( 603 ) + return "DDERR_NOTONMIPMAPSUBLEVEL";//: // ( 603 ) + case DDERR_TESTFINISHED : // ( 692 ) + return "DDERR_TESTFINISHED";//: // ( 692 ) + case DDERR_NEWMODE : // ( 693 ) + return "DDERR_NEWMODE";//: // ( 693 ) +//#endif + //case D3DERR_COMMAND_UNPARSED : // (3000) + /// return "case";//D3DERR_COMMAND_UNPARSED : // (3000) + + 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_OVERLAPPINGRECTS : // ( 270 ) + return "DDERR_OVERLAPPINGRECTS ";//: // ( 270 ) + 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_INVALIDSTREAM : // ( 521 ) + return "DDERR_INVALIDSTREAM";//: // ( 521 ) + 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_EXPIRED : // ( 691 ) + return "DDERR_EXPIRED";//: // ( 691 ) + case DDERR_VIDEONOTACTIVE : // ( 695 ) + return "DDERR_VIDEONOTACTIVE ";//: // ( 695 ) + case DDERR_DEVICEDOESNTOWNSURFACE : // ( 699 ) + return "DDERR_DEVICEDOESNTOWNSURFACE ";//: // ( 699 ) + case DXFILEERR_BADOBJECT : // (850) + return "DXFILEERR_BADOBJECT";//: // (850) + case DXFILEERR_BADVALUE : // (851) + return "DXFILEERR_BADVALUE";//: // (851) + case DXFILEERR_BADTYPE : // (852) + return "DXFILEERR_BADTYPE";//: // (852) + case DXFILEERR_BADSTREAMHANDLE : // (853) + return "DXFILEERR_BADSTREAMHANDLE";//: // (853) + case DXFILEERR_BADALLOC : // (854) + return "DXFILEERR_BADALLOC";//: // (854) + case DXFILEERR_NOTFOUND : // (855) + return "DXFILEERR_NOTFOUND";//: // (855) + case DXFILEERR_NOTDONEYET : // (856) + return "DXFILEERR_NOTDONEYET";//: // (856) + case DXFILEERR_FILENOTFOUND : // (857) + return "DXFILEERR_FILENOTFOUND";//: // (857) + case DXFILEERR_RESOURCENOTFOUND : // (858) + return "DXFILEERR_RESOURCENOTFOUND";//: // (858) + case DXFILEERR_URLNOTFOUND : // (859) + return "DXFILEERR_URLNOTFOUND";//: // (859) + case DXFILEERR_BADRESOURCE : // (860) + return "DXFILEERR_BADRESOURCE";//: // (860) + case DXFILEERR_BADFILETYPE : // (861) + return "DXFILEERR_BADFILETYPE";//: // (861) + case DXFILEERR_BADFILEVERSION : // (862) + return "DXFILEERR_BADFILEVERSION";//: // (862) + case DXFILEERR_BADFILEFLOATSIZE : // (863) + return "DXFILEERR_BADFILEFLOATSIZE";//: // (863) + case DXFILEERR_BADFILECOMPRESSIONTYPE : // (864) + return "DXFILEERR_BADFILECOMPRESSIONTYPE";//: // (864) + case DXFILEERR_BADFILE : // (865) + return "DXFILEERR_BADFILE";//: // (865) + case DXFILEERR_PARSEERROR : // (866) + return "DXFILEERR_PARSEERROR";//: // (866) + case DXFILEERR_NOTEMPLATE : // (867) + return "DXFILEERR_NOTEMPLATE";//: // (867) + case DXFILEERR_BADARRAYSIZE : // (868) + return "DXFILEERR_BADARRAYSIZE";//: // (868) + case DXFILEERR_BADDATAREFERENCE : // (869) + return "DXFILEERR_BADDATAREFERENCE";//: // (869) + case DXFILEERR_INTERNALERROR : // (870) + return "DXFILEERR_INTERNALERROR";//: // (870) + case DXFILEERR_NOMOREOBJECTS : // (871) + return "DXFILEERR_NOMOREOBJECTS";//: // (871) + case DXFILEERR_BADINTRINSICS : // (872) + return "DXFILEERR_BADINTRINSICS";//: // (872) + case DXFILEERR_NOMORESTREAMHANDLES : // (873) + return "DXFILEERR_NOMORESTREAMHANDLES";//: // (873) + case DXFILEERR_NOMOREDATA : // (874) + return "DXFILEERR_NOMOREDATA";//: // (874) + case DXFILEERR_BADCACHEFILE : // (875) + return "DXFILEERR_BADCACHEFILE";//: // (875) + case DXFILEERR_NOINTERNET : // (876) + return "DXFILEERR_NOINTERNET";//: // (876) + + 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; + } +} + diff --git a/panda/src/dxgsg7/wdxGraphicsPipe.h.old b/panda/src/dxgsg7/wdxGraphicsPipe.h.old new file mode 100644 index 0000000000..9302c00b00 --- /dev/null +++ b/panda/src/dxgsg7/wdxGraphicsPipe.h.old @@ -0,0 +1,67 @@ +// Filename: wdxGraphicsPipe.h +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// +#ifndef WDXGRAPHICSPIPE_H +#define WDXGRAPHICSPIPE_H +// +//////////////////////////////////////////////////////////////////// +// Includes +//////////////////////////////////////////////////////////////////// + +#include +#include "wdxGraphicsWindow.h" +#include + +//////////////////////////////////////////////////////////////////// +// Class : wdxGraphicsPipe +// Description : +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDADX wdxGraphicsPipe : public InteractiveGraphicsPipe { +public: + wdxGraphicsPipe(const PipeSpecifier&); + + wdxGraphicsWindow* find_window(HWND win); +// ButtonHandle lookup_key(WPARAM wparam) const; + + virtual TypeHandle get_window_type() const; + +public: + + static GraphicsPipe* make_wdxGraphicsPipe(const FactoryParams ¶ms); + + static TypeHandle get_class_type(void); + static void init_type(void); + virtual TypeHandle get_type(void) const; + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + +private: + + static TypeHandle _type_handle; + +// int _width; +// int _height; +// bool _shift; + +protected: + + wdxGraphicsPipe(void); + wdxGraphicsPipe(const wdxGraphicsPipe&); + wdxGraphicsPipe& operator=(const wdxGraphicsPipe&); + +}; + +#endif diff --git a/panda/src/dxgsg7/wdxGraphicsWindow.cxx.old b/panda/src/dxgsg7/wdxGraphicsWindow.cxx.old new file mode 100644 index 0000000000..9a6a89dd31 --- /dev/null +++ b/panda/src/dxgsg7/wdxGraphicsWindow.cxx.old @@ -0,0 +1,3010 @@ +// Filename: wdxGraphicsWindow.cxx +// Created by: mike (09Jan00) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#include +#include +#include +#include +#include "wdxGraphicsWindow.h" +#include "wdxGraphicsPipe.h" +#include "config_wdxdisplay.h" + +#include +#include +#include + +#ifdef DO_PSTATS +#include +#endif + +#include + +//////////////////////////////////////////////////////////////////// +// Static variables +//////////////////////////////////////////////////////////////////// +TypeHandle wdxGraphicsWindow::_type_handle; + +#define LAST_ERROR 0 +#define ERRORBOX_TITLE "Panda3D Error" +#define WDX_WINDOWCLASSNAME "wdxDisplay" +#define DEFAULT_CURSOR IDC_ARROW + +typedef map HWND_PANDAWIN_MAP; + +HWND_PANDAWIN_MAP hwnd_pandawin_map; +wdxGraphicsWindow* global_wdxwinptr = NULL; // need this for temporary windproc + +#define MAX_DISPLAYS 20 + +extern bool dx_full_screen_antialiasing; // defined in dxgsg_config.cxx + +#define PAUSED_TIMER_ID 7 // completely arbitrary choice +#define DXREADY ((_dxgsg!=NULL)&&(_dxgsg->GetDXReady())) + +LONG WINAPI static_window_proc(HWND hwnd, UINT msg, WPARAM wparam,LPARAM lparam); + +// imperfect method to ID NVid? could also scan desc str, but that isnt fullproof either +#define IS_NVIDIA(DDDEVICEID) ((DDDEVICEID.dwVendorId==0x10DE) || (DDDEVICEID.dwVendorId==0x12D2)) +#define IS_ATI(DDDEVICEID) (DDDEVICEID.dwVendorId==0x1002) +#define IS_MATROX(DDDEVICEID) (DDDEVICEID.dwVendorId==0x102B) + +// 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}; + +static DWORD BitDepth_2_DDBDMask(DWORD iBitDepth) { + switch(iBitDepth) { + case 16: return DDBD_16; + case 32: return DDBD_32; + case 24: return DDBD_24; + case 8: return DDBD_8; + case 1: return DDBD_1; + case 2: return DDBD_2; + case 4: return DDBD_4; + } + return 0x0; +} +/* +typedef enum {DBGLEV_FATAL,DBGLEV_ERROR,DBGLEV_WARNING,DBGLEV_INFO,DBGLEV_DEBUG,DBGLEV_SPAM + } DebugLevels; + +void PrintDBGStr(DebugLevels level,HRESULT hr,const char *msgstr) { + ostream *pstrm; + static ostream dbg_strms[DBGLEV_SPAM+1]={wdxdisplay_cat.fatal,wdxdisplay_cat.error, + wdxdisplay_cat.warning,wdxdisplay_cat.info,wdxdisplay_cat.debug,wdxdisplay_cat.spam}; + assert(level<=DBGLEV_SPAM); + + pstrm=dbg_strms[level]; + (*pstrm)->fatal() << "GetDisplayMode failed, result = " << ConvD3DErrorToString(hr) << endl; +} +*/ +#ifdef _DEBUG +static void DebugPrintPixFmt(DDPIXELFORMAT* pddpf) { + static int iddpfnum=0; + ostream *dbgout = &dxgsg_cat.debug(); + + *dbgout << "ZBuf DDPF[" << iddpfnum << "]: RGBBitCount:" << pddpf->dwRGBBitCount + << " Flags:" << (void *)pddpf->dwFlags ; + + if(pddpf->dwFlags & DDPF_STENCILBUFFER) { + *dbgout << " StencilBits:" << (void *) pddpf->dwStencilBitDepth; + } + + *dbgout << endl; + + iddpfnum++; +} +#endif + +// pops up MsgBox w/system error msg +#define LAST_ERROR 0 +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); + wdxdisplay_cat.fatal() << "System error msg: " << pMessageBuffer << endl; + LocalFree( pMessageBuffer ); +} + +//#if defined(NOTIFY_DEBUG) || defined(DO_PSTATS) +#ifdef _DEBUG +extern void dbgPrintVidMem(LPDIRECTDRAW7 pDD, LPDDSCAPS2 lpddsCaps,const char *pMsg) { + DWORD dwTotal,dwFree; + HRESULT hr; + + // These Caps bits arent allowed to be specified when calling GetAvailVidMem. + // They don't affect surface allocation in a vram heap. + +#define AVAILVIDMEM_BADCAPS (DDSCAPS_BACKBUFFER | \ + DDSCAPS_FRONTBUFFER | \ + DDSCAPS_COMPLEX | \ + DDSCAPS_FLIP | \ + DDSCAPS_OWNDC | \ + DDSCAPS_PALETTE | \ + DDSCAPS_SYSTEMMEMORY | \ + DDSCAPS_VISIBLE | \ + DDSCAPS_WRITEONLY) + + DDSCAPS2 ddsCaps = *lpddsCaps; + ddsCaps.dwCaps &= ~(AVAILVIDMEM_BADCAPS); // turn off the bad caps +// ddsCaps.dwCaps |= DDSCAPS_VIDEOMEMORY; done internally by DX anyway + + if(FAILED( hr = pDD->GetAvailableVidMem(&ddsCaps,&dwTotal,&dwFree))) { + wdxdisplay_cat.debug() << "GetAvailableVidMem failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + // Write a debug message to the console reporting the texture memory. + char tmpstr[100],tmpstr2[100]; + sprintf(tmpstr,"%.4g",dwTotal/1000000.0); + sprintf(tmpstr2,"%.4g",dwFree/1000000.0); + if(wdxdisplay_cat.is_debug()) + wdxdisplay_cat.debug() << "AvailableVidMem before creating "<< pMsg << ",(megs) total: " << tmpstr << " free:" << tmpstr2 <DestroyMe(bAtExitFnCalled); + } +} + +void AtExitFn() { +#ifdef _DEBUG + wdxdisplay_cat.spam() << "AtExitFn called\n"; +#endif + + restore_global_parameters(); + + DestroyAllWindows(true); +} + +//////////////////////////////////////////////////////////////////// +// Function: wdxGraphicsWindow::set_window_handle +// Access: Public +// Description: This is called on the object once the actual Window +// has been created. It gives the window handle of the +// created window so the wdxGraphicsWindow object can +// perform any additional initialization based on this. +//////////////////////////////////////////////////////////////////// +void wdxGraphicsWindow:: +set_window_handle(HWND hwnd) { + // Tell the associated dxGSG about the window handle. + _dxgsg->scrn.hWnd = hwnd; + + // Determine the initial open status of the IME. + _ime_open = false; + _ime_active = false; + HIMC hIMC = ImmGetContext(hwnd); + if (hIMC != 0) { + _ime_open = (ImmGetOpenStatus(hIMC) != 0); + ImmReleaseContext(hwnd, hIMC); + } +} + +//////////////////////////////////////////////////////////////////// +// 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()) { + wdxGraphicsWindow *wdxwinptr=(*pwin).second; + return wdxwinptr->window_proc(hwnd, msg, wparam, lparam); + } else if(global_wdxwinptr!=NULL){ + // this stuff should only be used during CreateWindow() + return global_wdxwinptr->window_proc(hwnd, msg, wparam, lparam); + } else { + // should never need this?? (maybe at shutdwn?) + return DefWindowProc(hwnd, msg, wparam, lparam); + } +} + +// 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 wdxGraphicsWindow:: +track_mouse_leaving(HWND hwnd) { + if(_pParentWindowGroup->_pfnTrackMouseEvent==NULL) + return; + + TRACKMOUSEEVENT tme = {sizeof(TRACKMOUSEEVENT),TME_LEAVE,hwnd,0}; + BOOL bSucceeded = _pParentWindowGroup->_pfnTrackMouseEvent(&tme); // tell win32 to post WM_MOUSELEAVE msgs + + if((!bSucceeded) && wdxdisplay_cat.is_debug()) + wdxdisplay_cat.debug() << "TrackMouseEvent failed!, LastError=" << GetLastError() << endl; + + _tracking_mouse_leaving=true; +} + +//////////////////////////////////////////////////////////////////// +// Function: window_proc +// Access: +// Description: +//////////////////////////////////////////////////////////////////// +LONG wdxGraphicsWindow:: +window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam) { + int button = -1; + int x, y, width, height; + + switch(msg) { + case WM_PAINT: { + PAINTSTRUCT ps; + BeginPaint(hwnd, &ps); + if(DXREADY) + _dxgsg->show_frame(); + EndPaint(hwnd, &ps); + return 0; + } + + case WM_MOUSEMOVE: + if(!DXREADY) + break; + + // 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); + return 0; + + // if cursor is invisible, make it visible when moving in the window bars,etc + case WM_NCMOUSEMOVE: { + if(!_props._bCursorIsVisible) { + if(!_cursor_in_windowclientarea) { + ShowCursor(true); + _cursor_in_windowclientarea=true; + } + } + break; + } + + case WM_NCMOUSELEAVE: { + if(!_props._bCursorIsVisible) { + ShowCursor(false); + _cursor_in_windowclientarea=false; + } + break; + } + + case WM_MOUSELEAVE: { + // wdxdisplay_cat.fatal() << "XXXXX WM_MOUSELEAVE received\n"; + + _tracking_mouse_leaving=false; + handle_mouse_entry(false,0,0); + break; + } + + case WM_CREATE: { + track_mouse_leaving(hwnd); + + _cursor_in_windowclientarea=false; + if(!_props._bCursorIsVisible) + ShowCursor(false); + break; + } + + 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: + // In case we're running fullscreen mode, we have to turn on + // explicit DX support for overlay windows now, so we'll be able + // to see the IME window. + _dxgsg->support_overlay_window(true); + _ime_active = true; + break; + + case WM_IME_ENDCOMPOSITION: + // Turn off the support for overlay windows, since we're done + // with the IME window for now and it just slows things down. + _dxgsg->support_overlay_window(false); + _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(!DXREADY) + break; + + 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); + return 0; + + case WM_LBUTTONUP: + button = 0; + case WM_MBUTTONUP: + if(button < 0) + button = 1; + case WM_RBUTTONUP: + if(!DXREADY) + break; + + 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)); + return 0; + + case WM_MOVE: + if(!DXREADY) + break; + handle_window_move(LOWORD(lparam), HIWORD(lparam) ); + return 0; + + case WM_EXITSIZEMOVE: + #ifdef _DEBUG + wdxdisplay_cat.spam() << "WM_EXITSIZEMOVE received" << endl; + #endif + + if(_WindowAdjustingType==Resizing) { + handle_reshape(true); + } + + _WindowAdjustingType = NotAdjusting; + return 0; + + case WM_ENTERSIZEMOVE: { + if(_dxgsg!=NULL) + _dxgsg->SetDXReady(true); // dont disable here because I want to see pic as I resize + _WindowAdjustingType = MovingOrResizing; + } + break; + + case WM_DISPLAYCHANGE: { + #ifdef _DEBUG + width = LOWORD(lparam); height = HIWORD(lparam); + DWORD newbitdepth=wparam; + wdxdisplay_cat.spam() <<"WM_DISPLAYCHANGE received with width:" << width << " height: " << height << " bpp: " << wparam<< endl; + #endif + + // unfortunately this doesnt seem to work because RestoreAllSurfaces doesn't + // seem to think we're back in the original displaymode even after I've received + // the WM_DISPLAYCHANGE msg, and returns WRONGMODE error. So the only way I can + // think of to make this work is to have the timer periodically check for restored + // coop level + + // if(_props._fullscreen && !_window_active) { + // if(_dxgsg!=NULL) + // _dxgsg->CheckCooperativeLevel(DO_REACTIVATE_WINDOW); + // else reactivate_window(); + // } + + // does the windowed case handle displaychange properly? no. need to recreate all devices + } + break; + + case WM_SIZE: { + #ifdef _DEBUG + { + width = LOWORD(lparam); height = HIWORD(lparam); + wdxdisplay_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 + // old comment -- added SIZE_RESTORED to handle 3dfx case + if(dx_full_screen || ((_dxgsg==NULL) || (_dxgsg->scrn.hWnd==NULL)) || ((wparam != SIZE_RESTORED) && (wparam != SIZE_MAXIMIZED))) + break; + + width = LOWORD(lparam); height = HIWORD(lparam); + + if((_props._xsize != width) || (_props._ysize != height)) { + _WindowAdjustingType = Resizing; + + // for maximized,unmaximize, need to call resize code artificially + // since no WM_EXITSIZEMOVE is generated. + if(wparam==SIZE_MAXIMIZED) { + _bSizeIsMaximized=TRUE; + window_proc(hwnd, WM_EXITSIZEMOVE, 0x0,0x0); + } else if((wparam==SIZE_RESTORED) && _bSizeIsMaximized) { + _bSizeIsMaximized=FALSE; // only want to reinit dx if restoring from maximized state + window_proc(hwnd, WM_EXITSIZEMOVE, 0x0,0x0); + } + } + + break; + } + + case WM_SETFOCUS: { + if(!DXREADY) { + break; + } + + 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 + + int i; + for(i=0;iflags << endl; + break; + } + + case WM_GETMINMAXINFO: + wdxdisplay_cat.spam() << "WM_GETMINMAXINFO received\n" << endl; + break; +#endif + + case WM_ERASEBKGND: + // WM_ERASEBKGND will be ignored during resizing, because + // we dont want to redraw as user is manually resizing window + if(_WindowAdjustingType) + break; + return 0; // dont let GDI waste time redrawing the deflt background + + case WM_TIMER: + // 2 cases of app deactivation: + // + // 1) user has switched out of fullscreen mode + // this is first signalled when ACTIVATEAPP returns false + // for this case, we dont wake up until WM_SIZE returns restore or maximize + // and WM_TIMER just periodically reawakens app for idle processing + + // unfortunately this doesnt seem to work because RestoreAllSurfaces doesn't + // seem to think we're back in the original displaymode even after I've received + // the WM_DISPLAYCHANGE msg, and returns WRONGMODE error. So the only way I can + // think of to make this work is to have the timer periodically check for restored + // coop level, as it does in case 2) + + // + // 2) windowed app has lost access to dx because another app has taken dx exclusive mode + // here we rely on WM_TIMER to periodically check if it is ok to reawaken app. + // windowed apps currently run regardless of if its window is in the foreground + // so we cannot rely on window messages to reawaken app + + if((wparam==_PandaPausedTimer) && (!_window_active||_active_minimized_fullscreen)) { + assert(_dxgsg!=NULL); + _dxgsg->CheckCooperativeLevel(DO_REACTIVATE_WINDOW); + + // wdxdisplay_cat.spam() << "periodic return of 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? + } + return 0; + + case WM_CLOSE: + // close_window(); + delete _pParentWindowGroup; + + // 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 # windows==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); + } + return 0; + + + case WM_ACTIVATEAPP: { + #ifdef _DEBUG + wdxdisplay_cat.spam() << "WM_ACTIVATEAPP(" << (bool)(wparam!=0) <<") received\n"; + #endif + + if((!wparam) && _props._fullscreen) { + deactivate_window(); + return 0; + } // dont want to reactivate until window is actually un-minimized (see WM_SIZE) + break; + } + } + + return DefWindowProc(hwnd, msg, wparam, lparam); +} + + +//////////////////////////////////////////////////////////////////// +// Function: handle_reshape +// Access: +// Description: +//////////////////////////////////////////////////////////////////// +void wdxGraphicsWindow::handle_reshape(bool bDoDxReset) { + + GdiFlush(); + + if(bDoDxReset && _dxgsg!=NULL) { + HRESULT hr; + + if(_dxgsg->scrn.pddsBack==NULL) { + //assume this is initial creation reshape and ignore this call + return; + } + + // Clear the back/primary surface to black + DX_DECLARE_CLEAN(DDBLTFX, bltfx) + bltfx.dwDDFX |= DDBLTFX_NOTEARING; + hr = _dxgsg->scrn.pddsPrimary->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&bltfx); + if(FAILED( hr )) { + wdxdisplay_cat.fatal() << "Blt to Black of Primary Surf failed! : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(FAILED(hr = _dxgsg->scrn.pDD->TestCooperativeLevel())) { + wdxdisplay_cat.error() << "TestCooperativeLevel failed : result = " << ConvD3DErrorToString(hr) << endl; + return; + } + + _dxgsg->SetDXReady(false); // disable rendering whilst we mess with surfs + + _dxgsg->RestoreAllVideoSurfaces(); + + // Want to change rendertarget size without destroying d3d device. To save vid memory + // (and make resizing work on memory-starved 4MB cards), we need to construct + // a temporary mini-sized render target for the d3d device (it cannot point to a + // NULL rendertarget) before creating the fully resized buffers. The old + // rendertargets will be freed when these temp targets are set, and that will give + // us the memory to create the resized target + + LPDIRECTDRAWSURFACE7 pddsDummy = NULL, pddsDummyZ = NULL; + ULONG refcnt; + + DX_DECLARE_CLEAN( DDSURFACEDESC2, ddsd ); + + _dxgsg->scrn.pddsBack->GetSurfaceDesc(&ddsd); + LPDIRECTDRAW7 pDD = _dxgsg->scrn.pDD; + + ddsd.dwFlags &= ~DDSD_PITCH; + ddsd.dwWidth = 1; ddsd.dwHeight = 1; + ddsd.ddsCaps.dwCaps &= ~(DDSCAPS_COMPLEX | DDSCAPS_FLIP | DDSCAPS_FRONTBUFFER | DDSCAPS_BACKBUFFER); + + PRINTVIDMEM(pDD,&ddsd.ddsCaps,"dummy backbuf"); + + if(FAILED( hr = pDD->CreateSurface( &ddsd, &pddsDummy, NULL ) )) { + wdxdisplay_cat.fatal() << "Resize CreateSurface for temp backbuf failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(_dxgsg->scrn.pddsZBuf!=NULL) { + DX_DECLARE_CLEAN( DDSURFACEDESC2, ddsdZ ); + _dxgsg->scrn.pddsZBuf->GetSurfaceDesc(&ddsdZ); + ddsdZ.dwFlags &= ~DDSD_PITCH; + ddsdZ.dwWidth = 1; ddsdZ.dwHeight = 1; + + PRINTVIDMEM(pDD,&ddsdZ.ddsCaps,"dummy zbuf"); + + if(FAILED( hr = pDD->CreateSurface( &ddsdZ, &pddsDummyZ, NULL ) )) { + wdxdisplay_cat.fatal() << "Resize CreateSurface for temp zbuf failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(FAILED( hr = pddsDummy->AddAttachedSurface( pddsDummyZ ) )) { + wdxdisplay_cat.fatal() << "Resize AddAttachedSurf for temp zbuf failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + } + + if(FAILED( hr = _dxgsg->scrn.pD3DDevice->SetRenderTarget( pddsDummy, 0x0 ))) { + wdxdisplay_cat.fatal() + << "Resize failed to set render target to temporary surface, result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + RELEASE(pddsDummyZ,wdxdisplay,"dummy resize zbuffer",false); + RELEASE(pddsDummy,wdxdisplay,"dummy resize rendertarget buffer",false); + } + + RECT view_rect; + + assert(!dx_full_screen); + + HWND hWnd=_dxgsg->scrn.hWnd; + GetClientRect( hWnd, &view_rect ); + ClientToScreen( hWnd, (POINT*)&view_rect.left ); // translates top,left pnt + ClientToScreen( hWnd, (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(wdxdisplay_cat.is_spam()) { + wdxdisplay_cat.spam() << "reshape to origin: (" << _props._xorg << "," << _props._yorg << "), size: (" << _props._xsize << "," << _props._ysize << ")\n"; + } + + if(_dxgsg!=NULL) { + if(bDoDxReset) + _dxgsg->dx_setup_after_resize(view_rect,hWnd); // create the new resized rendertargets + _dxgsg->SetDXReady(true); + } +} + +void wdxGraphicsWindow::deactivate_window(void) { + // current policy is to suspend minimized or deactivated fullscreen windows, but leave + // regular windows running normally + + if(!_window_active || _exiting_window || _active_minimized_fullscreen) { + #ifdef _DEBUG + if(wdxdisplay_cat.is_spam()) + wdxdisplay_cat.spam() << "deactivate_window called, but ignored in current mode\n"; + #endif + return; + } + + if(bResponsive_minimized_fullscreen_window) { + if(wdxdisplay_cat.is_spam()) + wdxdisplay_cat.spam() << "WDX fullscreen window switching to active minimized mode...\n"; + _active_minimized_fullscreen = true; + } else { + + if(wdxdisplay_cat.is_spam()) + wdxdisplay_cat.spam() << "WDX window deactivated, waiting...\n"; + + _window_active = false; + } + + if(_props._fullscreen) { + // make sure window is minimized + + WINDOWPLACEMENT wndpl; + wndpl.length=sizeof(WINDOWPLACEMENT); + if(!GetWindowPlacement(_dxgsg->scrn.hWnd,&wndpl)) { + wdxdisplay_cat.error() << "GetWindowPlacement failed!\n"; + return; + } + + if((wndpl.showCmd!=SW_MINIMIZE)&&(wndpl.showCmd!=SW_SHOWMINIMIZED)) { + ShowWindow(_dxgsg->scrn.hWnd, SW_MINIMIZE); + } + + throw_event("PandaPaused"); // right now this is used to signal python event handler to disable audio + } + +// if(!bResponsive_minimized_fullscreen_window) { + // need this even in responsive-mode to trigger the dxgsg check of cooplvl, i think? + + _PandaPausedTimer = SetTimer(_dxgsg->scrn.hWnd,PAUSED_TIMER_ID,500,NULL); + if(_PandaPausedTimer!=PAUSED_TIMER_ID) { + wdxdisplay_cat.error() << "Error in SetTimer!\n"; + } +// } +} + +void wdxGraphicsWindow::reactivate_window(void) { + if(!_window_active) { + + // first see if dx cooperative level is OK for reactivation + // if(!_dxgsg->CheckCooperativeLevel()) + // return; + + if(wdxdisplay_cat.is_spam()) + wdxdisplay_cat.spam() << "WDX window re-activated...\n"; + + _window_active = true; + + if(_PandaPausedTimer!=NULL) { + KillTimer(_dxgsg->scrn.hWnd,_PandaPausedTimer); + _PandaPausedTimer = NULL; + } + + // move window to top of zorder + // if(_props._fullscreen) + // SetWindowPos(_DisplayDataArray[0].hWnd, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER); + GdiFlush(); + + } else if(_active_minimized_fullscreen) { + if(wdxdisplay_cat.is_spam()) + wdxdisplay_cat.spam() << "WDX window unminimized from active-minimized state...\n"; + + if(_PandaPausedTimer!=NULL) { + KillTimer(_dxgsg->scrn.hWnd,_PandaPausedTimer); + _PandaPausedTimer = NULL; + } + + _active_minimized_fullscreen = false; + + // move window to top of zorder + // if(_props._fullscreen) + // SetWindowPos(_DisplayDataArray[0].hWnd, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE | SWP_NOOWNERZORDER); + GdiFlush(); + } + + if(_props._fullscreen) { + throw_event("PandaRestarted"); // right now this is used to signal python event handler to re-enable audio + } +} + +//////////////////////////////////////////////////////////////////// +// Function: Constructor +// Access: +// Description: +//////////////////////////////////////////////////////////////////// +wdxGraphicsWindow::wdxGraphicsWindow(GraphicsPipe* pipe) : GraphicsWindow(pipe) { + _ime_active = false; + _pParentWindowGroup=NULL; + _pParentWindowGroup=new wdxGraphicsWindowGroup(this); +} + +//////////////////////////////////////////////////////////////////// +// Function: Constructor +// Access: +// Description: +//////////////////////////////////////////////////////////////////// +wdxGraphicsWindow::wdxGraphicsWindow(GraphicsPipe* pipe, const GraphicsWindow::Properties& props) + : GraphicsWindow(pipe, props) { + _ime_open = false; + _pParentWindowGroup=NULL; + _pParentWindowGroup=new wdxGraphicsWindowGroup(this); +} + +bool supports_color_cursors(DDDEVICEIDENTIFIER2 &DevID) { + // TODO: add more cards as more testing is done + if(IS_NVIDIA(DevID)) { + // all nvidia seem to support 256 color + return true; + } else if(IS_ATI(DevID)) { + // radeons seem to be in the 5100 range and support color, assume anything in 6000 or above + // is newer than radeon and supports 256 color + if(((DevID.dwDeviceId>=0x5100) && (DevID.dwDeviceId<=0x5200)) || + (DevID.dwDeviceId>=0x6000)) + return true; + } else if IS_MATROX(DevID) { + if(DevID.dwDeviceId==0x0525) // G400 seems to support color cursors, havent tested other matrox + return true; + } + + return false; +} + +void wdxGraphicsWindowGroup::CreateWindows(void) { + HINSTANCE hProgramInstance = GetModuleHandle(NULL); + WNDCLASS wc; + static bool wc_registered = false; + _hParentWindow = NULL; + + // 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); + + _pfnGetMonitorInfo = (PFN_GETMONITORINFO) GetProcAddress(hUser32, "GetMonitorInfoA"); + _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 = hProgramInstance; + + string windows_icon_filename = get_icon_filename().to_os_specific(); + string windows_mono_cursor_filename = get_mono_cursor_filename().to_os_specific(); + string windows_color_cursor_filename = get_color_cursor_filename().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) { + wdxdisplay_cat.warning() << "windows icon filename '" << windows_icon_filename << "' not found!!\n"; + } + } else { + wc.hIcon = NULL; // use default app icon + } + + _bLoadedCustomCursor=false; + _hMouseCursor=NULL; + + if(!windows_color_cursor_filename.empty()) { + // card support for full color 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 the lack of HW support 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 (this is done automatically by DX8 runtime mouse cursor support), or to have separate thread draw cursor + // (sync issues?). instead we do mono cursor unless card is known to support 256 color cursors + bool bSupportsColorCursor=true; + + /* if any card doesnt support color, dont load it*/ + for(DWORD w=0;w<_windows.size();w++) + bSupportsColorCursor &= supports_color_cursors(_windows[w]->_dxgsg->scrn.DXDeviceID); + + if(bSupportsColorCursor) { + DWORD load_flags = LR_LOADFROMFILE; + + if(dx_full_screen) { + // 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: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings) + // if icon is more than 8bpp + + // loads a .cur fmt file. + _hMouseCursor = (HCURSOR) LoadImage(NULL, windows_color_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags ); + + if(_hMouseCursor==NULL) { + wdxdisplay_cat.warning() << "windows color cursor filename '" << windows_color_cursor_filename << "' not found!!\n"; + goto try_mono_cursor; + + } + +/* dont need these anymore since we are do mousestuff before window creation + SetClassLongPtr(_mwindow, GCLP_HCURSOR, (LONG_PTR) hNewMouseCursor); + SetCursor(hNewMouseCursor); + + if(_bLoadedCustomCursor) + DestroyCursor(_hMouseCursor); +*/ + _bLoadedCustomCursor=true; + } + } + + try_mono_cursor: + + if((!_bLoadedCustomCursor) && (!windows_mono_cursor_filename.empty())) { + // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings) + // if icon is more than 8bpp + + DWORD load_flags = LR_LOADFROMFILE; + + if(dx_full_screen) { + // 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) { + wdxdisplay_cat.warning() << "windows mono cursor filename '" << windows_mono_cursor_filename << "' not found!!\n"; + } else _bLoadedCustomCursor=true; + } + + if(!_bLoadedCustomCursor) + _hMouseCursor = LoadCursor(NULL, DEFAULT_CURSOR); + + if (!wc_registered) { + // We only need to register the window class once per session. + wc.hCursor = _hMouseCursor; + wc.hbrBackground = (HBRUSH)GetStockObject(BLACK_BRUSH); + wc.lpszMenuName = NULL; + wc.lpszClassName = WDX_WINDOWCLASSNAME; + + if(!RegisterClass(&wc)) { + wdxdisplay_cat.error() << "could not register window class!" << endl; + } + wc_registered = true; + } + + DWORD window_style = WS_POPUP | WS_SYSMENU; // for CreateWindow + + global_wdxwinptr = _windows[0]; // for use during createwin() bugbug look at this again + + // rect now contains the coords for the entire window, not the client + if(dx_full_screen) { + + // extra windows must be parented to the first so app doesnt minimize when user selects them + for(DWORD devnum=0;devnum<_windows.size();devnum++) { + MONITORINFO minfo; + ZeroMemory(&minfo, sizeof(MONITORINFO)); + minfo.cbSize = sizeof(MONITORINFO); + if(_pfnGetMonitorInfo!=NULL) + // get upper-left corner coords using GetMonitorInfo + (*_pfnGetMonitorInfo)(_windows[devnum]->_dxgsg->scrn.hMon, &minfo); + else { + minfo.rcMonitor.left = minfo.rcMonitor.top = 0; + } + + GraphicsWindow::Properties *props = &_windows[devnum]->_props; + + wdxdisplay_cat.info() << "opening " << props->_xsize << "x" << props->_ysize << " fullscreen window\n"; + + HWND hWin = CreateWindow(WDX_WINDOWCLASSNAME, props->_title.c_str(), + window_style, minfo.rcMonitor.left, minfo.rcMonitor.top, + props->_xsize,props->_ysize, + _hParentWindow, NULL, hProgramInstance, 0); + + if(!hWin) { + wdxdisplay_cat.fatal() << "CreateWindow failed for monitor " << devnum << "!, LastError=" << GetLastError() << endl; + #ifdef _DEBUG + PrintErrorMessage(LAST_ERROR); + #endif + exit(1); + } + + _windows[devnum]->set_window_handle(hWin); + if(devnum==0) { + _hParentWindow=hWin; + } + } + } else { + assert(_windows.size()==1); + + GraphicsWindow::Properties *props = &_windows[0]->_props; + + 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; // should we just use WS_THICKFRAME instead? + + AdjustWindowRect(&win_rect, window_style, FALSE); //compute window size based on desired client area size + + // make sure origin is on screen + if(win_rect.left < 0) { + win_rect.right -= win_rect.left; win_rect.left = 0; + } + if(win_rect.top < 0) { + win_rect.bottom -= win_rect.top; win_rect.top = 0; + } + + UINT xsize = win_rect.right-win_rect.left; + UINT ysize = win_rect.bottom-win_rect.top; + + wdxdisplay_cat.info() << "opening " << props->_xsize << "x" << props->_ysize << " regular window\n"; + + _hParentWindow = + CreateWindow(WDX_WINDOWCLASSNAME, props->_title.c_str(), + window_style, win_rect.left, win_rect.top, xsize,ysize, + NULL, NULL, hProgramInstance, 0); + _windows[0]->set_window_handle(_hParentWindow); + } + + if(_hParentWindow==NULL) { + wdxdisplay_cat.fatal() << "CreateWindow failed!\n"; + exit(1); + } + + for(DWORD devnum=0;devnum<_windows.size();devnum++) { + wdxGraphicsWindow *pWDXWin = _windows[devnum]; + // for use by the window_proc + hwnd_pandawin_map[pWDXWin->_dxgsg->scrn.hWnd] = pWDXWin; + +/* + // DC is mostly used for writing fps meter (but also old palette code, which needs updating) + // probably only need to do this for devnum 0 + HDC hdc = GetDC(pWDXWin->_dxgsg_>scrn.hWnd); + pWDXWin->_dxgsg->Set_HDC(hdc); +*/ + } + + // now we can stop using the global_wdxwinptr crutch since windows are created + global_wdxwinptr = NULL; // get rid of any reference to this obj +} + +//////////////////////////////////////////////////////////////////// +// Function: config +// Access: +// Description: Set up win32 window. +//////////////////////////////////////////////////////////////////// +void wdxGraphicsWindow::config_window(wdxGraphicsWindowGroup *pParentGroup) { +// assert(_pParentWindowGroup==NULL); + _pParentWindowGroup=pParentGroup; + + GraphicsWindow::config(); + + _hdc = NULL; + _gsg = _dxgsg = NULL; + _exiting_window = false; + _window_active = true; + _return_control_to_app = false; + _active_minimized_fullscreen = false; + + if(dx_full_screen || _props._fullscreen) { + _props._fullscreen = dx_full_screen = true; + } + + _WindowAdjustingType = NotAdjusting; + _bSizeIsMaximized=FALSE; + + _gsg = _dxgsg = NULL; + // Create a GSG to manage the graphics + if(_gsg==NULL) { + make_gsg(); + if(_gsg==NULL) { + wdxdisplay_cat.error() << "make_gsg() failed!\n"; + exit(1); + } + } + _dxgsg = DCAST(DXGraphicsStateGuardian, _gsg); + + // 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; +} + +void wdxGraphicsWindow::finish_window_setup(void) { + // Now indicate that we have our keyboard/mouse device ready. + GraphicsWindowInputDevice device = GraphicsWindowInputDevice::pointer_and_keyboard("keyboard/mouse"); + _input_devices.push_back(device); + + // move windows to top of zorder + HWND hWin = _dxgsg->scrn.hWnd; + + SetWindowPos(hWin, HWND_TOP, 0,0,0,0, SWP_NOMOVE | SWP_NOSENDCHANGING | SWP_NOSIZE); + // call twice to override STARTUPINFO value, which may be set to hidden initially (by emacs for instance) + ShowWindow(hWin, SW_SHOWNORMAL); + ShowWindow(hWin, SW_SHOWNORMAL); + // UpdateWindow( _mwindow ); +} + + + +HRESULT CALLBACK EnumDevicesCallback(LPSTR pDeviceDescription, LPSTR pDeviceName, + LPD3DDEVICEDESC7 pD3DDeviceDesc,LPVOID pContext) { + D3DDEVICEDESC7 *pd3ddevs = (D3DDEVICEDESC7 *)pContext; +#ifdef _DEBUG + wdxdisplay_cat.spam() << "Enumerating Device " << pDeviceName << " : " << pDeviceDescription << endl; +#endif + + +#define REGHALIDX 0 +#define TNLHALIDX 1 +#define SWRASTIDX 2 + + if(IsEqualGUID(pD3DDeviceDesc->deviceGUID,IID_IDirect3DHALDevice)) { + CopyMemory(&pd3ddevs[REGHALIDX],pD3DDeviceDesc,sizeof(D3DDEVICEDESC7)); + } else if(IsEqualGUID(pD3DDeviceDesc->deviceGUID,IID_IDirect3DTnLHalDevice)) { + CopyMemory(&pd3ddevs[TNLHALIDX],pD3DDeviceDesc,sizeof(D3DDEVICEDESC7)); + } else if(IsEqualGUID(pD3DDeviceDesc->deviceGUID,IID_IDirect3DRGBDevice)) { + CopyMemory(&pd3ddevs[SWRASTIDX],pD3DDeviceDesc,sizeof(D3DDEVICEDESC7)); + } + return DDENUMRET_OK; +} + +#define MAX_DISPLAY_MODES 100 // probably dont need this much, since i already screen for width&hgt +typedef struct { + DWORD maxWidth,maxHeight; + DWORD supportedBitDepths; // uses DDBD_* flags + LPDDSURFACEDESC2 pDDSD_Arr; + DWORD cNumSurfDescs; +} DisplayModeInfo; + +HRESULT WINAPI EnumDisplayModesCallBack(LPDDSURFACEDESC2 lpDDSurfaceDesc,LPVOID lpContext) { + DisplayModeInfo *pDMI = (DisplayModeInfo *) lpContext; + + // ddsd_search should assure this is true + assert((lpDDSurfaceDesc->dwWidth == pDMI->maxWidth) && (lpDDSurfaceDesc->dwHeight == pDMI->maxHeight)); + + // ignore refresh rates under 60Hz (and special values of 0 & 1) + if((lpDDSurfaceDesc->dwRefreshRate>1) && (lpDDSurfaceDesc->dwRefreshRate<60)) + return DDENUMRET_OK; + + assert(pDMI->cNumSurfDescs < MAX_DISPLAY_MODES); + memcpy( &(pDMI->pDDSD_Arr[pDMI->cNumSurfDescs]), lpDDSurfaceDesc, sizeof(DDSURFACEDESC2) ); + pDMI->cNumSurfDescs++; + pDMI->supportedBitDepths |= BitDepth_2_DDBDMask(lpDDSurfaceDesc->ddpfPixelFormat.dwRGBBitCount); + + return DDENUMRET_OK; +} + +/* +BOOL WINAPI DriverEnumCallback_Voodoo1( GUID* pGUID, TCHAR* strDesc,TCHAR* strName, + VOID *argptr, HMONITOR hm) { + + if(hm!=NULL) // skip over non-primary and non-voodoo-type display devices + return DDENUMRET_OK; + + GUID null_guid; + ZeroMemory(&null_guid,sizeof(GUID)); + + // primary display driver will have NULL guid + // ignore that and save any non-null value, which + // indicates a secondary driver, which is usually voodoo1/2 + if((pGUID!=NULL) && !IsEqualGUID(null_guid,*pGUID)) { + memcpy(argptr,pGUID,sizeof(GUID)); + } + + return DDENUMRET_OK; +} +*/ + +BOOL WINAPI save_devinfo( GUID* pGUID, TCHAR* strDesc,TCHAR* strName,VOID *argptr, HMONITOR hm) { + + DXDeviceInfoVec *pDevInfoArr = (DXDeviceInfoVec *) argptr; + + DXDeviceInfo devinfo; + ZeroMemory(&devinfo,sizeof(devinfo)); + + // primary display driver will have NULL guid + if(pGUID!=NULL) { + memcpy(&devinfo.guidDeviceIdentifier,pGUID,sizeof(GUID)); + } + if(strDesc!=NULL) { + _tcsncpy(devinfo.szDescription, + strDesc, + MAX_DDDEVICEID_STRING); + } + if(strName!=NULL) { + _tcsncpy(devinfo.szDriver,strName,MAX_DDDEVICEID_STRING); + } + devinfo.hMon=hm; + + pDevInfoArr->push_back(devinfo); + return DDENUMRET_OK; +} + +BOOL WINAPI DriverEnumCallback_MultiMon( GUID* pGUID, TCHAR* strDesc,TCHAR* strName,VOID *argptr, HMONITOR hm) { + if(hm==NULL) { + // skip over the 'primary' since it will duplicated later as an explicit device + return DDENUMRET_OK; + } + + return save_devinfo(pGUID,strDesc,strName,argptr,hm); +} + +bool wdxGraphicsWindow::resize(unsigned int xsize,unsigned int ysize) { + + if (!_props._fullscreen) { + if(wdxdisplay_cat.is_debug()) + wdxdisplay_cat.debug() << "resize("<scrn.hWnd, NULL, 0,0, xsize, ysize, SWP_NOZORDER | SWP_NOMOVE | SWP_NOSENDCHANGING); + // WM_ERASEBKGND will be ignored, because _WindowAdjustingType!=NotAdjusting because + // we dont want to redraw as user is manually resizing window, so need to force explicit + // background clear for the programmatic resize fn call + _WindowAdjustingType=NotAdjusting; + + // this doesnt seem to be working in toontown resize, so I put ddraw blackblt in handle_reshape instead + //window_proc(_mwindow, WM_ERASEBKGND,(WPARAM)_hdc,0x0); + handle_reshape(true); + return true; + } + + if(wdxdisplay_cat.is_info()) + wdxdisplay_cat.info() << "resize("<SetDXReady(false); + + HRESULT hr; + + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd_curmode); + + if(FAILED(hr = _dxgsg->scrn.pDD->GetDisplayMode(&ddsd_curmode))) { + wdxdisplay_cat.fatal() << "resize() - GetDisplayMode failed, result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd_search); + + ddsd_search.dwFlags = DDSD_HEIGHT | DDSD_WIDTH; + ddsd_search.dwWidth=xsize; ddsd_search.dwHeight=ysize; + + // not requesting same refresh rate since changing res might not support same refresh rate + + DDSURFACEDESC2 DDSD_Arr[MAX_DISPLAY_MODES]; + DisplayModeInfo DMI; + ZeroMemory(&DDSD_Arr,sizeof(DDSD_Arr)); + ZeroMemory(&DMI,sizeof(DMI)); + DMI.maxWidth=xsize; DMI.maxHeight=ysize; + DMI.pDDSD_Arr=DDSD_Arr; + + if(FAILED(hr = _dxgsg->scrn.pDD->EnumDisplayModes(DDEDM_REFRESHRATES,&ddsd_search,&DMI,EnumDisplayModesCallBack))) { + wdxdisplay_cat.fatal() << "resize() - EnumDisplayModes failed, result = " << ConvD3DErrorToString(hr) << endl; + return false; + } + + DMI.supportedBitDepths &= _dxgsg->scrn.D3DDevDesc.dwDeviceRenderBitDepth; + + DWORD dwFullScreenBitDepth; + DWORD requested_bpp=ddsd_curmode.ddpfPixelFormat.dwRGBBitCount; + + // would like to match current bpp first. if that is not possible, try 16bpp, then 32 + DWORD requested_bpp_DDBD = BitDepth_2_DDBDMask(requested_bpp); + + if(DMI.supportedBitDepths & requested_bpp_DDBD) { + dwFullScreenBitDepth=requested_bpp; + } else if(DMI.supportedBitDepths & DDBD_16) { + dwFullScreenBitDepth=16; + } else if(DMI.supportedBitDepths & DDBD_32) { + dwFullScreenBitDepth=32; + } else { + wdxdisplay_cat.error() + << "resize failed, no fullScreen resolutions at " << xsize << "x" << ysize << endl; + return false; + } + + if(FAILED(hr = _dxgsg->scrn.pDD->TestCooperativeLevel())) { + wdxdisplay_cat.error() << "TestCooperativeLevel failed : result = " << ConvD3DErrorToString(hr) << endl; + wdxdisplay_cat.error() << "Full screen app failed to get exclusive mode on resize, exiting..\n"; + return false; + } + + _dxgsg->free_dxgsg_objects(); + + // let driver choose default refresh rate (hopefully its >=60Hz) + if(FAILED( hr = _dxgsg->scrn.pDD->SetDisplayMode( xsize,ysize,dwFullScreenBitDepth, 0L, 0L ))) { + wdxdisplay_cat.error() << "resize failed to reset display mode to (" << xsize <<"x"<scrn.dwRenderWidth=xsize; + _dxgsg->scrn.dwRenderHeight=ysize; + + CreateScreenBuffersAndDevice(_dxgsg->scrn); + _dxgsg->RecreateAllVideoSurfaces(); + _dxgsg->SetDXReady(true); + return true; +} + + +// overrides of the general estimator for known working cases +bool wdxGraphicsWindow:: +special_check_fullscreen_resolution(UINT xsize,UINT ysize) { + // assert(IS_VALID_PTR(_dxgsg)); + + DWORD VendorId=_dxgsg->scrn.DXDeviceID.dwVendorId; + DWORD DeviceId=_dxgsg->scrn.DXDeviceID.dwDeviceId; + switch(VendorId) { + case 0x8086: // Intel + /*for now, just validate all the intel cards at these resolutions. + I dont have a complete list of deviceIDs (missing 82830, 845, etc) + // Intel i810,i815,82810 + if((DeviceId==0x7121)||(DeviceId==0x7123)||(DeviceId==0x7125)|| + (DeviceId==0x1132)) + */ + { + if((xsize==640)&&(ysize==480)) + return true; + if((xsize==800)&&(ysize==600)) + return true; + if((xsize==1024)&&(ysize==768)) + return true; + } + break; + } + + return false; +} + +unsigned int wdxGraphicsWindow:: +verify_window_sizes(unsigned int numsizes,unsigned int *dimen) { + DWORD num_valid_modes=0; + HRESULT hr; + + // not requesting same refresh rate since changing res might not support same refresh rate at new size + + DDSURFACEDESC2 DDSD_Arr[MAX_DISPLAY_MODES]; + DisplayModeInfo DMI; + DWORD i,*pCurDim=(DWORD *)dimen; + + for(i=0;iscrn.pDD->EnumDisplayModes(DDEDM_REFRESHRATES,&ddsd_search,&DMI,EnumDisplayModesCallBack))) { + wdxdisplay_cat.fatal() << "resize() - EnumDisplayModes failed, result = " << ConvD3DErrorToString(hr) << endl; + return 0; + } + + // get rid of bpp's we cant render at + DMI.supportedBitDepths &= _dxgsg->scrn.D3DDevDesc.dwDeviceRenderBitDepth; + + bool bIsGoodMode=false; + + if(DMI.supportedBitDepths & (DDBD_16 | DDBD_24 | DDBD_32)) { + if(special_check_fullscreen_resolution(xsize,ysize)) { + // bypass the test below for certain cards we know have valid modes + bIsGoodMode=true; + } else { + if(_dxgsg->scrn.bIsLowVidMemCard) + bIsGoodMode=(((float)xsize*(float)ysize)<=(float)(640*480)); + else { + // assume user is testing fullscreen, not windowed, so use the dwTotal value + // see if 3 scrnbufs (front/back/z)at 16bpp at xsize*ysize will fit with a few + // extra megs for texmem + + // 8MB Rage Pro says it has 6.8 megs Total free and will run at 1024x768, so + // formula makes it so that is OK + + #define REQD_TEXMEM 1800000.0f + + if(_dxgsg->scrn.MaxAvailVidMem==0) { + //assume buggy drivers return bad val of 0 and everything will be OK + bIsGoodMode=true; + } else { + bIsGoodMode = ((((float)xsize*(float)ysize)*6+REQD_TEXMEM) < (float)_dxgsg->scrn.MaxAvailVidMem); + } + } + } + } + + if(bIsGoodMode) + num_valid_modes++; + else { + pCurDim[0] = 0; + pCurDim[1] = 0; + } + } + + return num_valid_modes; +} + +/* +void wdxGraphicsWindow:: +check_for_color_cursor_support(void) { + // 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().to_os_specific(); + if(windows_color_cursor_filename.empty()) + return; + + bool bSupportsColorCursor=false; + + if(IS_NVIDIA(_DXDeviceID)) { + // all nvidia seem to support 256 color + bSupportsColorCursor=true; + } else if(IS_ATI(_DXDeviceID)) { + // radeons seem to be in the 5100 range and support color, assume anything in 6000 or above + // is newer than radeon and supports 256 color + if(((_DXDeviceID.dwDeviceId>=0x5100) && (_DXDeviceID.dwDeviceId<=0x5200)) || + (_DXDeviceID.dwDeviceId>=0x6000)) + bSupportsColorCursor=true; + } else if IS_MATROX(_DXDeviceID) { + if(_DXDeviceID.dwDeviceId==0x0525) // G400 seems to support color cursors, havent tested other matrox + bSupportsColorCursor=true; + } + + // TODO: add more cards as more testing is done + + if(bSupportsColorCursor) { + // Note: LoadImage seems to cause win2k internal heap corruption (outputdbgstr warnings) + // if icon is more than 8bpp + + DWORD load_flags = LR_LOADFROMFILE; + + if(dx_full_screen) { + // 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. + HCURSOR hNewMouseCursor = (HCURSOR) LoadImage(NULL, windows_color_cursor_filename.c_str(), IMAGE_CURSOR, 0, 0, load_flags ); + + if(hNewMouseCursor==NULL) { + wdxdisplay_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; + } +} +*/ + +// returns true if successful +bool wdxGraphicsWindow::search_for_device(int devnum,DXDeviceInfo *pDevinfo) { + DWORD dwRenderWidth = _props._xsize; + DWORD dwRenderHeight = _props._ysize; + LPDIRECTDRAW7 pDD=NULL; + HRESULT hr; + + assert(_dxgsg!=NULL); + + GUID *pDDDeviceGUID; + if(pDevinfo==NULL) + pDDDeviceGUID=NULL; + else pDDDeviceGUID=&pDevinfo->guidDeviceIdentifier; + + assert(_pParentWindowGroup->_pDDCreateEx!=NULL); + + // Create the Direct Draw Objects + hr = (*(_pParentWindowGroup->_pDDCreateEx))(pDDDeviceGUID,(void **)&pDD, IID_IDirectDraw7, NULL); + if((hr != DD_OK)||(pDD==NULL)) { + wdxdisplay_cat.fatal() << "DirectDrawCreateEx failed for monitor("<szDescription << "; DriverFile: '" << pDevID->szDriver + << "'; VendorID: 0x" << (void*)pDevID->dwVendorId + << "; DeviceID: 0x" << (void*)pDevID->dwDeviceId + << "; DriverVer: " + << HIWORD(pDevID->liDriverVersion.HighPart) << "." + << LOWORD(pDevID->liDriverVersion.HighPart) << "." + << HIWORD(pDevID->liDriverVersion.LowPart) << "." + << LOWORD(pDevID->liDriverVersion.LowPart) << endl; + } + + // Query DirectDraw for access to Direct3D + hr = pDD->QueryInterface( IID_IDirect3D7, (VOID**)&_dxgsg->scrn.pD3D); + if(hr != DD_OK) { + wdxdisplay_cat.fatal() << "QI for D3D failed : result = " << ConvD3DErrorToString(hr) << endl; + goto error_exit; + } + + D3DDEVICEDESC7 d3ddevs[3]; // put HAL in 0, TnLHAL in 1, SW rast in 2 + + // just look for HAL and TnL devices right now. I dont think + // we have any interest in the sw rasts at this point + + ZeroMemory(d3ddevs,3*sizeof(D3DDEVICEDESC7)); + + hr = _dxgsg->scrn.pD3D->EnumDevices(EnumDevicesCallback,d3ddevs); + if(hr != DD_OK) { + wdxdisplay_cat.fatal() << "EnumDevices failed : result = " << ConvD3DErrorToString(hr) << endl; + goto error_exit; + } + + WORD DeviceIdx; + + // select TNL if present + if(d3ddevs[TNLHALIDX].dwDevCaps & D3DDEVCAPS_HWRASTERIZATION) { + DeviceIdx=TNLHALIDX; + } else if(d3ddevs[REGHALIDX].dwDevCaps & D3DDEVCAPS_HWRASTERIZATION) { + DeviceIdx=REGHALIDX; + } else if(dx_allow_software_renderer || dx_force_software_renderer) { + DeviceIdx=SWRASTIDX; + } else { + wdxdisplay_cat.error() << "No 3D HW present on device #"<scrn.DXDeviceID.szDescription<<")\n"; + goto error_exit; + } + + if(dx_force_software_renderer) { + DeviceIdx=SWRASTIDX; + } + + memcpy(&_dxgsg->scrn.D3DDevDesc,&d3ddevs[DeviceIdx],sizeof(D3DDEVICEDESC7)); + + _dxgsg->scrn.bIsTNLDevice=(DeviceIdx==TNLHALIDX); + + // 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 + DDSCAPS2 ddsGAVMCaps; + DWORD dwVidMemTotal,dwVidMemFree; + dwVidMemTotal=dwVidMemFree=0; + ZeroMemory(&ddsGAVMCaps,sizeof(DDSCAPS2)); + ddsGAVMCaps.dwCaps = DDSCAPS_VIDEOMEMORY | DDSCAPS_LOCALVIDMEM; // dont count AGP mem! + if(FAILED(hr = pDD->GetAvailableVidMem(&ddsGAVMCaps,&dwVidMemTotal,&dwVidMemFree))) { + wdxdisplay_cat.error() << "GetAvailableVidMem failed for device #"<scrn.DXDeviceID.szDescription<<"), result = " << ConvD3DErrorToString(hr) << endl; + // goto skip_device; + exit(1); // probably want to exit, since it may be my fault + } + + if(wdxdisplay_cat.is_info()) + wdxdisplay_cat.info() << "Before fullscreen switch: GetAvailableVidMem for device #"<scrn.D3DDevDesc.dwDeviceRenderBitDepth; + + DWORD dwFullScreenBitDepth; + + // note: this chooses 32bpp, which may not be preferred over 16 for memory & speed reasons + if(DMI.supportedBitDepths & DDBD_32) { + dwFullScreenBitDepth=32; // go for 32bpp if its avail + } else if(DMI.supportedBitDepths & DDBD_24) { + dwFullScreenBitDepth=24; // go for 24bpp if its avail + } else if(DMI.supportedBitDepths & DDBD_16) { + dwFullScreenBitDepth=16; // do 16bpp + } else { + wdxdisplay_cat.fatal() << "No Supported FullScreen resolutions at " << dwRenderWidth << "x" << dwRenderHeight + << " for device #" << devnum << " (" << _dxgsg->scrn.DXDeviceID.szDescription<<"), skipping device...\n"; + goto error_exit; + } + + if(_dxgsg->scrn.bIsLowVidMemCard) { + { + // hack: figuring out exactly what res to use is tricky, instead I will + // just use 640x480 if we have < 3 meg avail + + dwFullScreenBitDepth=16; + dwRenderWidth=640; + dwRenderHeight=480; + dx_force_16bpptextures = true; + + if(wdxdisplay_cat.is_info()) + wdxdisplay_cat.info() << "Available VidMem (" << dwVidMemFree<<") is under " << LOWVIDMEMTHRESHOLD <<", using 640x480 16bpp rendertargets to save tex vidmem.\n"; + } + + #if 0 + /* + // cant use this method without more accurate way to estimate mem used before actually switching + // to that fullscrn mode. simply computing memsize based on GetDisplayMode doesnt seem + // to be accurate within more than 1 meg + + // we think we need to reserve at least 2 megs of vidmem for textures. + // to do this, reduce buffer bitdepth if possible + #define RESERVEDTEXVIDMEM 2000000 + + int rendertargetmem=dwRenderWidth*dwRenderHeight*(dwFullScreenBitDepth>>3); + int memleft = dwFree-rendertargetmem*2; //*2 to handle backbuf/zbuf + + if(memleft < RESERVEDTEXVIDMEM) { + dwFullScreenBitDepth=16; + wdxdisplay_cat.debug() << "using 16bpp rendertargets to save tex vidmem\n"; + assert((DMI.supportedBitDepths & DDBD_16) && (pD3DDevDesc->dwDeviceRenderBitDepth & DDBD_16)); // probably a safe assumption + rendertargetmem=dwRenderWidth*dwRenderHeight*(dwFullScreenBitDepth>>3); + memleft = dwFree-rendertargetmem*2; + + // BUGBUG: if we still cant reserve 2 megs of vidmem, need to auto-reduce the scrn res + if(memleft < RESERVEDTEXVIDMEM) + wdxdisplay_cat.debug() << "XXXX WARNING: cant reserve 2MB of tex vidmem. only " << memleft << " bytes available. Need to rewrite wdxdisplay to try lower resolutions XXXXXXXX\n"; + } + */ + #endif + } + + _dxgsg->scrn.dwFullScreenBitDepth=dwFullScreenBitDepth; + } + + _dxgsg->scrn.dwRenderWidth=dwRenderWidth; + _dxgsg->scrn.dwRenderHeight=dwRenderHeight; + if(pDevinfo) + _dxgsg->scrn.hMon=pDevinfo->hMon; + _dxgsg->scrn.CardIDNum=devnum; // add ID tag for dbgprint purposes + + return true; + + // handle errors within this for device loop + + error_exit: + if(_dxgsg->scrn.pD3D!=NULL) + _dxgsg->scrn.pD3D->Release(); + if(_dxgsg->scrn.pDD!=NULL) + _dxgsg->scrn.pDD->Release(); + + _dxgsg->scrn.pDD=NULL; + _dxgsg->scrn.pD3D=NULL; + return false; +} + +void wdxGraphicsWindowGroup:: +SetCoopLevelsAndDisplayModes(void) { + HRESULT hr; + DWORD SCL_FPUFlag; + + if(dx_preserve_fpu_state) + SCL_FPUFlag = DDSCL_FPUPRESERVE; // tell d3d to preserve the fpu state across calls. this hurts perf, but is good for dbgging + else SCL_FPUFlag = DDSCL_FPUSETUP; + + DXScreenData *pScrn=&_windows[0]->_dxgsg->scrn; + // All SetCoopLevels must use the parent window + + if(!dx_full_screen) { + if(FAILED(hr = pScrn->pDD->SetCooperativeLevel(_hParentWindow, SCL_FPUFlag | DDSCL_NORMAL))) { + wdxdisplay_cat.fatal() << "SetCooperativeLevel failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + return; + } + + DWORD SCL_FLAGS = SCL_FPUFlag | DDSCL_FULLSCREEN | DDSCL_EXCLUSIVE | DDSCL_ALLOWREBOOT; + + if(_windows.size()>1) { + SCL_FLAGS |= DDSCL_SETDEVICEWINDOW; + } + + for(DWORD devnum=0;devnum<_windows.size();devnum++) { + DXScreenData *pScrn=&_windows[devnum]->_dxgsg->scrn; + + // need to set focus/device windows for multimon + // focus window is primary monitor that will receive keybd input + // all ddraw objs need to have same focus window + if(_windows.size()>1) { + if(FAILED(hr = pScrn->pDD->SetCooperativeLevel(_hParentWindow, DDSCL_SETFOCUSWINDOW))) { + wdxdisplay_cat.fatal() << "SetCooperativeLevel SetFocusWindow failed on device 0: result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + } + + // s3 savage2000 on w95 seems to set EXCLUSIVE_MODE only if you call SetCoopLevel twice. + // so we do it, it really shouldnt be necessary if drivers werent buggy + for(int jj=0;jj<2;jj++) { + if(FAILED(hr = pScrn->pDD->SetCooperativeLevel(pScrn->hWnd, SCL_FLAGS))) { + wdxdisplay_cat.fatal() << "SetCooperativeLevel failed for device #"<< devnum<<": result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + } + + if(FAILED(hr = pScrn->pDD->TestCooperativeLevel())) { + wdxdisplay_cat.fatal() << "TestCooperativeLevel failed for device #"<< devnum<<": result = " << ConvD3DErrorToString(hr) << endl; + wdxdisplay_cat.fatal() << "Full screen app failed to get exclusive mode on init, exiting..\n"; + exit(1); + } + + // note: its important we call SetDisplayMode on all cards before creating surfaces on any of them + // let driver choose default refresh rate (hopefully its >=60Hz) + if(FAILED( hr = pScrn->pDD->SetDisplayMode( pScrn->dwRenderWidth, pScrn->dwRenderHeight, + pScrn->dwFullScreenBitDepth, 0, 0 ))) { + wdxdisplay_cat.fatal() << "SetDisplayMode failed to set ("<dwRenderWidth<<"x"<dwRenderHeight<<"x"<dwFullScreenBitDepth<<") on device #"<< pScrn->CardIDNum<<": result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(wdxdisplay_cat.is_debug()) { + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd34); + pScrn->pDD->GetDisplayMode(&ddsd34); + wdxdisplay_cat.debug() << "set displaymode to " << ddsd34.dwWidth << "x" << ddsd34.dwHeight << " at "<< ddsd34.ddpfPixelFormat.dwRGBBitCount << "bpp, " << ddsd34.dwRefreshRate<< "Hz\n"; + + /* + #ifdef _DEBUG + if(FAILED(hr = (*Disply).pDD->GetAvailableVidMem(&ddsGAVMCaps,&dwVidMemTotal,&dwVidMemFree))) { + wdxdisplay_cat.debug() << "GetAvailableVidMem failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + wdxdisplay_cat.debug() << "after fullscreen switch: GetAvailableVidMem returns Total: " << dwVidMemTotal/1000000.0 << " Free: " << dwVidMemFree/1000000.0 << endl; + #endif + */ + } + } +} + +//return true if successful +void wdxGraphicsWindow:: +CreateScreenBuffersAndDevice(DXScreenData &Display) { + + DWORD dwRenderWidth=Display.dwRenderWidth; + DWORD dwRenderHeight=Display.dwRenderHeight; + LPDIRECT3D7 pD3DI=Display.pD3D; + LPDIRECTDRAW7 pDD=Display.pDD; + D3DDEVICEDESC7 *pD3DDevDesc=&Display.D3DDevDesc; + + LPDIRECTDRAWSURFACE7 pPrimaryDDSurf,pBackDDSurf,pZDDSurf; + LPDIRECT3DDEVICE7 pD3DDevice; + RECT view_rect; + int i; + HRESULT hr; + DX_DECLARE_CLEAN( DDSURFACEDESC2, SurfaceDesc ); + + assert(pDD!=NULL); + assert(pD3DI!=NULL); + +/* + // select the best device if the caller does not provide one + D3DDEVICEDESC7 d3ddevs[2]; // put HAL in 0, TnLHAL in 1 + + if(pD3DDevDesc==NULL) { + // just look for HAL and TnL devices right now. I dont think + // we have any interest in the sw rasts at this point + + ZeroMemory(d3ddevs,2*sizeof(D3DDEVICEDESC7)); + + hr = pD3DI->EnumDevices(EnumDevicesCallback,d3ddevs); + if(hr != DD_OK) { + wdxdisplay_cat.fatal() << "EnumDevices failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + WORD DeviceIdx=REGHALIDX; + + if(!(d3ddevs[DeviceIdx].dwDevCaps & D3DDEVCAPS_HWRASTERIZATION )) { + wdxdisplay_cat.fatal() << "No 3D HW present, exiting..." << endl; + exit(1); + } + + // select TNL if present + if(d3ddevs[TNLHALIDX].dwDevCaps & D3DDEVCAPS_HWRASTERIZATION) { + DeviceIdx=TNLHALIDX; + } + + pD3DDevDesc=&d3ddevs[DeviceIdx]; + } +*/ + + DX_DECLARE_CLEAN(DDCAPS,DDCaps); + pDD->GetCaps(&DDCaps,NULL); + + // if window is not foreground in exclusive mode, ddraw thinks you are 'not active', so + // it changes your WM_ACTIVATEAPP from true to false, causing us + // to go into a 'wait-for WM_ACTIVATEAPP true' loop, and the event never comes so we hang + // in fullscreen wait. + + SetForegroundWindow(Display.hWnd); + + if(dx_full_screen) { + // Setup to create the primary surface w/backbuffer + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd) + ddsd.dwFlags = DDSD_CAPS|DDSD_BACKBUFFERCOUNT; + ddsd.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE | DDSCAPS_3DDEVICE | + DDSCAPS_FLIP | DDSCAPS_COMPLEX; + ddsd.dwBackBufferCount = 1; + + if(dx_full_screen_antialiasing) { + // cant check that d3ddevice has this capability yet, so got to set it anyway. + // hope this is OK. + ddsd.ddsCaps.dwCaps2 |= DDSCAPS2_HINTANTIALIASING; + } + + PRINTVIDMEM(pDD,&ddsd.ddsCaps,"initial primary & backbuf"); + + // Create the primary surface + if(FAILED( hr = pDD->CreateSurface( &ddsd, &pPrimaryDDSurf, NULL ) )) { + wdxdisplay_cat.fatal() << "CreateSurface failed for primary surface: result = " << ConvD3DErrorToString(hr) << endl; + + if(((hr==DDERR_OUTOFVIDEOMEMORY)||(hr==DDERR_OUTOFMEMORY)) && + (Display.dwFullScreenBitDepth>16)) { + // emergency fallback to 16bpp (shouldnt have to do this unless GetAvailVidMem lied) + // will this work for multimon? what if surfs are already created on 1st mon? + Display.dwFullScreenBitDepth=16; + + if(wdxdisplay_cat.info()) + wdxdisplay_cat.info() << "GetAvailVidMem lied, not enough VidMem for 32bpp, so trying 16bpp on device #"<< Display.CardIDNum<< endl; + + if(FAILED( hr = pDD->SetDisplayMode( Display.dwRenderWidth, Display.dwRenderHeight,Display.dwFullScreenBitDepth, 0, 0 ))) { + wdxdisplay_cat.fatal() << "SetDisplayMode failed to set ("<GetDisplayMode( &SurfaceDesc ))) { + wdxdisplay_cat.fatal() << "GetDisplayMode failed result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + if(SurfaceDesc.ddpfPixelFormat.dwRGBBitCount <= 8) { + wdxdisplay_cat.fatal() << "Can't run windowed in an 8-bit or less display mode" << endl; + exit(1); + } + + if(!(BitDepth_2_DDBDMask(SurfaceDesc.ddpfPixelFormat.dwRGBBitCount) & pD3DDevDesc->dwDeviceRenderBitDepth)) { + wdxdisplay_cat.fatal() << "3D Device doesnt support rendering at " << SurfaceDesc.ddpfPixelFormat.dwRGBBitCount << "bpp (current desktop bitdepth)" << endl; + exit(1); + } + + + // Get the dimensions of the viewport and screen bounds + + GetClientRect( Display.hWnd, &view_rect ); + POINT ul,lr; + ul.x=view_rect.left; ul.y=view_rect.top; + lr.x=view_rect.right; lr.y=view_rect.bottom; + ClientToScreen(Display.hWnd, &ul ); + ClientToScreen(Display.hWnd, &lr ); + view_rect.left=ul.x; view_rect.top=ul.y; + view_rect.right=lr.x; view_rect.bottom=lr.y; + + dwRenderWidth = view_rect.right - view_rect.left; + dwRenderHeight = view_rect.bottom - view_rect.top; + _props._xorg = view_rect.left; // _props should reflect view rectangle + _props._yorg = view_rect.top; + _props._xsize = dwRenderWidth; + _props._ysize = dwRenderHeight; + + // Initialize the description of the primary surface + ZeroMemory( &SurfaceDesc, sizeof(DDSURFACEDESC2) ); + SurfaceDesc.dwSize = sizeof(DDSURFACEDESC2); + SurfaceDesc.dwFlags = DDSD_CAPS ; + SurfaceDesc.ddsCaps.dwCaps = DDSCAPS_PRIMARYSURFACE; + + PRINTVIDMEM(pDD,&SurfaceDesc.ddsCaps,"initial primary surface"); + + // Create the primary surface. This includes all of the visible + // window, so no need to specify height/width + if(FAILED(hr = pDD->CreateSurface( &SurfaceDesc, &pPrimaryDDSurf, NULL ))) { + wdxdisplay_cat.fatal() + << "CreateSurface failed for primary surface: result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + // Create a clipper object which handles all our clipping for cases when + // our window is partially obscured by other windows. + LPDIRECTDRAWCLIPPER Clipper; + if(FAILED(hr = pDD->CreateClipper( 0, &Clipper, NULL ))) { + wdxdisplay_cat.fatal() << "CreateClipper failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + // Associate the clipper with our window. Note that, afterwards, the + // clipper is internally referenced by the primary surface, so it is safe + // to release our local reference to it. + Clipper->SetHWnd( 0, Display.hWnd ); + pPrimaryDDSurf->SetClipper( Clipper ); + Clipper->Release(); + + // Clear the primary surface to black + DX_DECLARE_CLEAN(DDBLTFX, bltfx) + + if(FAILED( hr = pPrimaryDDSurf->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&bltfx))) { + wdxdisplay_cat.fatal() + << "Blt to Black of Primary Surf failed! : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + // Setup a surface description to create a backbuffer. + SurfaceDesc.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS; + SurfaceDesc.ddsCaps.dwCaps = DDSCAPS_OFFSCREENPLAIN | DDSCAPS_3DDEVICE | DDSCAPS_VIDEOMEMORY; + SurfaceDesc.dwWidth = dwRenderWidth; + SurfaceDesc.dwHeight = dwRenderHeight; + + if(dx_full_screen_antialiasing) { + // cant check that d3ddevice has this capability yet, so got to set it anyway. + // hope this is OK. + SurfaceDesc.ddsCaps.dwCaps2 |= DDSCAPS2_HINTANTIALIASING; + } + + PRINTVIDMEM(pDD,&SurfaceDesc.ddsCaps,"initial backbuf"); + + // Create the backbuffer. (might want to handle failure due to running out of video memory) + if(FAILED(hr = pDD->CreateSurface( &SurfaceDesc, &pBackDDSurf, NULL ))) { + wdxdisplay_cat.fatal() + << "CreateSurface failed for backbuffer : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(FAILED( hr = pBackDDSurf->Blt(NULL,NULL,NULL,DDBLT_COLORFILL | DDBLT_WAIT,&bltfx))) { + wdxdisplay_cat.fatal() + << "Blt to Black of Back Surf failed! : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + } // end create windowed buffers + +// ======================================================== + + resized(dwRenderWidth,dwRenderHeight); // update panda channel/display rgn info + + #ifndef NDEBUG + if(!(_props._mask & W_DEPTH)) { + wdxdisplay_cat.info() << "no zbuffer requested, skipping zbuffer creation\n"; + } + #endif + + // Check if the device supports z-bufferless hidden surface removal. If so, + // we don't really need a z-buffer + if((!(pD3DDevDesc->dpcTriCaps.dwRasterCaps & D3DPRASTERCAPS_ZBUFFERLESSHSR )) && + (_props._mask & W_DEPTH)) { + + // Get z-buffer dimensions from the render target + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd); + pBackDDSurf->GetSurfaceDesc( &ddsd ); + + // Setup the surface desc for the z-buffer. + ddsd.dwFlags = DDSD_WIDTH | DDSD_HEIGHT | DDSD_CAPS | DDSD_PIXELFORMAT; + ddsd.ddsCaps.dwCaps = DDSCAPS_ZBUFFER | ((_dxgsg->scrn.bIsSWRast) ? DDSCAPS_SYSTEMMEMORY : DDSCAPS_VIDEOMEMORY); + + DDPIXELFORMAT ZBufPixFmts[MAX_DX_ZBUF_FMTS]; + cNumZBufFmts=0; + + // Get an appropiate pixel format from enumeration of the formats. On the + // first pass, we look for a zbuffer dpeth which is equal to the frame + // buffer depth (as some cards unfornately require this). + if(FAILED(pD3DI->EnumZBufferFormats((Display.bIsTNLDevice ? IID_IDirect3DHALDevice : IID_IDirect3DTnLHalDevice), + EnumZBufFmtsCallback, + (VOID*)&ZBufPixFmts ))) { + wdxdisplay_cat.fatal() << "EnumZBufferFormats failed" << endl; + exit(1); + } + +#ifdef _DEBUG + { static BOOL bPrinted=FALSE; + if(!bPrinted) { + for(i=0;idwFlags & DDPF_STENCILBUFFER)!=0)) { + switch(pCurPixFmt->dwRGBBitCount) { + case 16: + pz16=pCurPixFmt; + break; + case 24: + pz24=pCurPixFmt; + break; + case 32: + pz32=pCurPixFmt; + break; + } + } + } + + if((pz16==NULL)&&(pz24==NULL)&&(pz32==NULL)) { + if(bWantStencil) + wdxdisplay_cat.fatal() << "stencil buffer requested, device has no stencil capability\n"; + else wdxdisplay_cat.fatal() << "failed to find adequate zbuffer capability\n"; + exit(1); + } + + #define SET_ZBUF_DEPTH(DEPTH) { assert(pz##DEPTH != NULL); Display.depth_buffer_bitdepth=DEPTH; ddsd.ddpfPixelFormat = *pz##DEPTH;} + + if(_dxgsg->scrn.bIsSWRast) { + SET_ZBUF_DEPTH(16); // need this for fast path rasterizers + } else + if(IS_NVIDIA(Display.DXDeviceID)) { + DX_DECLARE_CLEAN(DDSURFACEDESC2,ddsd_pri) + pPrimaryDDSurf->GetSurfaceDesc(&ddsd_pri); + + // must pick zbuf depth to match primary surface depth for nvidia + if(ddsd_pri.ddpfPixelFormat.dwRGBBitCount==16) { + SET_ZBUF_DEPTH(16); + } else { + if(dx_force_16bpp_zbuffer) { + wdxdisplay_cat.fatal() << "'dx-force-16bpp-zbuffer #t' requires a 16bpp desktop on nvidia cards\n"; + exit(1); + } + // take the smaller of 24 or 32. (already assured to match stencil capability) + if(pz24!=NULL) { + SET_ZBUF_DEPTH(24); + } else SET_ZBUF_DEPTH(32); + } + } else { + if(dx_force_16bpp_zbuffer) { + if(pz16==NULL) { + wdxdisplay_cat.fatal() << "'dx-force-16bpp-zbuffer #t', but no 16bpp zbuf fmts available on this card\n"; + exit(1); + } + + if(wdxdisplay_cat.is_debug()) + wdxdisplay_cat.debug() << "forcing use of 16bpp Z-Buffer\n"; + SET_ZBUF_DEPTH(16); + ddsd.ddpfPixelFormat = *pz16; + } else { + // pick the highest res zbuffer format avail. Note: this is choosing to waste vid-memory + // and possibly perf for more accuracy, less z-fighting at long distance (std 16bpp would + // be smaller// maybe faster) + // order of preference 24: (should be enough), 32: probably means 24 of Z, then 16 + + if(bWantStencil && (pz32!=NULL)) { + // dont want to select 16/8 z/stencil over 24/8 z/stenc + SET_ZBUF_DEPTH(32); + } else { + if(pz24!=NULL) { + SET_ZBUF_DEPTH(24); + } else if(pz32!=NULL) { + SET_ZBUF_DEPTH(32); + } else { + SET_ZBUF_DEPTH(16); + } + } + } + } + + PRINTVIDMEM(pDD,&ddsd.ddsCaps,"initial zbuf"); + +#ifdef _DEBUG + wdxdisplay_cat.info() << "Creating " << ddsd.ddpfPixelFormat.dwRGBBitCount << "bpp zbuffer\n"; +#endif + + // Create and attach a z-buffer + if(FAILED( hr = pDD->CreateSurface( &ddsd, &pZDDSurf, NULL ) )) { + wdxdisplay_cat.fatal() << "CreateSurface failed for Z buffer: result = " << ConvD3DErrorToString(hr) << endl; + + if(((hr==DDERR_OUTOFVIDEOMEMORY)||(hr==DDERR_OUTOFMEMORY)) && + ((Display.dwFullScreenBitDepth>16)||(ddsd.ddpfPixelFormat.dwRGBBitCount>16))) { + Display.dwFullScreenBitDepth=16; + // emergency fallback to 16bpp (shouldnt have to do this unless GetAvailVidMem lied) + // will this work for multimon? what if surfs are already created on 1st mon? + + if(wdxdisplay_cat.info()) + wdxdisplay_cat.info() << "GetAvailVidMem lied, not enough VidMem for 32bpp, so trying 16bpp on device #"<< Display.CardIDNum<< endl; + + ULONG refcnt; + + // free pri and back (maybe should just free pri since created as complex chain?) + RELEASE(pBackDDSurf,wdxdisplay,"backbuffer",false); + RELEASE(pPrimaryDDSurf,wdxdisplay,"primary surface",false); + + if(FAILED( hr = pDD->SetDisplayMode( Display.dwRenderWidth, Display.dwRenderHeight,Display.dwFullScreenBitDepth, 0, 0 ))) { + wdxdisplay_cat.fatal() << "SetDisplayMode failed to set ("<get_pipe(); + + GraphicsWindow::WindowProps *props_param; + if(!get_param_into(props_param, params)) { + return new wdxGraphicsWindow(pipe); + } else { + return new wdxGraphicsWindow(pipe, props_param->get_properties()); + } +} + +TypeHandle wdxGraphicsWindow::get_class_type(void) { + return _type_handle; +} + +void wdxGraphicsWindow::init_type(void) { + GraphicsWindow::init_type(); + register_type(_type_handle, "wdxGraphicsWindow", + GraphicsWindow::get_class_type()); +} + +TypeHandle wdxGraphicsWindow::get_type(void) const { + return get_class_type(); +} + +//////////////////////////////////////////////////////////////////// +// Function: lookup_key +// Access: +// Description: +//////////////////////////////////////////////////////////////////// +ButtonHandle wdxGraphicsWindow:: +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(); +} + +int wdxGraphicsWindow:: +get_depth_bitwidth(void) { + assert(_dxgsg!=NULL); + if(_dxgsg->scrn.pddsZBuf!=NULL) + return _dxgsg->scrn.depth_buffer_bitdepth; + else return 0; + +// GetSurfaceDesc is not reliable, on GF2, GetSurfDesc returns 32bpp when you created a 24bpp zbuf +// instead store the depth used at creation time + +// DX_DECLARE_CLEAN(DDSURFACEDESC2, ddsd); +// _dxgsg->_zbuf->GetSurfaceDesc(&ddsd); +// return ddsd.ddpfPixelFormat.dwRGBBitCount; +} + +// Global system parameters we want to modify during our run +static int iMouseTrails; +static bool bCursorShadowOn,bMouseVanish; + +#ifndef SPI_GETMOUSEVANISH +// get rid of this when we upgrade to winxp winuser.h in newest platform sdk +#define SPI_GETMOUSEVANISH 0x1020 +#define SPI_SETMOUSEVANISH 0x1021 +#endif + +#ifndef SPI_GETCURSORSHADOW +#error You have old windows headers, need to get latest MS Platform SDK +#endif + +void set_global_parameters(void) { + // 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(void) { + SystemParametersInfo(SPI_SETCURSORSHADOW,NULL,(PVOID)bCursorShadowOn,NULL); + SystemParametersInfo(SPI_SETMOUSETRAILS,NULL,(PVOID)iMouseTrails,NULL); + SystemParametersInfo(SPI_SETMOUSEVANISH,NULL,(PVOID)bMouseVanish,NULL); +} + + +// fns for exporting to python, which cant pass variable length arrays +wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,const GraphicsWindow::Properties &Win1Prop) { + GraphicsWindow::Properties WinPropArr[1]; + WinPropArr[0]=Win1Prop; + make_windows(pipe,1,WinPropArr); +} + +wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe, + const GraphicsWindow::Properties &Win1Prop, + const GraphicsWindow::Properties &Win2Prop) { + GraphicsWindow::Properties WinPropArr[2]; + + WinPropArr[0]=Win1Prop; + WinPropArr[1]=Win2Prop; + make_windows(pipe,2,WinPropArr); +} + +wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe, + const GraphicsWindow::Properties &Win1Prop, + const GraphicsWindow::Properties &Win2Prop, + const GraphicsWindow::Properties &Win3Prop) { + GraphicsWindow::Properties WinPropArr[3]; + + WinPropArr[0]=Win1Prop; + WinPropArr[1]=Win2Prop; + WinPropArr[2]=Win3Prop; + make_windows(pipe,3,WinPropArr); +} + +wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(wdxGraphicsWindow *OneWindow) { + // init a 1 window group + // called from config_window + + _windows.reserve(1); + _windows.push_back(OneWindow); + initWindowGroup(); +} + +void wdxGraphicsWindowGroup::initWindowGroup(void) { + HRESULT hr; + unsigned int i; + + assert(_windows.size()>0); + _hOldForegroundWindow=GetForegroundWindow(); + _bClosingAllWindows= false; + + unsigned int num_windows=_windows.size(); + + #define DDRAW_NAME "ddraw.dll" + + _hDDrawDLL = LoadLibrary(DDRAW_NAME); + if(_hDDrawDLL == 0) { + wdxdisplay_cat.fatal() << "can't locate " << DDRAW_NAME <<"!\n"; + exit(1); + } + + _hMouseCursor = NULL; + _bLoadedCustomCursor = false; + + // can only get multimon HW acceleration in fullscrn on DX7 + + unsigned int numMonitors = GetSystemMetrics(SM_CMONITORS); + + if(numMonitors < num_windows) { + if(numMonitors==0) { + numMonitors=1; //win95 system will fail this call + } else { + wdxdisplay_cat.fatal() << "system has only "<< numMonitors << " monitors attached, couldn't find enough devices to meet multi window reqmt of " << num_windows << endl; + exit(1); + } + } + + _pDDCreateEx = (LPDIRECTDRAWCREATEEX) GetProcAddress(_hDDrawDLL,"DirectDrawCreateEx"); + if(_pDDCreateEx == NULL) { + wdxdisplay_cat.fatal() << "Panda currently requires at least DirectX 7.0!\n"; + exit(1); + } + + if(_windows.size()>1) { + // just do Enumeration for multimon case. + // enumeration was reqd to select voodoo1-class devices, but I'm no longer + // going to support them on DX7 due to lack of mouse cursor + + LPDIRECTDRAWENUMERATEEX pDDEnumEx = (LPDIRECTDRAWENUMERATEEX) GetProcAddress(_hDDrawDLL,"DirectDrawEnumerateExA"); + if(pDDEnumEx == NULL) { + wdxdisplay_cat.fatal() << "GetProcAddr failed for DirectDrawEnumerateEx!\n"; + exit(1); + } + + hr = (*pDDEnumEx)(DriverEnumCallback_MultiMon, &_DeviceInfoVec, DDENUM_ATTACHEDSECONDARYDEVICES | DDENUM_NONDISPLAYDEVICES); + if(FAILED(hr)) { + wdxdisplay_cat.fatal() << "DirectDrawEnumerateEx failed : result = " << ConvD3DErrorToString(hr) << endl; + exit(1); + } + + if(_DeviceInfoVec.size() < num_windows) { + wdxdisplay_cat.fatal() << "couldn't find enough devices attached to meet multi window reqmt of " << num_windows << endl; + exit(1); + } + } + + assert(_windows[0] != NULL); + + for(i=0;iconfig_window(this); + } + + assert(_windows[0] != NULL); + + DWORD good_device_count=0; + + if(num_windows==1) { + assert(_windows[0] != NULL); + if(_windows[0]->search_for_device(0,NULL)) + good_device_count=1; + } else { + for(DWORD devnum=0;devnum<_DeviceInfoVec.size() && (good_device_count < num_windows);devnum++) { + if(_windows[devnum]->search_for_device(devnum,&(_DeviceInfoVec[devnum]))) + good_device_count++; + } + } + + if(good_device_count < num_windows) { + if(good_device_count==0) + wdxdisplay_cat.fatal() << "no usable display devices, exiting...\n"; + else wdxdisplay_cat.fatal() << "multi-device request for " << num_windows << "devices, found only "<< good_device_count << endl; + exit(1); + } + + _DeviceInfoVec.clear(); // dont need this anymore + + CreateWindows(); // creates win32 windows (need to do this before Setting coopLvls and display modes, + // but after we have all the monitor handles needed by CreateWindow() + + SetCoopLevelsAndDisplayModes(); + + if(dx_show_fps_meter) + _windows[0]->_dxgsg->_bShowFPSMeter = true; // just show fps on 1st mon + + for(i=0;iCreateScreenBuffersAndDevice(_windows[i]->_dxgsg->scrn); + } + + for(i=0;ifinish_window_setup(); + } + + for(i=0;i_dxgsg->SetDXReady(true); + } +} + +wdxGraphicsWindowGroup::wdxGraphicsWindowGroup(GraphicsPipe *pipe,int num_windows,GraphicsWindow::Properties *WinPropArray) { + make_windows(pipe,num_windows,WinPropArray); +} + +void wdxGraphicsWindowGroup:: +make_windows(GraphicsPipe *pipe,int num_windows,GraphicsWindow::Properties *WinPropArray) { + _hParentWindow=NULL; + _windows.reserve(num_windows); + int i; + + // first make all the objs without running the dx config() stuff + for(i=0;iclose_window(); + } + + if((_hOldForegroundWindow!=NULL) /*&& (scrn.hWnd==GetForegroundWindow())*/) { + SetForegroundWindow(_hOldForegroundWindow); + } + + if(_bLoadedCustomCursor && (_hMouseCursor!=NULL)) + DestroyCursor(_hMouseCursor); + + + if(_hDDrawDLL != NULL) { + FreeLibrary(_hDDrawDLL); + _hDDrawDLL = NULL; + } +} + diff --git a/panda/src/dxgsg7/wdxGraphicsWindow.h.old b/panda/src/dxgsg7/wdxGraphicsWindow.h.old new file mode 100644 index 0000000000..fb268c5163 --- /dev/null +++ b/panda/src/dxgsg7/wdxGraphicsWindow.h.old @@ -0,0 +1,176 @@ +// Filename: wdxGraphicsWindow.h +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// +#ifndef WDXGRAPHICSWINDOW_H +#define WDXGRAPHICSWINDOW_H +//#define WBD_GL_MODE 1 // if setting this, do it in wdxGraphicsStateGuardian.h too +// +//////////////////////////////////////////////////////////////////// +// Includes +//////////////////////////////////////////////////////////////////// +#include "dxGraphicsStateGuardian.h" + +//////////////////////////////////////////////////////////////////// +// Defines +//////////////////////////////////////////////////////////////////// +class wdxGraphicsPipe; +class wdxGraphicsWindowGroup; + +const int WDXWIN_CONFIGURE = 4; +const int WDXWIN_EVENT = 8; + +typedef HRESULT (WINAPI * LPDIRECTDRAWCREATEEX)(GUID FAR * lpGuid, LPVOID *lplpDD, REFIID iid,IUnknown FAR *pUnkOuter); + +typedef struct { + char szDriver[MAX_DDDEVICEID_STRING]; + char szDescription[MAX_DDDEVICEID_STRING]; + GUID guidDeviceIdentifier; + HMONITOR hMon; +} DXDeviceInfo; +typedef vector DXDeviceInfoVec; + +//////////////////////////////////////////////////////////////////// +// Class : wdxGraphicsWindow +// Description : +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDADX wdxGraphicsWindow : public GraphicsWindow { + friend class DXGraphicsStateGuardian; + friend class DXTextureContext; + friend class wdxGraphicsWindowGroup; + +public: + wdxGraphicsWindow(GraphicsPipe* pipe); + wdxGraphicsWindow(GraphicsPipe* pipe,const GraphicsWindow::Properties& props); + + // this constructor will not initialize the wdx stuff, only the panda graphicswindow stuff + wdxGraphicsWindow(GraphicsPipe* pipe,const GraphicsWindow::Properties& props,wdxGraphicsWindowGroup *pParentGroup); + + virtual ~wdxGraphicsWindow(void); + + virtual TypeHandle get_gsg_type() const; + static GraphicsWindow* make_wdxGraphicsWindow(const FactoryParams ¶ms); + + void set_window_handle(HWND hwnd); + + LONG window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); + void process_events(void); + + INLINE void handle_mouse_motion(int x, int y); + INLINE void handle_mouse_entry(bool bEntering, int x, int y); + INLINE void handle_keypress(ButtonHandle key, int x, int y ); + INLINE void handle_keyrelease(ButtonHandle key); + void handle_window_move(int x, int y); + void dx_setup(); + virtual bool resize(unsigned int xsize,unsigned int ysize); + virtual unsigned int verify_window_sizes(unsigned int numsizes,unsigned int *dimen); + bool special_check_fullscreen_resolution(UINT xsize,UINT ysize); + virtual int get_depth_bitwidth(void); + +protected: + void CreateScreenBuffersAndDevice(LPDIRECTDRAW7 pDD,LPDIRECT3D7 pD3DI); + ButtonHandle lookup_key(WPARAM wparam) const; +// virtual void config(void); + void config_single_window(void); + void config_window(wdxGraphicsWindowGroup *pParentGroup); + void finish_window_setup(void); + bool search_for_device(int devnum,DXDeviceInfo *pDevinfo); + void setup_colormap(void); + +public: + UINT_PTR _PandaPausedTimer; + DXGraphicsStateGuardian *_dxgsg; + void CreateScreenBuffersAndDevice(DXScreenData &Display); + +private: + INLINE void track_mouse_leaving(HWND hwnd); + wdxGraphicsWindowGroup *_pParentWindowGroup; + HDC _hdc; + HPALETTE _colormap; + typedef enum { NotAdjusting,MovingOrResizing,Resizing } WindowAdjustType; + WindowAdjustType _WindowAdjustingType; + bool _bSizeIsMaximized; + bool _cursor_in_windowclientarea; + bool _tracking_mouse_leaving; + bool _ime_open; + bool _ime_active; + bool _ime_composition_w; + bool _exiting_window; + bool _window_inactive; + bool _active_minimized_fullscreen; + bool _return_control_to_app; + int _depth_buffer_bpp; + +public: + static TypeHandle get_class_type(void); + static void init_type(void); + virtual TypeHandle get_type(void) const; + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + + void DestroyMe(bool bAtExitFnCalled); + virtual void do_close_window(); + void deactivate_window(void); + void reactivate_window(void); + void handle_reshape(bool bDoDXReset); + +private: + static TypeHandle _type_handle; +}; + +// this class really belongs in panda, not here +class EXPCL_PANDADX wdxGraphicsWindowGroup { +// group of windows are all created at the same time + friend class wdxGraphicsWindow; + +PUBLISHED: + wdxGraphicsWindowGroup(GraphicsPipe *,const GraphicsWindow::Properties&); + wdxGraphicsWindowGroup(GraphicsPipe *,const GraphicsWindow::Properties&,const GraphicsWindow::Properties&); + wdxGraphicsWindowGroup(GraphicsPipe *,const GraphicsWindow::Properties&,const GraphicsWindow::Properties&, + const GraphicsWindow::Properties&); +public: + wdxGraphicsWindowGroup(wdxGraphicsWindow *OneWindow); + // dont publish variable length one, since FFI wont support it + wdxGraphicsWindowGroup(GraphicsPipe *pipe,int num_windows,GraphicsWindow::Properties *WinPropArray); + ~wdxGraphicsWindowGroup(); + void SetCoopLevelsAndDisplayModes(void); +public: + void CreateWindows(void); + void make_windows(GraphicsPipe *,int num_windows,GraphicsWindow::Properties *pWinPropArray); + void initWindowGroup(void); + + pvector _windows; + DXDeviceInfoVec *_pDeviceInfoVec; // only used during init to store valid devices + HWND _hParentWindow; + HINSTANCE _hDDrawDLL; + HWND _hOldForegroundWindow; + HCURSOR _hMouseCursor; + bool _bLoadedCustomCursor; + bool _bClosingAllWindows; + int _numMonitors; + LPDIRECTDRAWCREATEEX _pDDCreateEx; + DXDeviceInfoVec _DeviceInfoVec; + + // win32 fns that dont exist on w95 + typedef BOOL (WINAPI* PFN_GETMONITORINFO)(HMONITOR, LPMONITORINFO); + PFN_GETMONITORINFO _pfnGetMonitorInfo; + typedef BOOL (WINAPI* PFN_TRACKMOUSEEVENT)(LPTRACKMOUSEEVENT); + PFN_TRACKMOUSEEVENT _pfnTrackMouseEvent; +}; + +extern void set_global_parameters(void); +extern void restore_global_parameters(void); + +#endif diff --git a/panda/src/wgldisplay/wglGraphicsPipe.cxx.old b/panda/src/wgldisplay/wglGraphicsPipe.cxx.old new file mode 100644 index 0000000000..e08696bdd9 --- /dev/null +++ b/panda/src/wgldisplay/wglGraphicsPipe.cxx.old @@ -0,0 +1,82 @@ +// Filename: wglGraphicsPipe.cxx +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// +#include "wglGraphicsPipe.h" +#include "config_wgldisplay.h" + +//////////////////////////////////////////////////////////////////// +// Static variables +//////////////////////////////////////////////////////////////////// +TypeHandle wglGraphicsPipe::_type_handle; + +wglGraphicsPipe::wglGraphicsPipe(const PipeSpecifier& spec) + : InteractiveGraphicsPipe(spec) +{} + +//////////////////////////////////////////////////////////////////// +// Function: wglGraphicsPipe::get_window_type +// Access: Public, Virtual +// Description: Returns the TypeHandle of the kind of window +// preferred by this kind of pipe. +//////////////////////////////////////////////////////////////////// +TypeHandle wglGraphicsPipe:: +get_window_type() const { + return wglGraphicsWindow::get_class_type(); +} + +GraphicsPipe *wglGraphicsPipe:: +make_wglGraphicsPipe(const FactoryParams ¶ms) { + GraphicsPipe::PipeSpec *pipe_param; + if (!get_param_into(pipe_param, params)) { + return new wglGraphicsPipe(PipeSpecifier()); + } else { + return new wglGraphicsPipe(pipe_param->get_specifier()); + } +} + + +TypeHandle wglGraphicsPipe::get_class_type(void) { + return _type_handle; +} + +const char *pipe_type_name="wglGraphicsPipe"; + +void wglGraphicsPipe::init_type(void) { + InteractiveGraphicsPipe::init_type(); + register_type(_type_handle, pipe_type_name, + InteractiveGraphicsPipe::get_class_type()); +} + +TypeHandle wglGraphicsPipe::get_type(void) const { + return get_class_type(); +} + +wglGraphicsPipe::wglGraphicsPipe(void) { + wgldisplay_cat.error() + << pipe_type_name <<"s should not be created with the default constructor" << endl; +} + +wglGraphicsPipe::wglGraphicsPipe(const wglGraphicsPipe&) { + wgldisplay_cat.error() + << pipe_type_name << "s should not be copied" << endl; +} + +wglGraphicsPipe& wglGraphicsPipe::operator=(const wglGraphicsPipe&) { + wgldisplay_cat.error() + << pipe_type_name << "s should not be assigned" << endl; + return *this; +} diff --git a/panda/src/wgldisplay/wglGraphicsPipe.h.old b/panda/src/wgldisplay/wglGraphicsPipe.h.old new file mode 100644 index 0000000000..35090b212a --- /dev/null +++ b/panda/src/wgldisplay/wglGraphicsPipe.h.old @@ -0,0 +1,63 @@ +// Filename: wglGraphicsPipe.h +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// +#ifndef WGLGRAPHICSPIPE_H +#define WGLGRAPHICSPIPE_H +// +//////////////////////////////////////////////////////////////////// +// Includes +//////////////////////////////////////////////////////////////////// +#include + +#include +#include +#include "wglGraphicsWindow.h" +#define WINDOWS_LEAN_AND_MEAN +#include +#undef WINDOWS_LEAN_AND_MEAN + +//////////////////////////////////////////////////////////////////// +// Class : wglGraphicsPipe +// Description : +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDAGL wglGraphicsPipe : public InteractiveGraphicsPipe { +public: + wglGraphicsPipe(const PipeSpecifier&); + + virtual TypeHandle get_window_type() const; + +public: + + static GraphicsPipe* make_wglGraphicsPipe(const FactoryParams ¶ms); + + static TypeHandle get_class_type(); + static void init_type(); + virtual TypeHandle get_type() const; + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + +private: + + static TypeHandle _type_handle; + +protected: + + wglGraphicsPipe(); + wglGraphicsPipe(const wglGraphicsPipe&); + wglGraphicsPipe& operator=(const wglGraphicsPipe&); +}; + +#endif diff --git a/panda/src/wgldisplay/wglGraphicsWindow.cxx.old b/panda/src/wgldisplay/wglGraphicsWindow.cxx.old new file mode 100644 index 0000000000..3d70af589d --- /dev/null +++ b/panda/src/wgldisplay/wglGraphicsWindow.cxx.old @@ -0,0 +1,3566 @@ +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// + +#include "wglGraphicsWindow.h" +#include "wglGraphicsPipe.h" +#include "config_wgldisplay.h" +#include +#include +#include +#include +#include +#include +#include +#include +#include +#include +//#include +#include +#include "Win32Defs.h" + +#ifdef DO_PSTATS +#include +#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_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("<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(;modenumget_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;idwFlags & (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); +} + diff --git a/panda/src/wgldisplay/wglGraphicsWindow.h.old b/panda/src/wgldisplay/wglGraphicsWindow.h.old new file mode 100644 index 0000000000..e14337ab6d --- /dev/null +++ b/panda/src/wgldisplay/wglGraphicsWindow.h.old @@ -0,0 +1,158 @@ +// Filename: wglGraphicsWindow.h +// Created by: mike (09Jan97) +// +//////////////////////////////////////////////////////////////////// +// +// 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 +// panda3d@yahoogroups.com . +// +//////////////////////////////////////////////////////////////////// +#ifndef WGLGRAPHICSWINDOW_H +#define WGLGRAPHICSWINDOW_H +// +//////////////////////////////////////////////////////////////////// +// Includes +//////////////////////////////////////////////////////////////////// + +// include win32 defns for everything up to XP, and assume I'm smart enough to +// use GetProcAddress for backward compat on w95/w98 for newer fns +#define _WIN32_WINNT 0x0501 + +#define WINDOWS_LEAN_AND_MEAN +#include +#undef WINDOWS_LEAN_AND_MEAN + +#include +#include + +//////////////////////////////////////////////////////////////////// +// Defines +//////////////////////////////////////////////////////////////////// +class wglGraphicsPipe; + +#if 0 +#define GLX_USE_GL 1 /* support GLX rendering */ +#define GLX_BUFFER_SIZE 2 /* depth of the color buffer */ +#define GLX_LEVEL 3 /* level in plane stacking */ +#define GLX_RGBA 4 /* true if RGBA mode */ +#define GLX_DOUBLEBUFFER 5 /* double buffering supported */ +#define GLX_STEREO 6 /* stereo buffering supported */ +#define GLX_AUX_BUFFERS 7 /* number of aux buffers */ +#define GLX_RED_SIZE 8 /* number of red component bits */ +#define GLX_GREEN_SIZE 9 /* number of green component bits */ +#define GLX_BLUE_SIZE 10 /* number of blue component bits */ +#define GLX_ALPHA_SIZE 11 /* number of alpha component bits */ +#define GLX_DEPTH_SIZE 12 /* number of depth bits */ +#define GLX_STENCIL_SIZE 13 /* number of stencil bits */ +#define GLX_ACCUM_RED_SIZE 14 /* number of red accum bits */ +#define GLX_ACCUM_GREEN_SIZE 15 /* number of green accum bits */ +#define GLX_ACCUM_BLUE_SIZE 16 /* number of blue accum bits */ +#define GLX_ACCUM_ALPHA_SIZE 17 /* number of alpha accum bits */ +#endif + +//////////////////////////////////////////////////////////////////// +// Class : wglGraphicsWindow +// Description : +//////////////////////////////////////////////////////////////////// +class EXPCL_PANDAGL wglGraphicsWindow : public GraphicsWindow { +public: + wglGraphicsWindow(GraphicsPipe* pipe); + wglGraphicsWindow(GraphicsPipe* pipe, + const GraphicsWindow::Properties& props); + virtual ~wglGraphicsWindow(); + + virtual void end_frame(); + virtual void swap(); + virtual int get_depth_bitwidth(); + + virtual TypeHandle get_gsg_type() const; + static GraphicsWindow* make_wglGraphicsWindow(const FactoryParams ¶ms); + +public: + virtual void make_current(); + virtual void unmake_current(); + void handle_mouse_motion(int x, int y); + void handle_mouse_exit(void); + INLINE void track_mouse_leaving(HWND hwnd); + void handle_keypress(ButtonHandle key, int x, int y); + void handle_keyrelease(ButtonHandle key); + +protected: + int choose_visual(void); + int find_pixfmtnum(bool bLookforHW); + virtual void config(); + void setup_colormap(void); + void handle_reshape(); + void process_events(); + +public: + HWND _mwindow; + +private: + HGLRC _context; + HDC _hdc; + PIXELFORMATDESCRIPTOR _pixelformat; + HPALETTE _colormap; + HCURSOR _hMouseCursor; + HWND _hOldForegroundWindow; + UINT_PTR _PandaPausedTimer; + + DEVMODE *_pCurrent_display_settings; + bool _bIsLowVidMemCard; + bool _bLoadedCustomCursor; + + bool _active_minimized_fullscreen; + bool _return_control_to_app; + bool _exiting_window; + bool _cursor_in_windowclientarea; + bool _tracking_mouse_leaving; + bool _ime_open; + bool _ime_active; + bool _ime_composition_w; + + // vars for frames/sec meter + DWORD _start_time; + DWORD _start_frame_count; + DWORD _cur_frame_count; + float _current_fps; + + string _extensions_str; + + typedef BOOL (WINAPI* PFN_TRACKMOUSEEVENT)(LPTRACKMOUSEEVENT); + PFN_TRACKMOUSEEVENT _pfnTrackMouseEvent; + +public: + static TypeHandle get_class_type(); + static void init_type(); + virtual TypeHandle get_type() const; + virtual TypeHandle force_init_type() {init_type(); return get_class_type();} + + LONG WINAPI window_proc(HWND hwnd, UINT msg, WPARAM wparam, LPARAM lparam); + ButtonHandle lookup_key(WPARAM wparam) const; + void DestroyMe(bool bAtExitFnCalled); + virtual void deactivate_window(); + virtual void reactivate_window(); + + virtual bool resize(unsigned int xsize,unsigned int ysize); + virtual unsigned int verify_window_sizes(unsigned int numsizes,unsigned int *dimen); + +protected: + virtual void do_close_window(); + void check_for_color_cursor_support(); + +private: + static TypeHandle _type_handle; +}; + +extern void set_global_parameters(); +extern void restore_global_parameters(); + +#endif