{

LONG_PTR longPtr = ::GetWindowLongPtr(hWnd, 0);

if (WebView* webView = reinterpret_cast<WebView*>(longPtr))

return webView->wndProc(hWnd, message, wParam, lParam);

if (message == WM_CREATE) {

LPCREATESTRUCT createStruct = reinterpret_cast<LPCREATESTRUCT>(lParam);

// Associate the WebView with the window.

::SetWindowLongPtr(hWnd, 0, (LONG_PTR)createStruct->lpCreateParams);

return 0;

}

return ::DefWindowProc(hWnd, message, wParam, lParam);

{

LRESULT lResult = 0;

bool handled = true;

switch (message) {

case WM_CLOSE:

m_page->tryClose();

break;

case WM_DESTROY:

m_isBeingDestroyed = true;

close();

break;

case WM_ERASEBKGND:

lResult = 1;

break;

case WM_PAINT:

lResult = onPaintEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_PRINTCLIENT:

lResult = onPrintClientEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_MOUSEACTIVATE:

setWasActivatedByMouseEvent(true);

handled = false;

break;

case WM_MOUSEMOVE:

case WM_LBUTTONDOWN:

case WM_MBUTTONDOWN:

case WM_RBUTTONDOWN:

case WM_LBUTTONDBLCLK:

case WM_MBUTTONDBLCLK:

case WM_RBUTTONDBLCLK:

case WM_LBUTTONUP:

case WM_MBUTTONUP:

case WM_RBUTTONUP:

case WM_MOUSELEAVE:

lResult = onMouseEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_MOUSEWHEEL:

lResult = onWheelEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_HSCROLL:

lResult = onHorizontalScroll(hWnd, message, wParam, lParam, handled);

break;

case WM_VSCROLL:

lResult = onVerticalScroll(hWnd, message, wParam, lParam, handled);

break;

case WM_SYSKEYDOWN:

case WM_KEYDOWN:

case WM_SYSCHAR:

case WM_CHAR:

case WM_SYSKEYUP:

case WM_KEYUP:

lResult = onKeyEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_SIZE:

lResult = onSizeEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_WINDOWPOSCHANGED:

lResult = onWindowPositionChangedEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_SETFOCUS:

lResult = onSetFocusEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_KILLFOCUS:

lResult = onKillFocusEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_TIMER:

lResult = onTimerEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_SHOWWINDOW:

lResult = onShowWindowEvent(hWnd, message, wParam, lParam, handled);

break;

case WM_SETCURSOR:

lResult = onSetCursor(hWnd, message, wParam, lParam, handled);

break;

case WM_MENUCOMMAND:

lResult = onMenuCommand(hWnd, message, wParam, lParam, handled);

break;

case WM_COMMAND:

SendMessage(GetParent(hWnd), message, wParam, lParam);

break;

default:

handled = false;

break;

}

if (!handled)

lResult = ::DefWindowProc(hWnd, message, wParam, lParam);

return lResult;

{

static bool haveRegisteredWindowClass = false;

if (haveRegisteredWindowClass)

return true;

haveRegisteredWindowClass = true;

WNDCLASSEX wcex;

wcex.cbSize = sizeof(WNDCLASSEX);

wcex.style = CS_DBLCLKS;

wcex.lpfnWndProc = WebView::WebViewWndProc;

wcex.cbClsExtra = 0;

wcex.cbWndExtra = sizeof(WebView*);

wcex.hInstance = instanceHandle();

wcex.hIcon = 0;

wcex.hCursor = ::LoadCursor(0, IDC_ARROW);

wcex.hbrBackground = 0;

wcex.lpszMenuName = 0;

wcex.lpszClassName = kWebKit2WebViewWindowClassName;

wcex.hIconSm = 0;

return !!::RegisterClassEx(&wcex);

: m_pageClient(makeUniqueWithoutRefCountedCheck<PageClientImpl>(*this))

{

registerWebViewWindowClass();

m_window = ::CreateWindowExW(0, kWebKit2WebViewWindowClassName, 0, WS_CHILD | WS_CLIPSIBLINGS | WS_CLIPCHILDREN | WS_VISIBLE,

rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, parentWindow ? parentWindow : HWND_MESSAGE, 0, instanceHandle(), this);

ASSERT(::IsWindow(m_window));

// We only check our window style, and not ::IsWindowVisible, because m_isVisible only tracks

// this window's visibility status, while ::IsWindowVisible takes our ancestors' visibility

// status into account. <http://webkit.org/b/54104>

ASSERT(m_isVisible == static_cast<bool>(::GetWindowLong(m_window, GWL_STYLE) & WS_VISIBLE));

auto pageConfiguration = configuration.copy();

WebProcessPool& processPool = pageConfiguration->processPool();

m_page = processPool.createWebPage(*m_pageClient, WTFMove(pageConfiguration));

m_page->initializeWebPage();

IntSize windowSize(rect.right - rect.left, rect.bottom - rect.top);

if (m_page->drawingArea())

m_page->drawingArea()->setSize(windowSize);

#if ENABLE(REMOTE_INSPECTOR)

m_page->setURLSchemeHandlerForScheme(RemoteInspectorProtocolHandler::create(*m_page), "inspector"_s);

#endif

// FIXME: Initializing the tooltip window here matches WebKit win, but seems like something

// we could do on demand to save resources.

initializeToolTipWindow();

// Initialize the top level parent window and register it with the WindowMessageBroadcaster.

windowAncestryDidChange();

{

if (shouldInitializeTrackPointHack()) {

// If we detected a registry key belonging to a TrackPoint driver, then create fake

// scrollbars, so the WebView will receive WM_VSCROLL and WM_HSCROLL messages.

// We create an invisible vertical scrollbar and an invisible horizontal scrollbar to allow

// for receiving both types of messages.

::CreateWindow(TEXT("SCROLLBAR"), TEXT("FAKETRACKPOINTHSCROLLBAR"), WS_CHILD | WS_VISIBLE | SBS_HORZ, 0, 0, 0, 0, m_window, 0, instanceHandle(), 0);

::CreateWindow(TEXT("SCROLLBAR"), TEXT("FAKETRACKPOINTVSCROLLBAR"), WS_CHILD | WS_VISIBLE | SBS_VERT, 0, 0, 0, 0, m_window, 0, instanceHandle(), 0);

}

{

if (m_window) {

// If the host window hasn't changed, bail.

if (::GetParent(m_window) == parentWindow)

return;

if (parentWindow)

::SetParent(m_window, parentWindow);

else if (!m_isBeingDestroyed) {

// Turn the WebView into a message-only window so it will no longer be a child of the

// old parent window and will be hidden from screen. We only do this when

// isBeingDestroyed() is false because doing this while handling WM_DESTROY can leave

// m_window in a weird state (see <http://webkit.org/b/29337>).

::SetParent(m_window, HWND_MESSAGE);

}

}

windowAncestryDidChange();

{

if (!window)

return 0;

HWND current = window;

for (HWND parent = GetParent(current); current; current = parent, parent = GetParent(parent)) {

if (!parent || !(GetWindowLongPtr(current, GWL_STYLE) & (WS_POPUP | WS_CHILD)))

return current;

}

ASSERT_NOT_REACHED();

return 0;

{

HWND newTopLevelParentWindow;

if (m_window)

newTopLevelParentWindow = findTopLevelParentWindow(m_window);

else {

// There's no point in tracking active state changes of our parent window if we don't have

// a window ourselves.

newTopLevelParentWindow = 0;

}

if (newTopLevelParentWindow == m_topLevelParentWindow)

return;

if (m_topLevelParentWindow)

WindowMessageBroadcaster::removeListener(m_topLevelParentWindow, this);

m_topLevelParentWindow = newTopLevelParentWindow;

if (m_topLevelParentWindow)

WindowMessageBroadcaster::addListener(m_topLevelParentWindow, this);

updateActiveState();

{

NativeWebMouseEvent mouseEvent = NativeWebMouseEvent(hWnd, message, wParam, lParam, m_wasActivatedByMouseEvent);

setWasActivatedByMouseEvent(false);

switch (message) {

case WM_LBUTTONDOWN:

case WM_MBUTTONDOWN:

case WM_RBUTTONDOWN:

::SetFocus(m_window);

::SetCapture(m_window);

break;

case WM_LBUTTONUP:

case WM_MBUTTONUP:

case WM_RBUTTONUP:

::ReleaseCapture();

break;

case WM_MOUSEMOVE:

startTrackingMouseLeave();

break;

case WM_MOUSELEAVE:

stopTrackingMouseLeave();

break;

case WM_LBUTTONDBLCLK:

case WM_MBUTTONDBLCLK:

case WM_RBUTTONDBLCLK:

break;

default:

ASSERT_NOT_REACHED();

}

m_page->handleMouseEvent(mouseEvent);

handled = true;

return 0;

{

NativeWebWheelEvent wheelEvent(hWnd, message, wParam, lParam);

if (wheelEvent.controlKey()) {

// We do not want WebKit to handle Control + Wheel, this should be handled by the client application

// to zoom the page.

handled = false;

return 0;

}

m_page->handleNativeWheelEvent(wheelEvent);

handled = true;

return 0;

{

ScrollDirection direction;

ScrollGranularity granularity;

switch (LOWORD(wParam)) {

case SB_LINELEFT:

granularity = ScrollGranularity::Line;

direction = ScrollDirection::ScrollLeft;

break;

case SB_LINERIGHT:

granularity = ScrollGranularity::Line;

direction = ScrollDirection::ScrollRight;

break;

case SB_PAGELEFT:

granularity = ScrollGranularity::Document;

direction = ScrollDirection::ScrollLeft;

break;

case SB_PAGERIGHT:

granularity = ScrollGranularity::Document;

direction = ScrollDirection::ScrollRight;

break;

default:

handled = false;

return 0;

}

m_page->scrollBy(direction, granularity);

handled = true;

return 0;

{

ScrollDirection direction;

ScrollGranularity granularity;

switch (LOWORD(wParam)) {

case SB_LINEDOWN:

granularity = ScrollGranularity::Line;

direction = ScrollDirection::ScrollDown;

break;

case SB_LINEUP:

granularity = ScrollGranularity::Line;

direction = ScrollDirection::ScrollUp;

break;

case SB_PAGEDOWN:

granularity = ScrollGranularity::Document;

direction = ScrollDirection::ScrollDown;

break;

case SB_PAGEUP:

granularity = ScrollGranularity::Document;

direction = ScrollDirection::ScrollUp;

break;

default:

handled = false;

return 0;

}

m_page->scrollBy(direction, granularity);

handled = true;

return 0;

{

Vector<MSG> pendingCharEvents;

if (message == WM_KEYDOWN) {

MSG msg;

// WM_SYSCHAR events should not be removed, because WebKit is using WM_SYSCHAR for access keys and they can't be canceled.

while (PeekMessage(&msg, hWnd, WM_CHAR, WM_DEADCHAR, PM_REMOVE)) {

if (msg.message == WM_CHAR)

pendingCharEvents.append(msg);

}

}

m_page->handleKeyboardEvent(NativeWebKeyboardEvent(hWnd, message, wParam, lParam, WTFMove(pendingCharEvents)));

// We claim here to always have handled the event. If the event is not in fact handled, we will

// find out later in didNotHandleKeyEvent.

handled = true;

return 0;

{

auto& backgroundColor = page->backgroundColor();

if (!backgroundColor || backgroundColor.value().isVisible())

return;

::FillRect(dc, &rect, reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1));

{

if (dirtyRect.isEmpty())

return;

m_page->endPrinting();

if (m_page->drawingArea()) {

auto painter = [&](auto drawingArea) {

// FIXME: We should port WebKit1's rect coalescing logic here.

Region unpaintedRegion;

#if USE(CAIRO)

cairo_surface_t* surface = cairo_win32_surface_create(hdc);

cairo_t* context = cairo_create(surface);

drawingArea->paint(context, dirtyRect, unpaintedRegion);

cairo_destroy(context);

cairo_surface_destroy(surface);

#endif

auto unpaintedRects = unpaintedRegion.rects();

for (auto& rect : unpaintedRects)

drawPageBackground(hdc, m_page.get(), rect);

};

switch (m_page->drawingArea()->type()) {

#if USE(GRAPHICS_LAYER_WC)

case DrawingAreaType::WC:

painter(static_cast<DrawingAreaProxyWC*>(m_page->drawingArea()));

break;

#endif

case DrawingAreaType::CoordinatedGraphics:

painter(static_cast<DrawingAreaProxyCoordinatedGraphics*>(m_page->drawingArea()));

break;

default:

ASSERT_NOT_REACHED();

}

} else

drawPageBackground(hdc, m_page.get(), dirtyRect);

{

// Update child windows now so that any areas of our window they reveal will be included in the

// invalid region that ::BeginPaint sees.

PAINTSTRUCT paintStruct;

HDC hdc = ::BeginPaint(m_window, &paintStruct);

paint(hdc, paintStruct.rcPaint);

::EndPaint(m_window, &paintStruct);

handled = true;

return 0;

{

HDC hdc = reinterpret_cast<HDC>(wParam);

RECT winRect;

::GetClientRect(hWnd, &winRect);

paint(hdc, winRect);

handled = true;

return 0;

{

int width = LOWORD(lParam);

int height = HIWORD(lParam);

IntSize windowSize(width, height);

if (m_page && m_page->drawingArea()) {

// FIXME specify correctly layerPosition.

m_page->drawingArea()->setSize(windowSize, m_nextResizeScrollOffset);

m_nextResizeScrollOffset = IntSize();

}

handled = true;

return 0;

{

if (reinterpret_cast<WINDOWPOS*>(lParam)->flags & SWP_SHOWWINDOW)

updateActiveStateSoon();

handled = false;

return 0;

{

m_page->activityStateDidChange(ActivityState::IsFocused);

handled = true;

return 0;

{

m_page->activityStateDidChange(ActivityState::IsFocused);

handled = true;

return 0;

{

switch (wParam) {

case UpdateActiveStateTimer:

::KillTimer(hWnd, UpdateActiveStateTimer);

updateActiveState();

break;

}

handled = true;

return 0;

{

// lParam is 0 when the message is sent because of a ShowWindow call.

// FIXME: Since we don't get notified when an ancestor window is hidden or shown, we will keep

// painting even when we have a hidden ancestor. <http://webkit.org/b/54104>

if (!lParam)

setIsVisible(wParam);

handled = false;

return 0;

{

if (!m_lastCursorSet) {

handled = false;

return 0;

}

::SetCursor(m_lastCursorSet);

return 0;

{

#if ENABLE(CONTEXT_MENUS)

auto hMenu = reinterpret_cast<HMENU>(lParam);

auto index = static_cast<unsigned>(wParam);

MENUITEMINFO menuItemInfo;

menuItemInfo.cbSize = sizeof(menuItemInfo);

menuItemInfo.cch = 0;

menuItemInfo.fMask = MIIM_STRING;

::GetMenuItemInfo(hMenu, index, TRUE, &menuItemInfo);

menuItemInfo.cch++;

Vector<WCHAR> buffer(menuItemInfo.cch);

menuItemInfo.dwTypeData = buffer.data();

menuItemInfo.fMask |= MIIM_ID;

::GetMenuItemInfo(hMenu, index, TRUE, &menuItemInfo);

String title(buffer.data(), menuItemInfo.cch);

ContextMenuAction action = static_cast<ContextMenuAction>(menuItemInfo.wID);

bool enabled = !(menuItemInfo.fState & MFS_DISABLED);

bool checked = menuItemInfo.fState & MFS_CHECKED;

WebContextMenuItemData item(ContextMenuItemType::Action, action, WTFMove(title), enabled, checked);

m_page->contextMenuItemSelected(item);

handled = true;

#else

UNUSED_PARAM(hWnd);

UNUSED_PARAM(message);

UNUSED_PARAM(wParam);

UNUSED_PARAM(lParam);

handled = false;

#endif

return 0;

{

// This function is called while processing the WM_NCACTIVATE message.

// While processing WM_NCACTIVATE when we are being deactivated, GetActiveWindow() will

// still return our window. If we were to call updateActiveState() in that case, we would

// wrongly think that we are still the active window. To work around this, we update our

// active state after a 0-delay timer fires, at which point GetActiveWindow() will return

// the newly-activated window.

::SetTimer(m_window, UpdateActiveStateTimer, 0, 0);

{

static bool haveInitialized = false;

if (haveInitialized)

return true;

INITCOMMONCONTROLSEX init;

init.dwSize = sizeof(init);

init.dwICC = ICC_TREEVIEW_CLASSES;

haveInitialized = !!::InitCommonControlsEx(&init);

return haveInitialized;

{

if (!initCommonControls())

return;

m_toolTipWindow = ::CreateWindowEx(WS_EX_TRANSPARENT, TOOLTIPS_CLASS, 0, WS_POPUP | TTS_NOPREFIX | TTS_ALWAYSTIP,

CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT, CW_USEDEFAULT,

m_window, 0, 0, 0);

if (!m_toolTipWindow)

return;

TOOLINFO info { };

info.cbSize = sizeof(info);

info.uFlags = TTF_IDISHWND | TTF_SUBCLASS;

info.uId = reinterpret_cast<UINT_PTR>(m_window);

::SendMessage(m_toolTipWindow, TTM_ADDTOOL, 0, reinterpret_cast<LPARAM>(&info));

::SendMessage(m_toolTipWindow, TTM_SETMAXTIPWIDTH, 0, kMaxToolTipWidth);

::SetWindowPos(m_toolTipWindow, HWND_TOP, 0, 0, 0, 0, SWP_NOMOVE | SWP_NOSIZE | SWP_NOACTIVATE);

{

if (m_trackingMouseLeave)

return;

m_trackingMouseLeave = true;

TRACKMOUSEEVENT trackMouseEvent;

trackMouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);

trackMouseEvent.dwFlags = TME_LEAVE;

trackMouseEvent.hwndTrack = m_window;

::TrackMouseEvent(&trackMouseEvent);

{

if (!m_trackingMouseLeave)

return;

m_trackingMouseLeave = false;

TRACKMOUSEEVENT trackMouseEvent;

trackMouseEvent.cbSize = sizeof(TRACKMOUSEEVENT);

trackMouseEvent.dwFlags = TME_LEAVE | TME_CANCEL;

trackMouseEvent.hwndTrack = m_window;

::TrackMouseEvent(&trackMouseEvent);

{

static bool shouldCreateScrollbars;

static bool hasRunTrackPointCheck;

if (hasRunTrackPointCheck)

return shouldCreateScrollbars;

hasRunTrackPointCheck = true;

const wchar_t* trackPointKeys[] = {

L"Software\\Lenovo\\TrackPoint",

L"Software\\Lenovo\\UltraNav",

L"Software\\Alps\\Apoint\\TrackPoint",

L"Software\\Synaptics\\SynTPEnh\\UltraNavUSB",

L"Software\\Synaptics\\SynTPEnh\\UltraNavPS2"

};

for (size_t i = 0; i < std::size(trackPointKeys); ++i) {

HKEY trackPointKey;

int readKeyResult = ::RegOpenKeyExW(HKEY_CURRENT_USER, trackPointKeys[i], 0, KEY_READ, &trackPointKey);

::RegCloseKey(trackPointKey);

if (readKeyResult == ERROR_SUCCESS) {

shouldCreateScrollbars = true;

return shouldCreateScrollbars;

}

}

return shouldCreateScrollbars;

{

if (m_window) {

// We can't check IsWindow(m_window) here, because that will return true even while

// we're already handling WM_DESTROY. So we check !m_isBeingDestroyed instead.

if (!m_isBeingDestroyed)

DestroyWindow(m_window);

// Either we just destroyed m_window, or it's in the process of being destroyed. Either

// way, we clear it out to make sure we don't try to use it later.

m_window = 0;

}

setParentWindow(0);

m_page->close();

{

if (!m_page->hasRunningProcess())

return 0;

// We only show the override cursor if the default (arrow) cursor is showing.

static HCURSOR arrowCursor = ::LoadCursor(0, IDC_ARROW);

if (m_overrideCursor && m_webCoreCursor == arrowCursor)

return m_overrideCursor;

return m_webCoreCursor;

{

if (!cursor.platformCursor()->nativeCursor())

return;

m_webCoreCursor = cursor.platformCursor()->nativeCursor();

updateNativeCursor();

{

m_lastCursorSet = cursorToShow();

if (!m_lastCursorSet)

return;

::SetCursor(m_lastCursorSet);

{

m_overrideCursor = overrideCursor;

updateNativeCursor();

{

m_isInWindow = isInWindow;

if (m_page)

m_page->activityStateDidChange(ActivityState::IsInWindow);

{

m_isVisible = isVisible;

if (m_page)

m_page->activityStateDidChange(ActivityState::IsVisible);

{

HWND activeWindow = ::GetActiveWindow();

return (activeWindow && m_topLevelParentWindow == findTopLevelParentWindow(activeWindow));

{

// The next time we get a WM_SIZE message, scroll by the specified amount in onSizeEvent().

m_nextResizeScrollOffset = scrollOffset;

{

const RECT r = region.bounds();

::InvalidateRect(m_window, &r, true);

{

switch (message) {

case WM_NCACTIVATE:

updateActiveStateSoon();

break;

case WM_SETTINGCHANGE:

break;

}

{

// Truncate tooltip texts because multiline mode of tooltip control does word-wrapping very slowly

auto maxLength = 1024;

auto buffer = string.wideCharacters();

if (buffer.size() > maxLength) {

buffer[maxLength - 4] = L'.';

buffer[maxLength - 3] = L'.';

buffer[maxLength - 2] = L'.';

buffer[maxLength - 1] = L'\0';

}

return buffer;

{

if (!m_toolTipWindow)

return;

if (!toolTip.isEmpty()) {

TOOLINFO info { };

info.cbSize = sizeof(info);

info.uFlags = TTF_IDISHWND;

info.uId = reinterpret_cast<UINT_PTR>(nativeWindow());

auto toolTipCharacters = truncatedString(toolTip); // Retain buffer long enough to make the SendMessage call

info.lpszText = toolTipCharacters.data();

::SendMessage(m_toolTipWindow, TTM_UPDATETIPTEXT, 0, reinterpret_cast<LPARAM>(&info));

}

::SendMessage(m_toolTipWindow, TTM_ACTIVATE, !toolTip.isEmpty(), 0);