void Test_ClassAtoms()
{
ATOM atom;
int i;
WNDCLASSW cls;
// Initialize starting Atom number.
atom = GetClassInfoW(NULL, ControlsList[0], &cls);
if (!atom)
{
skip( "No reference Atom\n" );
return;
}
trace("First Control Class Atom 0x%x\n",atom);
for (i = 0; i < 17; atom++ ,i++)
{
if (lstrcmpW(ControlsList[i],L"\0"))
{
ATOM test_atom = GetClassInfoW(NULL, ControlsList[i], &cls);
// Skip unregistered Classes.
if (test_atom)
{
ok(test_atom == atom, "%S class atom did not match %x:%x\n",ControlsList[i],test_atom,atom);
ok(!lstrcmpW(cls.lpszClassName,ControlsList[i]),"GetClassName returned incorrect name\n");
}
}
}
}
HWND
WGLLibrary::CreateDummyWindow(HDC *aWindowDC)
{
WNDCLASSW wc;
if (!GetClassInfoW(GetModuleHandle(NULL), L"GLContextWGLClass", &wc)) {
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.style = CS_OWNDC;
wc.hInstance = GetModuleHandle(NULL);
wc.lpfnWndProc = DefWindowProc;
wc.lpszClassName = L"GLContextWGLClass";
if (!RegisterClassW(&wc)) {
NS_WARNING("Failed to register GLContextWGLClass?!");
// er. failed to register our class?
return NULL;
}
}
HWND win = CreateWindowW(L"GLContextWGLClass", L"GLContextWGL", 0,
0, 0, 16, 16,
NULL, NULL, GetModuleHandle(NULL), NULL);
NS_ENSURE_TRUE(win, NULL);
HDC dc = GetDC(win);
NS_ENSURE_TRUE(dc, NULL);
if (mWindowPixelFormat == 0) {
PIXELFORMATDESCRIPTOR pfd;
ZeroMemory(&pfd, sizeof(PIXELFORMATDESCRIPTOR));
pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
pfd.nVersion = 1;
pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL;
if (mUseDoubleBufferedWindows)
pfd.dwFlags |= PFD_DOUBLEBUFFER;
pfd.iPixelType = PFD_TYPE_RGBA;
pfd.cColorBits = 24;
pfd.cRedBits = 8;
pfd.cGreenBits = 8;
pfd.cBlueBits = 8;
pfd.cAlphaBits = 8;
pfd.cDepthBits = 0;
pfd.iLayerType = PFD_MAIN_PLANE;
mWindowPixelFormat = ChoosePixelFormat(dc, &pfd);
}
if (!mWindowPixelFormat ||
!SetPixelFormat(dc, mWindowPixelFormat, NULL))
{
NS_WARNING("SetPixelFormat failed!");
DestroyWindow(win);
return NULL;
}
if (aWindowDC) {
*aWindowDC = dc;
}
return win;
}
BOOL CDreamSkinStatic::InitialClass()
{
//Get the default window proc for this class
WNDCLASSW clsStaticDefault;
if(!GetClassInfoW(GetModuleHandle(NULL), DEFAULT_STATIC_CLASSNAME_W, &clsStaticDefault))
{
//Get class info failed
//TODO: add error handle code
return FALSE;
}
s_DefaultWindowProc = clsStaticDefault.lpfnWndProc;
GetDefaultSkin(&s_SkinStatic);
return TRUE;
}
nsresult
TaskbarTabPreview::Enable() {
WNDCLASSW wc;
HINSTANCE module = GetModuleHandle(nullptr);
if (!GetClassInfoW(module, kWindowClass, &wc)) {
wc.style = 0;
wc.lpfnWndProc = GlobalWndProc;
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = module;
wc.hIcon = nullptr;
wc.hCursor = nullptr;
wc.hbrBackground = (HBRUSH) nullptr;
wc.lpszMenuName = (LPCWSTR) nullptr;
wc.lpszClassName = kWindowClass;
RegisterClassW(&wc);
}
::CreateWindowW(kWindowClass, L"TaskbarPreviewWindow",
WS_CAPTION | WS_SYSMENU, 0, 0, 200, 60,
nullptr, nullptr, module, this);
// GlobalWndProc will set mProxyWindow so that WM_CREATE can have a valid HWND
if (!mProxyWindow)
return NS_ERROR_INVALID_ARG;
UpdateProxyWindowStyle();
nsresult rv = TaskbarPreview::Enable();
nsresult rvUpdate;
rvUpdate = UpdateTitle();
if (NS_FAILED(rvUpdate))
rv = rvUpdate;
rvUpdate = UpdateIcon();
if (NS_FAILED(rvUpdate))
rv = rvUpdate;
return rv;
}
void
EnableBatteryNotifications()
{
// Create custom window to watch battery event
// If we can get Gecko's window handle, this is unnecessary.
if (sHWnd == nullptr) {
WNDCLASSW wc;
HMODULE hSelf = GetModuleHandle(nullptr);
if (!GetClassInfoW(hSelf, L"MozillaBatteryClass", &wc)) {
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.hInstance = hSelf;
wc.lpfnWndProc = BatteryWindowProc;
wc.lpszClassName = L"MozillaBatteryClass";
RegisterClassW(&wc);
}
sHWnd = CreateWindowW(L"MozillaBatteryClass", L"Battery Watcher",
0, 0, 0, 0, 0,
nullptr, nullptr, hSelf, nullptr);
}
if (sHWnd == nullptr) {
return;
}
sPowerHandle =
RegisterPowerSettingNotification(sHWnd,
&GUID_ACDC_POWER_SOURCE,
DEVICE_NOTIFY_WINDOW_HANDLE);
sCapacityHandle =
RegisterPowerSettingNotification(sHWnd,
&GUID_BATTERY_PERCENTAGE_REMAINING,
DEVICE_NOTIFY_WINDOW_HANDLE);
}
bool
DeviceManagerD3D9::Init()
{
WNDCLASSW wc;
HRESULT hr;
if (!GetClassInfoW(GetModuleHandle(nullptr), kClassName, &wc)) {
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.hInstance = GetModuleHandle(nullptr);
wc.lpfnWndProc = ::DefWindowProc;
wc.lpszClassName = kClassName;
if (!RegisterClassW(&wc)) {
gfxCriticalError() << "[D3D9] Failed to register class for DeviceManager";
return false;
}
}
mFocusWnd = ::CreateWindowW(kClassName, L"D3D9Window", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, nullptr,
nullptr, GetModuleHandle(nullptr), nullptr);
if (!mFocusWnd) {
gfxCriticalError() << "[D3D9] Failed to create a window";
return false;
}
if (gfxPrefs::StereoVideoEnabled()) {
/* Create an Nv3DVUtils instance */
if (!mNv3DVUtils) {
mNv3DVUtils = new Nv3DVUtils();
if (!mNv3DVUtils) {
NS_WARNING("Could not create a new instance of Nv3DVUtils.");
}
}
/* Initialize the Nv3DVUtils object */
if (mNv3DVUtils) {
mNv3DVUtils->Initialize();
}
}
HMODULE d3d9 = LoadLibraryW(L"d3d9.dll");
decltype(Direct3DCreate9)* d3d9Create = (decltype(Direct3DCreate9)*)
GetProcAddress(d3d9, "Direct3DCreate9");
decltype(Direct3DCreate9Ex)* d3d9CreateEx = (decltype(Direct3DCreate9Ex)*)
GetProcAddress(d3d9, "Direct3DCreate9Ex");
#ifdef USE_D3D9EX
if (d3d9CreateEx) {
hr = d3d9CreateEx(D3D_SDK_VERSION, getter_AddRefs(mD3D9Ex));
if (SUCCEEDED(hr)) {
mD3D9 = mD3D9Ex;
}
}
#endif
if (!mD3D9) {
if (!d3d9Create) {
gfxCriticalError() << "[D3D9] Failed to load symbols";
return false;
}
mD3D9 = dont_AddRef(d3d9Create(D3D_SDK_VERSION));
if (!mD3D9) {
gfxCriticalError() << "[D3D9] Failed to create the IDirect3D9 object";
return false;
}
}
D3DADAPTER_IDENTIFIER9 ident;
hr = mD3D9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &ident);
if (FAILED(hr)) {
gfxCriticalError() << "[D3D9] Failed to create the environment code: " << gfx::hexa(hr);
return false;
}
D3DPRESENT_PARAMETERS pp;
memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS));
pp.BackBufferWidth = 1;
pp.BackBufferHeight = 1;
pp.BackBufferFormat = D3DFMT_A8R8G8B8;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.Windowed = TRUE;
pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
pp.hDeviceWindow = mFocusWnd;
if (mD3D9Ex) {
hr = mD3D9Ex->CreateDeviceEx(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
mFocusWnd,
D3DCREATE_FPU_PRESERVE |
D3DCREATE_MULTITHREADED |
D3DCREATE_MIXED_VERTEXPROCESSING,
&pp,
nullptr,
getter_AddRefs(mDeviceEx));
if (SUCCEEDED(hr)) {
mDevice = mDeviceEx;
}
D3DCAPS9 caps;
if (mDeviceEx && mDeviceEx->GetDeviceCaps(&caps)) {
if (LACKS_CAP(caps.Caps2, D3DCAPS2_DYNAMICTEXTURES)) {
// XXX - Should we actually hit this we'll need a CanvasLayer that
// supports static D3DPOOL_DEFAULT textures.
NS_WARNING("D3D9Ex device not used because of lack of support for \
dynamic textures. This is unexpected.");
mDevice = nullptr;
mDeviceEx = nullptr;
}
}
}
bool
DeviceManagerD3D9::Init()
{
WNDCLASSW wc;
HRESULT hr;
if (!GetClassInfoW(GetModuleHandle(NULL), kClassName, &wc)) {
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.hInstance = GetModuleHandle(NULL);
wc.lpfnWndProc = ::DefWindowProc;
wc.lpszClassName = kClassName;
if (!RegisterClassW(&wc)) {
NS_WARNING("Failed to register window class for DeviceManager.");
return false;
}
}
mFocusWnd = ::CreateWindowW(kClassName, L"D3D9Window", WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, NULL,
NULL, GetModuleHandle(NULL), NULL);
if (!mFocusWnd) {
NS_WARNING("Failed to create DeviceManagerD3D9 Window.");
return false;
}
/* Create an Nv3DVUtils instance */
if (!mNv3DVUtils) {
mNv3DVUtils = new Nv3DVUtils();
if (!mNv3DVUtils) {
NS_WARNING("Could not create a new instance of Nv3DVUtils.\n");
}
}
/* Initialize the Nv3DVUtils object */
if (mNv3DVUtils) {
mNv3DVUtils->Initialize();
}
HMODULE d3d9 = LoadLibraryW(L"d3d9.dll");
Direct3DCreate9Func d3d9Create = (Direct3DCreate9Func)
GetProcAddress(d3d9, "Direct3DCreate9");
Direct3DCreate9ExFunc d3d9CreateEx = (Direct3DCreate9ExFunc)
GetProcAddress(d3d9, "Direct3DCreate9Ex");
#ifdef USE_D3D9EX
if (d3d9CreateEx) {
hr = d3d9CreateEx(D3D_SDK_VERSION, getter_AddRefs(mD3D9Ex));
if (SUCCEEDED(hr)) {
mD3D9 = mD3D9Ex;
}
}
#endif
if (!mD3D9) {
if (!d3d9Create) {
return false;
}
mD3D9 = dont_AddRef(d3d9Create(D3D_SDK_VERSION));
if (!mD3D9) {
return false;
}
}
D3DADAPTER_IDENTIFIER9 ident;
hr = mD3D9->GetAdapterIdentifier(D3DADAPTER_DEFAULT, 0, &ident);
if (FAILED(hr)) {
return false;
}
if (!PL_strncasecmp(ident.Driver, "nvumdshim.dll", PL_strlen(ident.Driver))) {
// XXX - This is a device using NVidia Optimus. We have no idea how to do
// interop here so let's fail and use BasicLayers. See bug 597320.
return false;
}
D3DPRESENT_PARAMETERS pp;
memset(&pp, 0, sizeof(D3DPRESENT_PARAMETERS));
pp.BackBufferWidth = 1;
pp.BackBufferHeight = 1;
pp.BackBufferFormat = D3DFMT_A8R8G8B8;
pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
pp.Windowed = TRUE;
pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
pp.hDeviceWindow = mFocusWnd;
if (mD3D9Ex) {
hr = mD3D9Ex->CreateDeviceEx(D3DADAPTER_DEFAULT,
D3DDEVTYPE_HAL,
mFocusWnd,
D3DCREATE_FPU_PRESERVE |
D3DCREATE_MULTITHREADED |
D3DCREATE_MIXED_VERTEXPROCESSING,
&pp,
NULL,
getter_AddRefs(mDeviceEx));
if (SUCCEEDED(hr)) {
mDevice = mDeviceEx;
}
D3DCAPS9 caps;
if (mDeviceEx && mDeviceEx->GetDeviceCaps(&caps)) {
if (LACKS_CAP(caps.Caps2, D3DCAPS2_DYNAMICTEXTURES)) {
// XXX - Should we actually hit this we'll need a CanvasLayer that
// supports static D3DPOOL_DEFAULT textures.
NS_WARNING("D3D9Ex device not used because of lack of support for \
dynamic textures. This is unexpected.");
mDevice = nsnull;
mDeviceEx = nsnull;
}
}
}
void
EnableBatteryNotifications()
{
#if MOZ_WINSDK_TARGETVER >= MOZ_NTDDI_LONGHORN
if (IsVistaOrLater()) {
// RegisterPowerSettingNotification is from Vista or later.
// Use this API if available.
HMODULE hUser32 = GetModuleHandleW(L"USER32.DLL");
if (!sRegisterPowerSettingNotification)
sRegisterPowerSettingNotification = (REGISTERPOWERSETTINGNOTIFICATION)
GetProcAddress(hUser32, "RegisterPowerSettingNotification");
if (!sUnregisterPowerSettingNotification)
sUnregisterPowerSettingNotification = (UNREGISTERPOWERSETTINGNOTIFICATION)
GetProcAddress(hUser32, "UnregisterPowerSettingNotification");
if (!sRegisterPowerSettingNotification ||
!sUnregisterPowerSettingNotification) {
NS_ASSERTION(false, "Canot find PowerSettingNotification functions.");
return;
}
// Create custom window to watch battery event
// If we can get Gecko's window handle, this is unnecessary.
if (sHWnd == nsnull) {
WNDCLASSW wc;
HMODULE hSelf = GetModuleHandle(nsnull);
if (!GetClassInfoW(hSelf, L"MozillaBatteryClass", &wc)) {
ZeroMemory(&wc, sizeof(WNDCLASSW));
wc.hInstance = hSelf;
wc.lpfnWndProc = BatteryWindowProc;
wc.lpszClassName = L"MozillaBatteryClass";
RegisterClassW(&wc);
}
sHWnd = CreateWindowW(L"MozillaBatteryClass", L"Battery Watcher",
0, 0, 0, 0, 0,
nsnull, nsnull, hSelf, nsnull);
}
if (sHWnd == nsnull) {
return;
}
sPowerHandle =
sRegisterPowerSettingNotification(sHWnd,
&GUID_ACDC_POWER_SOURCE,
DEVICE_NOTIFY_WINDOW_HANDLE);
sCapacityHandle =
sRegisterPowerSettingNotification(sHWnd,
&GUID_BATTERY_PERCENTAGE_REMAINING,
DEVICE_NOTIFY_WINDOW_HANDLE);
} else
#endif
{
// for Windows 2000 and Windwos XP. If we remove Windows XP support,
// we should remove timer-based power notification
sUpdateTimer = do_CreateInstance(NS_TIMER_CONTRACTID);
if (sUpdateTimer) {
sUpdateTimer->InitWithFuncCallback(UpdateHandler,
nsnull,
Preferences::GetInt("dom.battery.timer",
30000 /* 30s */),
nsITimer::TYPE_REPEATING_SLACK);
}
}
}
bool CWebWindow::_createWindow(HWND parent, unsigned styles, unsigned styleEx, int x, int y, int width, int height)
{
if (IsWindow(m_hwnd))
return true;
const wchar_t* szClassName = L"wkeWebWindow";
MSG msg = { 0 };
WNDCLASSW wndClass = { 0 };
if (!GetClassInfoW(NULL, szClassName, &wndClass))
{
wndClass.style = CS_HREDRAW | CS_VREDRAW;
wndClass.lpfnWndProc = &CWebWindow::_staticWindowProc;
wndClass.cbClsExtra = 200;
wndClass.cbWndExtra = 200;
wndClass.hInstance = GetModuleHandleW(NULL);
wndClass.hIcon = LoadIcon(NULL, IDI_APPLICATION);
wndClass.hCursor = LoadCursor(NULL, IDC_ARROW);
wndClass.hbrBackground= NULL;
wndClass.lpszMenuName = NULL;
wndClass.lpszClassName = szClassName;
RegisterClassW(&wndClass);
}
//DWORD styleEx = 0;
//DWORD styles = 0;
//if (WKE_WINDOW_STYLE_LAYERED == (styleFlags & WKE_WINDOW_STYLE_LAYERED))
// styleEx = WS_EX_LAYERED;
//if (WKE_WINDOW_STYLE_CHILD == (styleFlags & WKE_WINDOW_STYLE_CHILD))
// styles |= WS_CHILD;
//else
// styles |= WS_POPUP|WS_CAPTION|WS_SYSMENU|WS_THICKFRAME;
//if (WKE_WINDOW_STYLE_BORDER == (styleFlags & WKE_WINDOW_STYLE_BORDER))
// styles |= WS_BORDER;
//if (WKE_WINDOW_STYLE_CAPTION == (styleFlags & WKE_WINDOW_STYLE_CAPTION))
// styles |= WS_CAPTION;
//if (WKE_WINDOW_STYLE_SIZEBOX == (styleFlags & WKE_WINDOW_STYLE_SIZEBOX))
// styles |= WS_SIZEBOX;
//if (WKE_WINDOW_STYLE_SHOWLOADING == (styleFlags & WKE_WINDOW_STYLE_SHOWLOADING))
// styles |= WS_VISIBLE;
m_hwnd = CreateWindowExW(
styleEx, // window ex-style
szClassName, // window class name
L"wkeWebWindow", // window caption
styles, // window style
x, // initial x position
y, // initial y position
width, // initial x size
height, // initial y size
parent, // parent window handle
NULL, // window menu handle
GetModuleHandleW(NULL), // program instance handle
this); // creation parameters
if (!IsWindow(m_hwnd))
return FALSE;
CWebView::setHostWindow(m_hwnd);
CWebView::resize(width, height);
return TRUE;
}
BOOL InquireIme(
PIMEDPI pImeDpi)
{
WNDCLASS wc;
WCHAR wszClassName[IM_UI_CLASS_SIZE];
PIMEINFO pImeInfo = &pImeDpi->ImeInfo;
(*pImeDpi->pfn.ImeInquire.w)(pImeInfo, (PVOID)wszClassName, NULL);
/*
* parameter checking for each fields.
*/
if (pImeInfo->dwPrivateDataSize == 0)
pImeInfo->dwPrivateDataSize = sizeof(UINT);
if (pImeInfo->fdwProperty & ~(IME_PROP_ALL)) {
RIPMSG0(RIP_WARNING, "wrong property");
return FALSE;
}
if (pImeInfo->fdwConversionCaps & ~(IME_CMODE_ALL)) {
RIPMSG0(RIP_WARNING, "wrong conversion capabilities");
return FALSE;
}
if (pImeInfo->fdwSentenceCaps & ~(IME_SMODE_ALL)) {
RIPMSG0(RIP_WARNING, "wrong sentence capabilities");
return FALSE;
}
if (pImeInfo->fdwUICaps & ~(UI_CAP_ALL)) {
RIPMSG0(RIP_WARNING, "wrong UI capabilities");
return FALSE;
}
if (pImeInfo->fdwSCSCaps & ~(SCS_CAP_ALL)) {
RIPMSG0(RIP_WARNING, "wrong set comp string capabilities");
return FALSE;
}
if (pImeInfo->fdwSelectCaps & ~(SELECT_CAP_ALL)) {
RIPMSG0(RIP_WARNING, "wrong select capabilities");
return FALSE;
}
if (!(pImeInfo->fdwProperty & IME_PROP_UNICODE)) {
ANSI_STRING AnsiString;
UNICODE_STRING UnicodeString;
RtlInitAnsiString(&AnsiString, (LPSTR)wszClassName);
UnicodeString.MaximumLength = (SHORT)sizeof(pImeDpi->wszUIClass);
UnicodeString.Buffer = pImeDpi->wszUIClass;
if (!NT_SUCCESS(RtlAnsiStringToUnicodeString(&UnicodeString,
&AnsiString,
FALSE))) {
return FALSE;
}
}
else {
RtlCopyMemory(pImeDpi->wszUIClass, wszClassName, sizeof(wszClassName));
pImeDpi->wszUIClass[IM_UI_CLASS_SIZE-1] = L'\0';
}
if (!GetClassInfoW((HINSTANCE)pImeDpi->hInst, pImeDpi->wszUIClass, &wc)) {
RIPMSG1(RIP_WARNING, "UI class (%ws) not found in this IME", pImeDpi->wszUIClass);
return FALSE;
} else if (wc.cbWndExtra < sizeof(DWORD) * 2) {
RIPMSG0(RIP_WARNING, "UI class cbWndExtra problem");
return FALSE;
}
return TRUE;
}