// Copyright (c) 2012 The Chromium Embedded Framework Authors. // Portions copyright (c) 2011 The Chromium Authors. All rights reserved. // Use of this source code is governed by a BSD-style license that can be // found in the LICENSE file. #include "libcef/browser/browser_host_impl.h" #include #include #include #include #include #include "libcef/browser/thread_util.h" #include "base/i18n/case_conversion.h" #include "base/strings/string_util.h" #include "base/strings/utf_string_conversions.h" #include "base/win/registry.h" #include "base/win/windows_version.h" #include "content/public/browser/native_web_keyboard_event.h" #include "content/public/browser/web_contents_view.h" #include "content/public/common/file_chooser_params.h" #include "grit/cef_strings.h" #include "grit/ui_strings.h" #include "net/base/mime_util.h" #include "third_party/WebKit/public/web/WebInputEvent.h" #include "third_party/WebKit/public/web/win/WebInputEventFactory.h" #include "ui/base/l10n/l10n_util.h" #include "ui/base/win/hwnd_util.h" #pragma comment(lib, "dwmapi.lib") namespace { bool IsAeroGlassEnabled() { if (base::win::GetVersion() < base::win::VERSION_VISTA) return false; BOOL enabled = FALSE; return SUCCEEDED(DwmIsCompositionEnabled(&enabled)) && enabled; } void SetAeroGlass(HWND hWnd) { if (!IsAeroGlassEnabled()) return; // Make the whole window transparent. MARGINS mgMarInset = { -1, -1, -1, -1 }; DwmExtendFrameIntoClientArea(hWnd, &mgMarInset); } void WriteTextToFile(const std::string& data, const std::wstring& file_path) { FILE* fp; errno_t err = _wfopen_s(&fp, file_path.c_str(), L"wt"); if (err) return; fwrite(data.c_str(), 1, data.size(), fp); fclose(fp); } // From ui/base/dialogs/select_file_dialog_win.cc. // Get the file type description from the registry. This will be "Text Document" // for .txt files, "JPEG Image" for .jpg files, etc. If the registry doesn't // have an entry for the file type, we return false, true if the description was // found. 'file_ext' must be in form ".txt". static bool GetRegistryDescriptionFromExtension(const std::wstring& file_ext, std::wstring* reg_description) { DCHECK(reg_description); base::win::RegKey reg_ext(HKEY_CLASSES_ROOT, file_ext.c_str(), KEY_READ); std::wstring reg_app; if (reg_ext.ReadValue(NULL, ®_app) == ERROR_SUCCESS && !reg_app.empty()) { base::win::RegKey reg_link(HKEY_CLASSES_ROOT, reg_app.c_str(), KEY_READ); if (reg_link.ReadValue(NULL, reg_description) == ERROR_SUCCESS) return true; } return false; } // Set up a filter for a Save/Open dialog, which will consist of |file_ext| file // extensions (internally separated by semicolons), |ext_desc| as the text // descriptions of the |file_ext| types (optional), and (optionally) the default // 'All Files' view. The purpose of the filter is to show only files of a // particular type in a Windows Save/Open dialog box. The resulting filter is // returned. The filters created here are: // 1. only files that have 'file_ext' as their extension // 2. all files (only added if 'include_all_files' is true) // Example: // file_ext: { "*.txt", "*.htm;*.html" } // ext_desc: { "Text Document" } // returned: "Text Document\0*.txt\0HTML Document\0*.htm;*.html\0" // "All Files\0*.*\0\0" (in one big string) // If a description is not provided for a file extension, it will be retrieved // from the registry. If the file extension does not exist in the registry, it // will be omitted from the filter, as it is likely a bogus extension. std::wstring FormatFilterForExtensions( const std::vector& file_ext, const std::vector& ext_desc, bool include_all_files) { const std::wstring all_ext = L"*.*"; const std::wstring all_desc = l10n_util::GetStringUTF16(IDS_APP_SAVEAS_ALL_FILES) + L" (" + all_ext + L")"; DCHECK(file_ext.size() >= ext_desc.size()); if (file_ext.empty()) include_all_files = true; std::wstring result; for (size_t i = 0; i < file_ext.size(); ++i) { std::wstring ext = file_ext[i]; std::wstring desc; if (i < ext_desc.size()) desc = ext_desc[i]; if (ext.empty()) { // Force something reasonable to appear in the dialog box if there is no // extension provided. include_all_files = true; continue; } if (desc.empty()) { DCHECK(ext.find(L'.') != std::wstring::npos); std::wstring first_extension = ext.substr(ext.find(L'.')); size_t first_separator_index = first_extension.find(L';'); if (first_separator_index != std::wstring::npos) first_extension = first_extension.substr(0, first_separator_index); // Find the extension name without the preceeding '.' character. std::wstring ext_name = first_extension; size_t ext_index = ext_name.find_first_not_of(L'.'); if (ext_index != std::wstring::npos) ext_name = ext_name.substr(ext_index); if (!GetRegistryDescriptionFromExtension(first_extension, &desc)) { // The extension doesn't exist in the registry. Create a description // based on the unknown extension type (i.e. if the extension is .qqq, // the we create a description "QQQ File (.qqq)"). include_all_files = true; desc = l10n_util::GetStringFUTF16( IDS_APP_SAVEAS_EXTENSION_FORMAT, base::i18n::ToUpper(WideToUTF16(ext_name)), ext_name); } } if (!desc.empty()) desc += L" (" + ext + L")"; else desc = ext; result.append(desc.c_str(), desc.size() + 1); // Append NULL too. result.append(ext.c_str(), ext.size() + 1); } if (include_all_files) { result.append(all_desc.c_str(), all_desc.size() + 1); result.append(all_ext.c_str(), all_ext.size() + 1); } result.append(1, '\0'); // Double NULL required. return result; } std::wstring GetDescriptionFromMimeType(const std::string& mime_type) { // Check for wild card mime types and return an appropriate description. static const struct { const char* mime_type; int string_id; } kWildCardMimeTypes[] = { { "audio", IDS_APP_AUDIO_FILES }, { "image", IDS_APP_IMAGE_FILES }, { "text", IDS_APP_TEXT_FILES }, { "video", IDS_APP_VIDEO_FILES }, }; for (size_t i = 0; i < arraysize(kWildCardMimeTypes); ++i) { if (mime_type == std::string(kWildCardMimeTypes[i].mime_type) + "/*") return l10n_util::GetStringUTF16(kWildCardMimeTypes[i].string_id); } return std::wstring(); } std::wstring GetFilterStringFromAcceptTypes( const std::vector& accept_types) { std::vector extensions; std::vector descriptions; for (size_t i = 0; i < accept_types.size(); ++i) { std::string ascii_type = UTF16ToASCII(accept_types[i]); if (ascii_type.length()) { // Just treat as extension if contains '.' as the first character. if (ascii_type[0] == '.') { extensions.push_back(L"*" + ASCIIToWide(ascii_type)); descriptions.push_back(std::wstring()); } else { // Otherwise convert mime type to one or more extensions. std::vector ext; std::wstring ext_str; net::GetExtensionsForMimeType(ascii_type, &ext); if (ext.size() > 0) { for (size_t x = 0; x < ext.size(); ++x) { if (x != 0) ext_str += L";"; ext_str += L"*." + ext[x]; } extensions.push_back(ext_str); descriptions.push_back(GetDescriptionFromMimeType(ascii_type)); } } } } return FormatFilterForExtensions(extensions, descriptions, true); } // from chrome/browser/views/shell_dialogs_win.cc bool RunOpenFileDialog(const content::FileChooserParams& params, HWND owner, base::FilePath* path) { OPENFILENAME ofn; // We must do this otherwise the ofn's FlagsEx may be initialized to random // junk in release builds which can cause the Places Bar not to show up! ZeroMemory(&ofn, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = owner; // Consider default file name if any. base::FilePath default_file_name(params.default_file_name); wchar_t filename[MAX_PATH] = {0}; ofn.lpstrFile = filename; ofn.nMaxFile = MAX_PATH; std::wstring directory; if (!default_file_name.empty()) { base::wcslcpy(filename, default_file_name.value().c_str(), arraysize(filename)); directory = default_file_name.DirName().value(); ofn.lpstrInitialDir = directory.c_str(); } std::wstring title; if (!params.title.empty()) title = params.title; else title = l10n_util::GetStringUTF16(IDS_OPEN_FILE_DIALOG_TITLE); if (!title.empty()) ofn.lpstrTitle = title.c_str(); // We use OFN_NOCHANGEDIR so that the user can rename or delete the directory // without having to close Chrome first. ofn.Flags = OFN_FILEMUSTEXIST | OFN_NOCHANGEDIR | OFN_EXPLORER | OFN_ENABLESIZING; std::wstring filter = GetFilterStringFromAcceptTypes(params.accept_types); if (!filter.empty()) ofn.lpstrFilter = filter.c_str(); bool success = !!GetOpenFileName(&ofn); if (success) *path = base::FilePath(filename); return success; } bool RunOpenMultiFileDialog(const content::FileChooserParams& params, HWND owner, std::vector* paths) { OPENFILENAME ofn; // We must do this otherwise the ofn's FlagsEx may be initialized to random // junk in release builds which can cause the Places Bar not to show up! ZeroMemory(&ofn, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = owner; scoped_ptr filename(new wchar_t[UNICODE_STRING_MAX_CHARS]); filename[0] = 0; ofn.lpstrFile = filename.get(); ofn.nMaxFile = UNICODE_STRING_MAX_CHARS; std::wstring title; if (!params.title.empty()) title = params.title; else title = l10n_util::GetStringUTF16(IDS_OPEN_FILES_DIALOG_TITLE); if (!title.empty()) ofn.lpstrTitle = title.c_str(); // We use OFN_NOCHANGEDIR so that the user can rename or delete the directory // without having to close Chrome first. ofn.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST | OFN_EXPLORER | OFN_HIDEREADONLY | OFN_ALLOWMULTISELECT | OFN_ENABLESIZING; std::wstring filter = GetFilterStringFromAcceptTypes(params.accept_types); if (!filter.empty()) ofn.lpstrFilter = filter.c_str(); bool success = !!GetOpenFileName(&ofn); if (success) { std::vector files; const wchar_t* selection = ofn.lpstrFile; while (*selection) { // Empty string indicates end of list. files.push_back(base::FilePath(selection)); // Skip over filename and null-terminator. selection += files.back().value().length() + 1; } if (files.empty()) { success = false; } else if (files.size() == 1) { // When there is one file, it contains the path and filename. paths->swap(files); } else { // Otherwise, the first string is the path, and the remainder are // filenames. std::vector::iterator path = files.begin(); for (std::vector::iterator file = path + 1; file != files.end(); ++file) { paths->push_back(path->Append(*file)); } } } return success; } bool RunSaveFileDialog(const content::FileChooserParams& params, HWND owner, base::FilePath* path) { OPENFILENAME ofn; // We must do this otherwise the ofn's FlagsEx may be initialized to random // junk in release builds which can cause the Places Bar not to show up! ZeroMemory(&ofn, sizeof(ofn)); ofn.lStructSize = sizeof(ofn); ofn.hwndOwner = owner; // Consider default file name if any. base::FilePath default_file_name(params.default_file_name); wchar_t filename[MAX_PATH] = {0}; ofn.lpstrFile = filename; ofn.nMaxFile = MAX_PATH; std::wstring directory; if (!default_file_name.empty()) { base::wcslcpy(filename, default_file_name.value().c_str(), arraysize(filename)); directory = default_file_name.DirName().value(); ofn.lpstrInitialDir = directory.c_str(); } std::wstring title; if (!params.title.empty()) title = params.title; else title = l10n_util::GetStringUTF16(IDS_SAVE_AS_DIALOG_TITLE); if (!title.empty()) ofn.lpstrTitle = title.c_str(); // We use OFN_NOCHANGEDIR so that the user can rename or delete the directory // without having to close Chrome first. ofn.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLESIZING | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST; std::wstring filter = GetFilterStringFromAcceptTypes(params.accept_types); if (!filter.empty()) ofn.lpstrFilter = filter.c_str(); bool success = !!GetSaveFileName(&ofn); if (success) *path = base::FilePath(filename); return success; } // According to Mozilla in uriloader/exthandler/win/nsOSHelperAppService.cpp: // "Some versions of windows (Win2k before SP3, Win XP before SP1) crash in // ShellExecute on long URLs (bug 161357 on bugzilla.mozilla.org). IE 5 and 6 // support URLS of 2083 chars in length, 2K is safe." const int kMaxAddressLengthChars = 2048; bool HasExternalHandler(const std::string& scheme) { base::win::RegKey key; const std::wstring registry_path = ASCIIToWide(scheme + "\\shell\\open\\command"); key.Open(HKEY_CLASSES_ROOT, registry_path.c_str(), KEY_READ); if (key.Valid()) { DWORD size = 0; key.ReadValue(NULL, NULL, &size, NULL); if (size > 2) { // ShellExecute crashes the process when the command is empty. // We check for "2" because it always returns the trailing NULL. return true; } } return false; } WORD KeyStatesToWord() { static const USHORT kHighBitMaskShort = 0x8000; WORD result = 0; if (GetKeyState(VK_CONTROL) & kHighBitMaskShort) result |= MK_CONTROL; if (GetKeyState(VK_SHIFT) & kHighBitMaskShort) result |= MK_SHIFT; if (GetKeyState(VK_LBUTTON) & kHighBitMaskShort) result |= MK_LBUTTON; if (GetKeyState(VK_MBUTTON) & kHighBitMaskShort) result |= MK_MBUTTON; if (GetKeyState(VK_RBUTTON) & kHighBitMaskShort) result |= MK_RBUTTON; return result; } } // namespace // static void CefBrowserHostImpl::RegisterWindowClass() { // Register the window class WNDCLASSEX wcex = { /* cbSize = */ sizeof(WNDCLASSEX), /* style = */ CS_HREDRAW | CS_VREDRAW, /* lpfnWndProc = */ CefBrowserHostImpl::WndProc, /* cbClsExtra = */ 0, /* cbWndExtra = */ 0, /* hInstance = */ ::GetModuleHandle(NULL), /* hIcon = */ NULL, /* hCursor = */ LoadCursor(NULL, IDC_ARROW), /* hbrBackground = */ 0, /* lpszMenuName = */ NULL, /* lpszClassName = */ CefBrowserHostImpl::GetWndClass(), /* hIconSm = */ NULL, }; RegisterClassEx(&wcex); } // static LPCTSTR CefBrowserHostImpl::GetWndClass() { return L"CefBrowserWindow"; } // static LRESULT CALLBACK CefBrowserHostImpl::WndProc(HWND hwnd, UINT message, WPARAM wParam, LPARAM lParam) { CefBrowserHostImpl* browser = static_cast(ui::GetWindowUserData(hwnd)); switch (message) { case WM_CLOSE: // Protect against multiple requests to close while the close is pending. if (browser && browser->destruction_state() <= DESTRUCTION_STATE_PENDING) { if (browser->destruction_state() == DESTRUCTION_STATE_NONE) { // Request that the browser close. browser->CloseBrowser(false); } // Cancel the close. return 0; } // Allow the close. break; case WM_DESTROY: if (browser) { // Clear the user data pointer. ui::SetWindowUserData(hwnd, NULL); // Force the browser to be destroyed and release the reference added in // PlatformCreateWindow(). browser->WindowDestroyed(); } return 0; case WM_SIZE: // Minimizing resizes the window to 0x0 which causes our layout to go all // screwy, so we just ignore it. if (wParam != SIZE_MINIMIZED && browser) { // resize the web view window to the full size of the browser window RECT rc; GetClientRect(hwnd, &rc); MoveWindow(browser->GetContentView(), 0, 0, rc.right, rc.bottom, TRUE); } return 0; case WM_SETFOCUS: if (browser) browser->OnSetFocus(FOCUS_SOURCE_SYSTEM); return 0; case WM_ERASEBKGND: return 1; case WM_DWMCOMPOSITIONCHANGED: // Message sent to top-level windows when composition has been enabled or // disabled. if (browser && browser->window_info_.transparent_painting) SetAeroGlass(hwnd); break; } return DefWindowProc(hwnd, message, wParam, lParam); } bool CefBrowserHostImpl::PlatformCreateWindow() { std::wstring windowName(CefString(&window_info_.window_name)); // Create the new browser window. window_info_.window = CreateWindowEx(window_info_.ex_style, GetWndClass(), windowName.c_str(), window_info_.style, window_info_.x, window_info_.y, window_info_.width, window_info_.height, window_info_.parent_window, window_info_.menu, ::GetModuleHandle(NULL), NULL); // It's possible for CreateWindowEx to fail if the parent window was // destroyed between the call to CreateBrowser and the above one. DCHECK(window_info_.window != NULL); if (!window_info_.window) return false; if (window_info_.transparent_painting && !(window_info_.style & WS_CHILD)) { // Transparent top-level windows will be given "sheet of glass" effect. SetAeroGlass(window_info_.window); } // Set window user data to this object for future reference from the window // procedure. ui::SetWindowUserData(window_info_.window, this); // Add a reference that will be released in the WM_DESTROY handler. AddRef(); // Parent the TabContents to the browser window. SetParent(web_contents_->GetView()->GetNativeView(), window_info_.window); // Size the web view window to the browser window. RECT cr; GetClientRect(window_info_.window, &cr); // Respect the WS_VISIBLE window style when setting the window's position. UINT flags = SWP_NOZORDER | SWP_SHOWWINDOW; if (!(window_info_.style & WS_VISIBLE)) flags |= SWP_NOACTIVATE; SetWindowPos(GetContentView(), NULL, cr.left, cr.top, cr.right, cr.bottom, flags); return true; } void CefBrowserHostImpl::PlatformCloseWindow() { if (window_info_.window != NULL) { HWND frameWnd = GetAncestor(window_info_.window, GA_ROOT); PostMessage(frameWnd, WM_CLOSE, 0, 0); } } void CefBrowserHostImpl::PlatformSizeTo(int width, int height) { RECT rect = {0, 0, width, height}; DWORD style = GetWindowLong(window_info_.window, GWL_STYLE); DWORD ex_style = GetWindowLong(window_info_.window, GWL_EXSTYLE); bool has_menu = !(style & WS_CHILD) && (GetMenu(window_info_.window) != NULL); // The size value is for the client area. Calculate the whole window size // based on the current style. AdjustWindowRectEx(&rect, style, has_menu, ex_style); // Size the window. SetWindowPos(window_info_.window, NULL, 0, 0, rect.right, rect.bottom, SWP_NOZORDER | SWP_NOMOVE | SWP_NOACTIVATE); } CefWindowHandle CefBrowserHostImpl::PlatformGetWindowHandle() { return IsWindowRenderingDisabled() ? window_info_.parent_window : window_info_.window; } bool CefBrowserHostImpl::PlatformViewText(const std::string& text) { CEF_REQUIRE_UIT(); DWORD dwRetVal; DWORD dwBufSize = 512; TCHAR lpPathBuffer[512]; UINT uRetVal; TCHAR szTempName[512]; dwRetVal = GetTempPath(dwBufSize, // length of the buffer lpPathBuffer); // buffer for path if (dwRetVal > dwBufSize || (dwRetVal == 0)) return false; // Create a temporary file. uRetVal = GetTempFileName(lpPathBuffer, // directory for tmp files TEXT("src"), // temp file name prefix 0, // create unique name szTempName); // buffer for name if (uRetVal == 0) return false; size_t len = wcslen(szTempName); wcscpy(szTempName + len - 3, L"txt"); WriteTextToFile(text, szTempName); HWND frameWnd = GetAncestor(PlatformGetWindowHandle(), GA_ROOT); int errorCode = reinterpret_cast(ShellExecute(frameWnd, L"open", szTempName, NULL, NULL, SW_SHOWNORMAL)); if (errorCode <= 32) return false; return true; } void CefBrowserHostImpl::PlatformHandleKeyboardEvent( const content::NativeWebKeyboardEvent& event) { // Any unhandled keyboard/character messages are sent to DefWindowProc so that // shortcut keys work correctly. DefWindowProc(event.os_event.hwnd, event.os_event.message, event.os_event.wParam, event.os_event.lParam); } void CefBrowserHostImpl::PlatformRunFileChooser( const content::FileChooserParams& params, RunFileChooserCallback callback) { std::vector files; if (params.mode == content::FileChooserParams::Open) { base::FilePath file; if (RunOpenFileDialog(params, PlatformGetWindowHandle(), &file)) files.push_back(file); } else if (params.mode == content::FileChooserParams::OpenMultiple) { RunOpenMultiFileDialog(params, PlatformGetWindowHandle(), &files); } else if (params.mode == content::FileChooserParams::Save) { base::FilePath file; if (RunSaveFileDialog(params, PlatformGetWindowHandle(), &file)) files.push_back(file); } else { NOTIMPLEMENTED(); } callback.Run(files); } void CefBrowserHostImpl::PlatformHandleExternalProtocol(const GURL& url) { if (CEF_CURRENTLY_ON_FILET()) { if (!HasExternalHandler(url.scheme())) return; const std::string& address = url.spec(); if (address.length() > kMaxAddressLengthChars) return; ShellExecuteA(NULL, "open", address.c_str(), NULL, NULL, SW_SHOWNORMAL); } else { // Execute on the FILE thread. CEF_POST_TASK(CEF_FILET, base::Bind(&CefBrowserHostImpl::PlatformHandleExternalProtocol, this, url)); } } // static bool CefBrowserHostImpl::IsWindowRenderingDisabled(const CefWindowInfo& info) { return info.window_rendering_disabled ? true : false; } bool CefBrowserHostImpl::IsTransparent() { return window_info_.transparent_painting != 0; } void CefBrowserHostImpl::PlatformTranslateKeyEvent( content::NativeWebKeyboardEvent& result, const CefKeyEvent& key_event) { result.timeStampSeconds = GetMessageTime() / 1000.0; result.windowsKeyCode = key_event.windows_key_code; result.nativeKeyCode = key_event.native_key_code; result.isSystemKey = key_event.is_system_key; switch (key_event.type) { case KEYEVENT_RAWKEYDOWN: case KEYEVENT_KEYDOWN: result.type = WebKit::WebInputEvent::RawKeyDown; break; case KEYEVENT_KEYUP: result.type = WebKit::WebInputEvent::KeyUp; break; case KEYEVENT_CHAR: result.type = WebKit::WebInputEvent::Char; break; default: NOTREACHED(); } if (result.type == WebKit::WebInputEvent::Char || result.type == WebKit::WebInputEvent::RawKeyDown) { result.text[0] = result.windowsKeyCode; result.unmodifiedText[0] = result.windowsKeyCode; } if (result.type != WebKit::WebInputEvent::Char) result.setKeyIdentifierFromWindowsKeyCode(); result.modifiers |= TranslateModifiers(key_event.modifiers); } void CefBrowserHostImpl::PlatformTranslateClickEvent( WebKit::WebMouseEvent& result, const CefMouseEvent& mouse_event, CefBrowserHost::MouseButtonType type, bool mouseUp, int clickCount) { PlatformTranslateMouseEvent(result, mouse_event); switch (type) { case MBT_LEFT: result.type = mouseUp ? WebKit::WebInputEvent::MouseUp : WebKit::WebInputEvent::MouseDown; result.button = WebKit::WebMouseEvent::ButtonLeft; break; case MBT_MIDDLE: result.type = mouseUp ? WebKit::WebInputEvent::MouseUp : WebKit::WebInputEvent::MouseDown; result.button = WebKit::WebMouseEvent::ButtonMiddle; break; case MBT_RIGHT: result.type = mouseUp ? WebKit::WebInputEvent::MouseUp : WebKit::WebInputEvent::MouseDown; result.button = WebKit::WebMouseEvent::ButtonRight; break; default: NOTREACHED(); } result.clickCount = clickCount; } void CefBrowserHostImpl::PlatformTranslateMoveEvent( WebKit::WebMouseEvent& result, const CefMouseEvent& mouse_event, bool mouseLeave) { PlatformTranslateMouseEvent(result, mouse_event); if (!mouseLeave) { result.type = WebKit::WebInputEvent::MouseMove; if (mouse_event.modifiers & EVENTFLAG_LEFT_MOUSE_BUTTON) result.button = WebKit::WebMouseEvent::ButtonLeft; else if (mouse_event.modifiers & EVENTFLAG_MIDDLE_MOUSE_BUTTON) result.button = WebKit::WebMouseEvent::ButtonMiddle; else if (mouse_event.modifiers & EVENTFLAG_RIGHT_MOUSE_BUTTON) result.button = WebKit::WebMouseEvent::ButtonRight; else result.button = WebKit::WebMouseEvent::ButtonNone; } else { result.type = WebKit::WebInputEvent::MouseLeave; result.button = WebKit::WebMouseEvent::ButtonNone; } result.clickCount = 0; } void CefBrowserHostImpl::PlatformTranslateWheelEvent( WebKit::WebMouseWheelEvent& result, const CefMouseEvent& mouse_event, int deltaX, int deltaY) { PlatformTranslateMouseEvent(result, mouse_event); result.type = WebKit::WebInputEvent::MouseWheel; result.button = WebKit::WebMouseEvent::ButtonNone; float wheelDelta; bool horizontalScroll = false; wheelDelta = static_cast(deltaY ? deltaY : deltaX); horizontalScroll = (deltaY == 0); static const ULONG defaultScrollCharsPerWheelDelta = 1; static const FLOAT scrollbarPixelsPerLine = 100.0f / 3.0f; static const ULONG defaultScrollLinesPerWheelDelta = 3; wheelDelta /= WHEEL_DELTA; float scrollDelta = wheelDelta; if (horizontalScroll) { ULONG scrollChars = defaultScrollCharsPerWheelDelta; SystemParametersInfo(SPI_GETWHEELSCROLLCHARS, 0, &scrollChars, 0); scrollDelta *= static_cast(scrollChars) * scrollbarPixelsPerLine; } else { ULONG scrollLines = defaultScrollLinesPerWheelDelta; SystemParametersInfo(SPI_GETWHEELSCROLLLINES, 0, &scrollLines, 0); if (scrollLines == WHEEL_PAGESCROLL) result.scrollByPage = true; if (!result.scrollByPage) scrollDelta *= static_cast(scrollLines) * scrollbarPixelsPerLine; } // Set scroll amount based on above calculations. WebKit expects positive // deltaY to mean "scroll up" and positive deltaX to mean "scroll left". if (horizontalScroll) { result.deltaX = scrollDelta; result.wheelTicksX = wheelDelta; } else { result.deltaY = scrollDelta; result.wheelTicksY = wheelDelta; } } void CefBrowserHostImpl::PlatformTranslateMouseEvent( WebKit::WebMouseEvent& result, const CefMouseEvent& mouse_event) { // position result.x = mouse_event.x; result.y = mouse_event.y; result.windowX = result.x; result.windowY = result.y; result.globalX = result.x; result.globalY = result.y; // global position if (IsWindowRenderingDisabled()) { GetClient()->GetRenderHandler()->GetScreenPoint(GetBrowser(), result.x, result.y, result.globalX, result.globalY); } else { POINT globalPoint = { result.x, result.y }; ClientToScreen(GetWindowHandle(), &globalPoint); result.globalX = globalPoint.x; result.globalY = globalPoint.y; } // modifiers result.modifiers |= TranslateModifiers(mouse_event.modifiers); // timestamp result.timeStampSeconds = GetMessageTime() / 1000.0; }