503 lines
18 KiB
C
503 lines
18 KiB
C
/*
|
|
* Some tests for OpenGL functions
|
|
*
|
|
* Copyright (C) 2007 Roderick Colenbrander
|
|
*
|
|
* This library is free software; you can redistribute it and/or
|
|
* modify it under the terms of the GNU Lesser General Public
|
|
* License as published by the Free Software Foundation; either
|
|
* version 2.1 of the License, or (at your option) any later version.
|
|
*
|
|
* This library is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
|
|
* Lesser General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU Lesser General Public
|
|
* License along with this library; if not, write to the Free Software
|
|
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
|
|
*/
|
|
|
|
#include <windows.h>
|
|
#include <wingdi.h>
|
|
#include "wine/test.h"
|
|
|
|
#define MAX_FORMATS 256
|
|
typedef void* HPBUFFERARB;
|
|
|
|
/* WGL_ARB_extensions_string */
|
|
static const char* (WINAPI *pwglGetExtensionsStringARB)(HDC);
|
|
static int (WINAPI *pwglReleasePbufferDCARB)(HPBUFFERARB, HDC);
|
|
|
|
/* WGL_ARB_make_current_read */
|
|
static BOOL (WINAPI *pwglMakeContextCurrentARB)(HDC hdraw, HDC hread, HGLRC hglrc);
|
|
static HDC (WINAPI *pwglGetCurrentReadDCARB)();
|
|
|
|
/* WGL_ARB_pixel_format */
|
|
#define WGL_COLOR_BITS_ARB 0x2014
|
|
#define WGL_RED_BITS_ARB 0x2015
|
|
#define WGL_GREEN_BITS_ARB 0x2017
|
|
#define WGL_BLUE_BITS_ARB 0x2019
|
|
#define WGL_ALPHA_BITS_ARB 0x201B
|
|
#define WGL_SUPPORT_GDI_ARB 0x200F
|
|
#define WGL_DOUBLE_BUFFER_ARB 0x2011
|
|
|
|
static BOOL (WINAPI *pwglChoosePixelFormatARB)(HDC, const int *, const FLOAT *, UINT, int *, UINT *);
|
|
static BOOL (WINAPI *pwglGetPixelFormatAttribivARB)(HDC, int, int, UINT, const int *, int *);
|
|
|
|
/* WGL_ARB_pbuffer */
|
|
#define WGL_DRAW_TO_PBUFFER_ARB 0x202D
|
|
static HPBUFFERARB* (WINAPI *pwglCreatePbufferARB)(HDC, int, int, int, const int *);
|
|
static HDC (WINAPI *pwglGetPbufferDCARB)(HPBUFFERARB);
|
|
|
|
static const char* wgl_extensions = NULL;
|
|
|
|
static void init_functions(void)
|
|
{
|
|
#define GET_PROC(func) \
|
|
p ## func = (void*)wglGetProcAddress(#func); \
|
|
if(!p ## func) \
|
|
trace("wglGetProcAddress(%s) failed\n", #func);
|
|
|
|
/* WGL_ARB_extensions_string */
|
|
GET_PROC(wglGetExtensionsStringARB)
|
|
|
|
/* WGL_ARB_make_current_read */
|
|
GET_PROC(wglMakeContextCurrentARB);
|
|
GET_PROC(wglGetCurrentReadDCARB);
|
|
|
|
/* WGL_ARB_pixel_format */
|
|
GET_PROC(wglChoosePixelFormatARB)
|
|
GET_PROC(wglGetPixelFormatAttribivARB)
|
|
|
|
/* WGL_ARB_pbuffer */
|
|
GET_PROC(wglCreatePbufferARB)
|
|
GET_PROC(wglGetPbufferDCARB)
|
|
GET_PROC(wglReleasePbufferDCARB)
|
|
|
|
#undef GET_PROC
|
|
}
|
|
|
|
static void test_pbuffers(HDC hdc)
|
|
{
|
|
const int iAttribList[] = { WGL_DRAW_TO_PBUFFER_ARB, 1, /* Request pbuffer support */
|
|
0 };
|
|
int iFormats[MAX_FORMATS];
|
|
unsigned int nOnscreenFormats;
|
|
unsigned int nFormats;
|
|
int i, res;
|
|
int iPixelFormat = 0;
|
|
|
|
nOnscreenFormats = DescribePixelFormat(hdc, 0, 0, NULL);
|
|
|
|
/* When you want to render to a pbuffer you need to call wglGetPbufferDCARB which
|
|
* returns a 'magic' HDC which you can then pass to wglMakeCurrent to switch rendering
|
|
* to the pbuffer. Below some tests are performed on what happens if you use standard WGL calls
|
|
* on this 'magic' HDC for both a pixelformat that support onscreen and offscreen rendering
|
|
* and a pixelformat that's only available for offscreen rendering (this means that only
|
|
* wglChoosePixelFormatARB and friends know about the format.
|
|
*
|
|
* The first thing we need are pixelformats with pbuffer capabilites.
|
|
*/
|
|
res = pwglChoosePixelFormatARB(hdc, iAttribList, NULL, MAX_FORMATS, iFormats, &nFormats);
|
|
if(res <= 0)
|
|
{
|
|
skip("No pbuffer compatible formats found while WGL_ARB_pbuffer is supported\n");
|
|
return;
|
|
}
|
|
trace("nOnscreenFormats: %d\n", nOnscreenFormats);
|
|
trace("Total number of pbuffer capable pixelformats: %d\n", nFormats);
|
|
|
|
/* Try to select an onscreen pixelformat out of the list */
|
|
for(i=0; i < nFormats; i++)
|
|
{
|
|
/* Check if the format is onscreen, if it is choose it */
|
|
if(iFormats[i] <= nOnscreenFormats)
|
|
{
|
|
iPixelFormat = iFormats[i];
|
|
trace("Selected iPixelFormat=%d\n", iPixelFormat);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/* A video driver supports a large number of onscreen and offscreen pixelformats.
|
|
* The traditional WGL calls only see a subset of the whole pixelformat list. First
|
|
* of all they only see the onscreen formats (the offscreen formats are at the end of the
|
|
* pixelformat list) and second extended pixelformat capabilities are hidden from the
|
|
* standard WGL calls. Only functions that depend on WGL_ARB_pixel_format can see them.
|
|
*
|
|
* Below we check if the pixelformat is also supported onscreen.
|
|
*/
|
|
if(iPixelFormat != 0)
|
|
{
|
|
HDC pbuffer_hdc;
|
|
HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
|
|
if(!pbuffer)
|
|
skip("Pbuffer creation failed!\n");
|
|
|
|
/* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
|
|
pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
|
|
res = GetPixelFormat(pbuffer_hdc);
|
|
ok(res == iPixelFormat, "Unexpected iPixelFormat=%d returned by GetPixelFormat for format %d\n", res, iPixelFormat);
|
|
trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
|
|
trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
|
|
|
|
pwglReleasePbufferDCARB(pbuffer, hdc);
|
|
}
|
|
else skip("Pbuffer test for onscreen pixelformat skipped as no onscreen format with pbuffer capabilities have been found\n");
|
|
|
|
/* Search for a real offscreen format */
|
|
for(i=0, iPixelFormat=0; i<nFormats; i++)
|
|
{
|
|
if(iFormats[i] > nOnscreenFormats)
|
|
{
|
|
iPixelFormat = iFormats[i];
|
|
trace("Selected iPixelFormat: %d\n", iPixelFormat);
|
|
break;
|
|
}
|
|
}
|
|
|
|
if(iPixelFormat != 0)
|
|
{
|
|
HDC pbuffer_hdc;
|
|
HPBUFFERARB pbuffer = pwglCreatePbufferARB(hdc, iPixelFormat, 640 /* width */, 480 /* height */, NULL);
|
|
if(!pbuffer)
|
|
skip("Pbuffer creation failed!\n");
|
|
|
|
/* Test the pixelformat returned by GetPixelFormat on a pbuffer as the behavior is not clear */
|
|
pbuffer_hdc = pwglGetPbufferDCARB(pbuffer);
|
|
res = GetPixelFormat(pbuffer_hdc);
|
|
|
|
ok(res == 1, "Unexpected iPixelFormat=%d (1 expected) returned by GetPixelFormat for offscreen format %d\n", res, iPixelFormat);
|
|
trace("iPixelFormat returned by GetPixelFormat: %d\n", res);
|
|
trace("PixelFormat from wglChoosePixelFormatARB: %d\n", iPixelFormat);
|
|
pwglReleasePbufferDCARB(pbuffer, hdc);
|
|
}
|
|
else skip("Pbuffer test for offscreen pixelformat skipped as no offscreen-only format with pbuffer capabilities has been found\n");
|
|
}
|
|
|
|
static void test_choosepixelformat(HDC hdc)
|
|
{
|
|
int iPixelFormat;
|
|
int nFormats;
|
|
BOOL found=FALSE;
|
|
PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR),
|
|
1, /* version */
|
|
PFD_DRAW_TO_WINDOW |
|
|
PFD_SUPPORT_OPENGL |
|
|
PFD_DOUBLEBUFFER,
|
|
PFD_TYPE_RGBA,
|
|
32, /* 32-bit color depth */
|
|
0, 0, 0, 0, 0, 0, /* color bits */
|
|
0, /* alpha buffer */
|
|
0, /* shift bit */
|
|
0, /* accumulation buffer */
|
|
0, 0, 0, 0, /* accum bits */
|
|
0, /* z-buffer */
|
|
0, /* stencil buffer */
|
|
0, /* auxiliary buffer */
|
|
PFD_MAIN_PLANE, /* main layer */
|
|
0, /* reserved */
|
|
0, 0, 0 /* layer masks */
|
|
};
|
|
|
|
/* Below we test the behavior of ChoosePixelFormat. As documented on MSDN this
|
|
* function doesn't give any guarantees about its outcome. Programs should not
|
|
* rely on weird behavior of the function but unfortunately a few programs like
|
|
* e.g. Serious Sam TSE rely on it.
|
|
*
|
|
* MSDN documents of a few flags like double buffering / stereo that they can be set to DONTCARE.
|
|
* It appears that a 0 value on other options like alpha, red, .. means DONTCARE. The hypothesis
|
|
* is that ChoosePixelFormat returns the first available format which matches the criteria.
|
|
*
|
|
* This test tries to proof the DONTCARE behavior by passing an almost 'empty' pfd to
|
|
* ChoosePixelFormat. The pfd only has some really needed flags (RGBA, window, double buffer) set.
|
|
* Further a 32 bit color buffer has been requested. The idea is that when a format with e.g. depth or stencil bits
|
|
* is returned, while there are also 'better' candidates in the list wihtout them (but located AFTER the returned one)
|
|
* that an option set to zero means DONTCARE. We try to proof this by checking the aux/depth/stencil bits.
|
|
* Proofing this behavior for the color bits isn't possible as all formats have red/green/blue/(alpha), so we assume
|
|
* that if it holds for aux/depth/stencil it also holds for the others.
|
|
*
|
|
* The test below passes at least on various ATI cards (rv250, r300) and Nvidia cards.
|
|
*/
|
|
|
|
iPixelFormat = ChoosePixelFormat(hdc, &pfd);
|
|
if(iPixelFormat) {
|
|
PIXELFORMATDESCRIPTOR pfd_tmp;
|
|
BOOL res;
|
|
int i;
|
|
|
|
memset(&pfd, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
res = DescribePixelFormat(hdc, iPixelFormat, sizeof(PIXELFORMATDESCRIPTOR), &pfd);
|
|
|
|
nFormats = DescribePixelFormat(hdc, 0, 0, NULL);
|
|
/* Start testing from iPixelFormat, second formats start counting from index=1, so use '<=' */
|
|
for(i=iPixelFormat; i<=nFormats; i++) {
|
|
memset(&pfd_tmp, 0, sizeof(PIXELFORMATDESCRIPTOR));
|
|
res = DescribePixelFormat(hdc, i, sizeof(PIXELFORMATDESCRIPTOR), &pfd_tmp);
|
|
if(!res)
|
|
continue;
|
|
|
|
/* Check if there is a format which better matches the requirements */
|
|
if((pfd_tmp.cAuxBuffers < pfd.cAuxBuffers) || (pfd_tmp.cDepthBits < pfd.cDepthBits) || (pfd_tmp.cStencilBits < pfd.cStencilBits))
|
|
found = TRUE;
|
|
}
|
|
|
|
/* When found=TRUE we were able to confirm our hypothesis */
|
|
ok(found == TRUE, "Unable to confirm DONTCARE behavior of unset pixelformatdescriptor flags\n");
|
|
}
|
|
|
|
}
|
|
|
|
static void test_setpixelformat(HDC winhdc)
|
|
{
|
|
int res = 0;
|
|
int nCfgs;
|
|
int pf;
|
|
int i;
|
|
PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR),
|
|
1, /* version */
|
|
PFD_DRAW_TO_WINDOW |
|
|
PFD_SUPPORT_OPENGL |
|
|
PFD_DOUBLEBUFFER,
|
|
PFD_TYPE_RGBA,
|
|
24, /* 24-bit color depth */
|
|
0, 0, 0, 0, 0, 0, /* color bits */
|
|
0, /* alpha buffer */
|
|
0, /* shift bit */
|
|
0, /* accumulation buffer */
|
|
0, 0, 0, 0, /* accum bits */
|
|
32, /* z-buffer */
|
|
0, /* stencil buffer */
|
|
0, /* auxiliary buffer */
|
|
PFD_MAIN_PLANE, /* main layer */
|
|
0, /* reserved */
|
|
0, 0, 0 /* layer masks */
|
|
};
|
|
|
|
HDC hdc = GetDC(0);
|
|
ok(hdc != 0, "GetDC(0) failed!\n");
|
|
|
|
/* This should pass even on the main device context */
|
|
pf = ChoosePixelFormat(hdc, &pfd);
|
|
ok(pf != 0, "ChoosePixelFormat failed on main device context\n");
|
|
|
|
/* SetPixelFormat on the main device context 'X root window' should fail */
|
|
res = SetPixelFormat(hdc, pf, &pfd);
|
|
ok(res == 0, "SetPixelFormat on main device context should fail\n");
|
|
|
|
/* Setting the same format that was set on the HDC is allowed; other
|
|
formats fail */
|
|
nCfgs = DescribePixelFormat(winhdc, 0, 0, NULL);
|
|
pf = GetPixelFormat(winhdc);
|
|
for(i = 1;i <= nCfgs;i++)
|
|
{
|
|
int res = SetPixelFormat(winhdc, i, NULL);
|
|
if(i == pf) ok(res, "Failed to set the same pixel format\n");
|
|
else ok(!res, "Unexpectedly set an alternate pixel format\n");
|
|
}
|
|
}
|
|
|
|
static void test_colorbits(HDC hdc)
|
|
{
|
|
const int iAttribList[] = { WGL_COLOR_BITS_ARB, WGL_RED_BITS_ARB, WGL_GREEN_BITS_ARB,
|
|
WGL_BLUE_BITS_ARB, WGL_ALPHA_BITS_ARB };
|
|
int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
|
|
const int iAttribs[] = { WGL_ALPHA_BITS_ARB, 1, 0 };
|
|
unsigned int nFormats;
|
|
int res;
|
|
int iPixelFormat = 0;
|
|
|
|
if (!pwglChoosePixelFormatARB)
|
|
{
|
|
skip("wglChoosePixelFormatARB is not available\n");
|
|
return;
|
|
}
|
|
|
|
/* We need a pixel format with at least one bit of alpha */
|
|
res = pwglChoosePixelFormatARB(hdc, iAttribs, NULL, 1, &iPixelFormat, &nFormats);
|
|
if(res == FALSE || nFormats == 0)
|
|
{
|
|
skip("No suitable pixel formats found\n");
|
|
return;
|
|
}
|
|
|
|
res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
|
|
sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList, iAttribRet);
|
|
if(res == FALSE)
|
|
{
|
|
skip("wglGetPixelFormatAttribivARB failed\n");
|
|
return;
|
|
}
|
|
iAttribRet[1] += iAttribRet[2]+iAttribRet[3]+iAttribRet[4];
|
|
ok(iAttribRet[0] == iAttribRet[1], "WGL_COLOR_BITS_ARB (%d) does not equal R+G+B+A (%d)!\n",
|
|
iAttribRet[0], iAttribRet[1]);
|
|
}
|
|
|
|
static void test_gdi_dbuf(HDC hdc)
|
|
{
|
|
const int iAttribList[] = { WGL_SUPPORT_GDI_ARB, WGL_DOUBLE_BUFFER_ARB };
|
|
int iAttribRet[sizeof(iAttribList)/sizeof(iAttribList[0])];
|
|
unsigned int nFormats;
|
|
int iPixelFormat;
|
|
int res;
|
|
|
|
if (!pwglGetPixelFormatAttribivARB)
|
|
{
|
|
skip("wglGetPixelFormatAttribivARB is not available\n");
|
|
return;
|
|
}
|
|
|
|
nFormats = DescribePixelFormat(hdc, 0, 0, NULL);
|
|
for(iPixelFormat = 1;iPixelFormat <= nFormats;iPixelFormat++)
|
|
{
|
|
res = pwglGetPixelFormatAttribivARB(hdc, iPixelFormat, 0,
|
|
sizeof(iAttribList)/sizeof(iAttribList[0]), iAttribList,
|
|
iAttribRet);
|
|
ok(res!=FALSE, "wglGetPixelFormatAttribivARB failed for pixel format %d\n", iPixelFormat);
|
|
if(res == FALSE)
|
|
continue;
|
|
|
|
ok(!(iAttribRet[0] && iAttribRet[1]), "GDI support and double buffering on pixel format %d\n", iPixelFormat);
|
|
}
|
|
}
|
|
|
|
static void test_make_current_read(HDC hdc)
|
|
{
|
|
int res;
|
|
HDC hread;
|
|
HGLRC hglrc = wglCreateContext(hdc);
|
|
|
|
if(!hglrc)
|
|
{
|
|
skip("wglCreateContext failed!\n");
|
|
return;
|
|
}
|
|
|
|
res = wglMakeCurrent(hdc, hglrc);
|
|
if(!res)
|
|
{
|
|
skip("wglMakeCurrent failed!\n");
|
|
return;
|
|
}
|
|
|
|
/* Test what wglGetCurrentReadDCARB does for wglMakeCurrent as the spec doesn't mention it */
|
|
hread = pwglGetCurrentReadDCARB();
|
|
trace("hread %p, hdc %p\n", hread, hdc);
|
|
ok(hread == hdc, "wglGetCurrentReadDCARB failed for standard wglMakeCurrent\n");
|
|
|
|
pwglMakeContextCurrentARB(hdc, hdc, hglrc);
|
|
hread = pwglGetCurrentReadDCARB();
|
|
ok(hread == hdc, "wglGetCurrentReadDCARB failed for wglMakeContextCurrent\n");
|
|
}
|
|
|
|
static void test_dc(HWND hwnd, HDC hdc)
|
|
{
|
|
int pf1, pf2;
|
|
HDC hdc2;
|
|
|
|
/* Get another DC and make sure it has the same pixel format */
|
|
hdc2 = GetDC(hwnd);
|
|
if(hdc != hdc2)
|
|
{
|
|
pf1 = GetPixelFormat(hdc);
|
|
pf2 = GetPixelFormat(hdc2);
|
|
ok(pf1 == pf2, "Second DC does not have the same format (%d != %d)\n", pf1, pf2);
|
|
}
|
|
else
|
|
skip("Could not get a different DC for the window\n");
|
|
|
|
if(hdc2)
|
|
{
|
|
ReleaseDC(hwnd, hdc2);
|
|
hdc2 = NULL;
|
|
}
|
|
}
|
|
|
|
START_TEST(opengl)
|
|
{
|
|
HWND hwnd;
|
|
PIXELFORMATDESCRIPTOR pfd = {
|
|
sizeof(PIXELFORMATDESCRIPTOR),
|
|
1, /* version */
|
|
PFD_DRAW_TO_WINDOW |
|
|
PFD_SUPPORT_OPENGL |
|
|
PFD_DOUBLEBUFFER,
|
|
PFD_TYPE_RGBA,
|
|
24, /* 24-bit color depth */
|
|
0, 0, 0, 0, 0, 0, /* color bits */
|
|
0, /* alpha buffer */
|
|
0, /* shift bit */
|
|
0, /* accumulation buffer */
|
|
0, 0, 0, 0, /* accum bits */
|
|
32, /* z-buffer */
|
|
0, /* stencil buffer */
|
|
0, /* auxiliary buffer */
|
|
PFD_MAIN_PLANE, /* main layer */
|
|
0, /* reserved */
|
|
0, 0, 0 /* layer masks */
|
|
};
|
|
|
|
hwnd = CreateWindow("static", "Title", WS_OVERLAPPEDWINDOW,
|
|
10, 10, 200, 200, NULL, NULL, NULL, NULL);
|
|
ok(hwnd != NULL, "err: %d\n", GetLastError());
|
|
if (hwnd)
|
|
{
|
|
HDC hdc;
|
|
int iPixelFormat, res;
|
|
HGLRC hglrc;
|
|
DWORD error;
|
|
ShowWindow(hwnd, SW_SHOW);
|
|
|
|
hdc = GetDC(hwnd);
|
|
|
|
iPixelFormat = ChoosePixelFormat(hdc, &pfd);
|
|
ok(iPixelFormat > 0, "No pixelformat found!\n"); /* This should never happen as ChoosePixelFormat always returns a closest match */
|
|
|
|
/* We shouldn't be able to create a context from a hdc which doesn't have a pixel format set */
|
|
hglrc = wglCreateContext(hdc);
|
|
ok(hglrc == NULL, "wglCreateContext should fail when no pixel format has been set, but it passed\n");
|
|
error = GetLastError();
|
|
ok(error == ERROR_INVALID_PIXEL_FORMAT, "expected ERROR_INVALID_PIXEL_FORMAT for wglCreateContext without a pixelformat set, but received %#x\n", error);
|
|
|
|
res = SetPixelFormat(hdc, iPixelFormat, &pfd);
|
|
ok(res, "SetPixelformat failed: %x\n", GetLastError());
|
|
|
|
test_dc(hwnd, hdc);
|
|
|
|
hglrc = wglCreateContext(hdc);
|
|
res = wglMakeCurrent(hdc, hglrc);
|
|
ok(res, "wglMakeCurrent failed!\n");
|
|
init_functions();
|
|
|
|
test_choosepixelformat(hdc);
|
|
test_setpixelformat(hdc);
|
|
test_colorbits(hdc);
|
|
test_gdi_dbuf(hdc);
|
|
|
|
if (!pwglGetExtensionsStringARB)
|
|
{
|
|
skip("wglGetExtensionsStringARB is not available\n");
|
|
DestroyWindow(hwnd);
|
|
return;
|
|
}
|
|
|
|
wgl_extensions = pwglGetExtensionsStringARB(hdc);
|
|
if(wgl_extensions == NULL) skip("Skipping opengl32 tests because this OpenGL implementation doesn't support WGL extensions!\n");
|
|
|
|
if(strstr(wgl_extensions, "WGL_ARB_make_current_read"))
|
|
test_make_current_read(hdc);
|
|
else
|
|
trace("WGL_ARB_make_current_read not supported, skipping test\n");
|
|
|
|
if(strstr(wgl_extensions, "WGL_ARB_pbuffer"))
|
|
test_pbuffers(hdc);
|
|
else
|
|
trace("WGL_ARB_pbuffer not supported, skipping pbuffer test\n");
|
|
|
|
DestroyWindow(hwnd);
|
|
}
|
|
}
|