// Copyright 2008, Google Inc. // All rights reserved. // // Redistribution and use in source and binary forms, with or without // modification, are permitted provided that the following conditions are // met: // // * Redistributions of source code must retain the above copyright // notice, this list of conditions and the following disclaimer. // * Redistributions in binary form must reproduce the above // copyright notice, this list of conditions and the following disclaimer // in the documentation and/or other materials provided with the // distribution. // * Neither the name of Google Inc. nor the names of its // contributors may be used to endorse or promote products derived from // this software without specific prior written permission. // // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. #include "chrome/common/win_util.h" #include #include #include #include #include #include #include "base/file_util.h" #include "base/gfx/bitmap_header.h" #include "base/gfx/png_encoder.h" #include "base/logging.h" #include "base/registry.h" #include "base/scoped_handle.h" #include "base/string_util.h" #include "base/win_util.h" #include "chrome/common/l10n_util.h" #include "generated_resources.h" // Ensure that we pick up this link library. #pragma comment(lib, "dwmapi.lib") namespace win_util { namespace { // Enforce visible dialog box. UINT_PTR CALLBACK SaveAsDialogHook(HWND dialog, UINT message, WPARAM wparam, LPARAM lparam) { static const UINT kPrivateMessage = 0x2F3F; switch (message) { case WM_INITDIALOG: { // Do nothing here. Just post a message to defer actual processing. PostMessage(dialog, kPrivateMessage, 0, 0); return TRUE; } case kPrivateMessage: { // The dialog box is the parent of the current handle. HWND real_dialog = GetParent(dialog); // Retrieve the final size. RECT dialog_rect; GetWindowRect(real_dialog, &dialog_rect); // Verify that the upper left corner is visible. POINT point = { dialog_rect.left, dialog_rect.top }; HMONITOR monitor1 = MonitorFromPoint(point, MONITOR_DEFAULTTONULL); point.x = dialog_rect.right; point.y = dialog_rect.bottom; // Verify that the lower right corner is visible. HMONITOR monitor2 = MonitorFromPoint(point, MONITOR_DEFAULTTONULL); if (monitor1 && monitor2) return 0; // Some part of the dialog box is not visible, fix it by moving is to the // client rect position of the browser window. HWND parent_window = GetParent(real_dialog); if (!parent_window) return 0; WINDOWINFO parent_info; parent_info.cbSize = sizeof(WINDOWINFO); GetWindowInfo(parent_window, &parent_info); SetWindowPos(real_dialog, NULL, parent_info.rcClient.left, parent_info.rcClient.top, 0, 0, // Size. SWP_NOACTIVATE | SWP_NOOWNERZORDER | SWP_NOSIZE | SWP_NOZORDER); return 0; } } return 0; } } // namespace std::wstring FormatSystemTime(const SYSTEMTIME& time, const std::wstring& format) { // If the format string is empty, just use the default format. LPCTSTR format_ptr = NULL; if (!format.empty()) format_ptr = format.c_str(); int buffer_size = GetTimeFormat(LOCALE_USER_DEFAULT, NULL, &time, format_ptr, NULL, 0); std::wstring output; GetTimeFormat(LOCALE_USER_DEFAULT, NULL, &time, format_ptr, WriteInto(&output, buffer_size), buffer_size); return output; } std::wstring FormatSystemDate(const SYSTEMTIME& date, const std::wstring& format) { // If the format string is empty, just use the default format. LPCTSTR format_ptr = NULL; if (!format.empty()) format_ptr = format.c_str(); int buffer_size = GetDateFormat(LOCALE_USER_DEFAULT, NULL, &date, format_ptr, NULL, 0); std::wstring output; GetDateFormat(LOCALE_USER_DEFAULT, NULL, &date, format_ptr, WriteInto(&output, buffer_size), buffer_size); return output; } bool ConvertToLongPath(const std::wstring& short_path, std::wstring* long_path) { wchar_t long_path_buf[MAX_PATH]; DWORD return_value = GetLongPathName(short_path.c_str(), long_path_buf, MAX_PATH); if (return_value != 0 && return_value < MAX_PATH) { *long_path = long_path_buf; return true; } return false; } bool IsDoubleClick(const POINT& origin, const POINT& current, DWORD elapsed_time) { // The CXDOUBLECLK and CYDOUBLECLK system metrics describe the width and // height of a rectangle around the origin position, inside of which clicks // within the double click time are considered double clicks. return (elapsed_time <= GetDoubleClickTime()) && (abs(current.x - origin.x) <= (GetSystemMetrics(SM_CXDOUBLECLK) / 2)) && (abs(current.y - origin.y) <= (GetSystemMetrics(SM_CYDOUBLECLK) / 2)); } bool IsDrag(const POINT& origin, const POINT& current) { // The CXDRAG and CYDRAG system metrics describe the width and height of a // rectangle around the origin position, inside of which motion is not // considered a drag. return (abs(current.x - origin.x) > (GetSystemMetrics(SM_CXDRAG) / 2)) || (abs(current.y - origin.y) > (GetSystemMetrics(SM_CYDRAG) / 2)); } bool ShouldUseVistaFrame() { if (win_util::GetWinVersion() < win_util::WINVERSION_VISTA) return false; // If composition is not enabled, we behave like on XP. BOOL f; DwmIsCompositionEnabled(&f); return !!f; } std::wstring FormatMessage(unsigned messageid) { wchar_t * string_buffer = NULL; unsigned string_length = ::FormatMessage(FORMAT_MESSAGE_ALLOCATE_BUFFER | FORMAT_MESSAGE_FROM_SYSTEM | FORMAT_MESSAGE_IGNORE_INSERTS, NULL, messageid, 0, reinterpret_cast(&string_buffer), 0, NULL); std::wstring formatted_string; if (string_buffer) { formatted_string = string_buffer; LocalFree(reinterpret_cast(string_buffer)); } else { // The formating failed. simply convert the message value into a string. SStringPrintf(&formatted_string, L"message number %d", messageid); } return formatted_string; } std::wstring FormatLastWin32Error() { return FormatMessage(GetLastError()); } void ShowItemInFolder(const std::wstring& full_path) { std::wstring dir = file_util::GetDirectoryFromPath(full_path); if (dir == L"" || !file_util::PathExists(full_path)) return; typedef HRESULT (WINAPI *SHOpenFolderAndSelectItemsFuncPtr)( PCIDLIST_ABSOLUTE pidl_Folder, UINT cidl, PCUITEMID_CHILD_ARRAY pidls, DWORD flags); static SHOpenFolderAndSelectItemsFuncPtr open_folder_and_select_itemsPtr = NULL; static bool initialize_open_folder_proc = true; if (initialize_open_folder_proc) { initialize_open_folder_proc = false; // The SHOpenFolderAndSelectItems API is exposed by shell32 version 6 // and does not exist in Win2K. We attempt to retrieve this function export // from shell32 and if it does not exist, we just invoke ShellExecute to // open the folder thus losing the functionality to select the item in // the process. HMODULE shell32_base = GetModuleHandle(L"shell32.dll"); if (!shell32_base) { NOTREACHED(); return; } open_folder_and_select_itemsPtr = reinterpret_cast (GetProcAddress(shell32_base, "SHOpenFolderAndSelectItems")); } if (!open_folder_and_select_itemsPtr) { ShellExecute(NULL, _T("open"), dir.c_str(), NULL, NULL, SW_SHOW); return; } CComPtr desktop; HRESULT hr = SHGetDesktopFolder(&desktop); if (FAILED(hr)) return; CoMemReleaser dir_item; hr = desktop->ParseDisplayName(NULL, NULL, const_cast(dir.c_str()), NULL, &dir_item, NULL); if (FAILED(hr)) return; CoMemReleaser file_item; hr = desktop->ParseDisplayName(NULL, NULL, const_cast(full_path.c_str()), NULL, &file_item, NULL); if (FAILED(hr)) return; const ITEMIDLIST* highlight[] = { {file_item}, }; (*open_folder_and_select_itemsPtr)(dir_item, arraysize(highlight), highlight, NULL); } // Open an item via a shell execute command. Error code checking and casting // explanation: http://msdn2.microsoft.com/en-us/library/ms647732.aspx bool OpenItemViaShell(const std::wstring& full_path, bool ask_for_app) { HINSTANCE h = ::ShellExecuteW(NULL, NULL, full_path.c_str(), NULL, NULL, SW_SHOWNORMAL); LONG_PTR error = reinterpret_cast(h); if (error > 32) return true; if ((error == SE_ERR_NOASSOC) && ask_for_app) return OpenItemWithExternalApp(full_path); return false; } bool OpenItemViaShellNoZoneCheck(const std::wstring& full_path, bool ask_for_app) { SHELLEXECUTEINFO sei = { sizeof(sei) }; sei.fMask = SEE_MASK_NOZONECHECKS | SEE_MASK_FLAG_DDEWAIT; sei.nShow = SW_SHOWNORMAL; sei.lpVerb = NULL; sei.lpFile = full_path.c_str(); if (::ShellExecuteExW(&sei)) return true; LONG_PTR error = reinterpret_cast(sei.hInstApp); if ((error == SE_ERR_NOASSOC) && ask_for_app) return OpenItemWithExternalApp(full_path); return false; } // Show the Windows "Open With" dialog box to ask the user to pick an app to // open the file with. bool OpenItemWithExternalApp(const std::wstring& full_path) { SHELLEXECUTEINFO sei = { sizeof(sei) }; sei.fMask = SEE_MASK_FLAG_DDEWAIT; sei.nShow = SW_SHOWNORMAL; sei.lpVerb = L"openas"; sei.lpFile = full_path.c_str(); return (TRUE == ::ShellExecuteExW(&sei)); } // 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); RegKey reg_ext(HKEY_CLASSES_ROOT, file_ext.c_str(), KEY_READ); std::wstring reg_app; if (reg_ext.ReadValue(NULL, ®_app) && !reg_app.empty()) { RegKey reg_link(HKEY_CLASSES_ROOT, reg_app.c_str(), KEY_READ); if (reg_link.ReadValue(NULL, reg_description)) return true; } return false; } // Set up a filter for a "Save As" dialog, which will consist of 'file_ext' file // extension, 'ext_desc' as the text description of the 'file_ext' type, 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 As" dialog box. The // resulting filter is stored in 'buffer', which is a vector since multiple // NULLs are embedded. 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" // ext_desc: "Text Document" // returned (in buffer): "Text Document\0*.txt\0All Files\0*.*\0\0" // This is painful to build, as you will soon see. static void FormatSaveAsFilterForExtension(const std::wstring& file_ext, const std::wstring& ext_desc, bool include_all_files, std::vector* buffer) { DCHECK(buffer); // Force something reasonable to appear in the dialog box if there is no // description provided. if (file_ext.empty() || ext_desc.empty()) include_all_files = true; size_t size; size_t offset = 0; const std::wstring all_ext = L"*.*"; const std::wstring all_desc = l10n_util::GetString(IDS_SAVEAS_ALL_FILES); // Includes 2 internal NULLs + "*". const size_t ext_size = ext_desc.length() + file_ext.length() + 3; // Includes 2 internal NULLs. const size_t all_size = all_desc.length() + all_ext.length() + 2; // Includes double terminating NULL. const size_t buf_size = (!ext_desc.empty() ? ext_size : 0) + (include_all_files ? all_size : 0) + 1; buffer->resize(buf_size); if (!file_ext.empty() && !ext_desc.empty()) { // Copy in the text description ("JPEG Image") + NULL. size = ext_desc.length() + 1; memcpy(&(*buffer)[offset], ext_desc.c_str(), size * sizeof(wchar_t)); offset += size; // Copy in the file type ("*.jpg") + NULL. const std::wstring wildcard_ext = L"*" + file_ext; size = wildcard_ext.length() + 1; memcpy(&(*buffer)[offset], wildcard_ext.c_str(), size * sizeof(wchar_t)); offset += size; } if (include_all_files) { // Copy in the default description ("All Files") + NULL. size = all_desc.length() + 1; memcpy(&(*buffer)[offset], all_desc.c_str(), size * sizeof(wchar_t)); offset += size; // Copy in the default file extension ("*.*") + NULL. size = all_ext.length() + 1; memcpy(&(*buffer)[offset], all_ext.c_str(), size * sizeof(wchar_t)); offset += size; } (*buffer)[offset] = L'\0'; // Double NULL required. } bool SaveFileAs(HWND owner, const std::wstring& suggested_name, std::wstring* final_name) { std::wstring reg_description; std::wstring file_ext = file_util::GetFileExtensionFromPath(suggested_name); if (!file_ext.empty()) { file_ext = L"." + file_ext; GetRegistryDescriptionFromExtension(file_ext, ®_description); } std::vector filter; FormatSaveAsFilterForExtension(file_ext, reg_description, true, &filter); unsigned index = 1; return SaveFileAsWithFilter(owner, suggested_name, &filter[0], L"", &index, final_name); } bool SaveFileAsWithFilter(HWND owner, const std::wstring& suggested_name, const wchar_t* filter, const std::wstring& def_ext, unsigned* index, std::wstring* final_name) { DCHECK(final_name); // Initially populated by the file component of 'suggested_name', this buffer // will be written into by Windows when the user is done with the dialog box. wchar_t file_name[MAX_PATH+1]; std::wstring file_part = file_util::GetFilenameFromPath(suggested_name); memcpy(file_name, file_part.c_str(), (file_part.length()+1) * sizeof(wchar_t)); OPENFILENAME save_as; // 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(&save_as, sizeof(save_as)); save_as.lStructSize = sizeof(OPENFILENAME); save_as.hwndOwner = owner; save_as.hInstance = NULL; save_as.lpstrFilter = &filter[0]; save_as.lpstrCustomFilter = NULL; save_as.nMaxCustFilter = 0; save_as.nFilterIndex = *index; save_as.lpstrFile = file_name; save_as.nMaxFile = arraysize(file_name); save_as.lpstrFileTitle = NULL; save_as.nMaxFileTitle = 0; // Set up the initial directory for the dialog. std::wstring directory = file_util::GetDirectoryFromPath(suggested_name); save_as.lpstrInitialDir = directory.c_str(); save_as.lpstrTitle = NULL; save_as.Flags = OFN_OVERWRITEPROMPT | OFN_EXPLORER | OFN_ENABLESIZING | OFN_ENABLEHOOK | OFN_NOCHANGEDIR | OFN_PATHMUSTEXIST; save_as.lpstrDefExt = &def_ext[0]; save_as.lCustData = NULL; save_as.lpfnHook = &SaveAsDialogHook; // Must be NULL or 0. save_as.pvReserved = NULL; save_as.dwReserved = 0; if (!GetSaveFileName(&save_as)) return false; // Return the user's choice. final_name->assign(save_as.lpstrFile); *index = save_as.nFilterIndex; std::wstring file_ext = file_util::GetFileExtensionFromPath(suggested_name); if (save_as.nFileExtension == 0) { // No extension is specified. Append the default extension. final_name->append(file_ext); } else if (save_as.nFileExtension == wcslen(save_as.lpstrFile)) { // The path ends with a ".". This is not supported on windows and since // we don't use a windows API to create the file, it will make the file // impossible to open. final_name->resize(final_name->size() - 1); } return true; } // Adjust the window to fit, returning true if the window was resized or moved. static bool AdjustWindowToFit(HWND hwnd, const RECT& bounds) { // Get the monitor. HMONITOR hmon = MonitorFromRect(&bounds, MONITOR_DEFAULTTONEAREST); if (!hmon) { NOTREACHED() << "Unable to find default monitor"; // No monitor available. return false; } MONITORINFO mi; mi.cbSize = sizeof(mi); GetMonitorInfo(hmon, &mi); gfx::Rect window_rect(bounds); gfx::Rect monitor_rect(mi.rcWork); gfx::Rect new_window_rect = window_rect.AdjustToFit(monitor_rect); if (!new_window_rect.Equals(window_rect)) { // Window doesn't fit on monitor, move and possibly resize. SetWindowPos(hwnd, 0, new_window_rect.x(), new_window_rect.y(), new_window_rect.width(), new_window_rect.height(), SWP_NOACTIVATE | SWP_NOZORDER); return true; } else { return false; } } void AdjustWindowToFit(HWND hwnd) { // Get the window bounds. RECT r; GetWindowRect(hwnd, &r); AdjustWindowToFit(hwnd, r); } void CenterAndSizeWindow(HWND parent, HWND window, const SIZE& pref, bool pref_is_client) { DCHECK(window && pref.cx > 0 && pref.cy > 0); // Calculate the ideal bounds. RECT window_bounds; RECT center_bounds = {0}; if (parent) { // If there is a parent, center over the parents bounds. ::GetWindowRect(parent, ¢er_bounds); } else { // No parent. Center over the monitor the window is on. HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST); if (monitor) { MONITORINFO mi = {0}; mi.cbSize = sizeof(mi); GetMonitorInfo(monitor, &mi); center_bounds = mi.rcWork; } else { NOTREACHED() << "Unable to get default monitor"; } } window_bounds.left = center_bounds.left + (center_bounds.right - center_bounds.left - pref.cx) / 2; window_bounds.right = window_bounds.left + pref.cx; window_bounds.top = center_bounds.top + (center_bounds.bottom - center_bounds.top - pref.cy) / 2; window_bounds.bottom = window_bounds.top + pref.cy; // If we're centering a child window, we are positioning in client // coordinates, and as such we need to offset the target rectangle by the // position of the parent window. if (::GetWindowLong(window, GWL_STYLE) & WS_CHILD) { DCHECK(parent && ::GetParent(window) == parent); POINT topleft = { window_bounds.left, window_bounds.top }; ::MapWindowPoints(HWND_DESKTOP, parent, &topleft, 1); window_bounds.left = topleft.x; window_bounds.top = topleft.y; window_bounds.right = window_bounds.left + pref.cx; window_bounds.bottom = window_bounds.top + pref.cy; } // Get the WINDOWINFO for window. We need the style to calculate the size // for the window. WINDOWINFO win_info = {0}; win_info.cbSize = sizeof(WINDOWINFO); GetWindowInfo(window, &win_info); // Calculate the window size needed for the content size. if (!pref_is_client || AdjustWindowRectEx(&window_bounds, win_info.dwStyle, FALSE, win_info.dwExStyle)) { if (!AdjustWindowToFit(window, window_bounds)) { // The window fits, reset the bounds. SetWindowPos(window, 0, window_bounds.left, window_bounds.top, window_bounds.right - window_bounds.left, window_bounds.bottom - window_bounds.top, SWP_NOACTIVATE | SWP_NOZORDER); } // else case, AdjustWindowToFit set the bounds for us. } else { NOTREACHED() << "Unable to adjust window to fit"; } } HANDLE GetSectionFromProcess(HANDLE section, HANDLE process, bool read_only) { HANDLE valid_section = NULL; DWORD access = STANDARD_RIGHTS_REQUIRED | FILE_MAP_READ; if (!read_only) access |= FILE_MAP_WRITE; DuplicateHandle(process, section, GetCurrentProcess(), &valid_section, access, FALSE, 0); return valid_section; } bool DoesWindowBelongToActiveWindow(HWND window) { DCHECK(window); HWND top_window = ::GetAncestor(window, GA_ROOT); if (!top_window) return false; HWND active_top_window = ::GetAncestor(::GetForegroundWindow(), GA_ROOT); return (top_window == active_top_window); } void EnsureRectIsVisibleInRect(const gfx::Rect& parent_rect, gfx::Rect* child_rect, int padding) { DCHECK(child_rect); // We use padding here because it allows some of the original web page to // bleed through around the edges. int twice_padding = padding * 2; // FIRST, clamp width and height so we don't open child windows larger than // the containing parent. if (child_rect->width() > (parent_rect.width() + twice_padding)) child_rect->set_width(std::max(0, parent_rect.width() - twice_padding)); if (child_rect->height() > parent_rect.height() + twice_padding) child_rect->set_height(std::max(0, parent_rect.height() - twice_padding)); // SECOND, clamp x,y position to padding,padding so we don't position child // windows in hyperspace. if (child_rect->x() < 0 || child_rect->x() > parent_rect.width()) child_rect->set_x(padding); if (child_rect->y() < 0 || child_rect->y() > parent_rect.height()) child_rect->set_y(padding); // LAST, nudge the window back up into the client area if its x,y position is // within the parent bounds but its width/height place it off-screen. if (child_rect->bottom() > parent_rect.bottom()) child_rect->set_y(parent_rect.bottom() - child_rect->height() - padding); if (child_rect->right() > parent_rect.right()) child_rect->set_x(parent_rect.right() - child_rect->width() - padding); } void SetChildBounds(HWND child_window, HWND parent_window, HWND insert_after_window, const gfx::Rect& bounds, int padding, unsigned long flags) { DCHECK(IsWindow(child_window)); // First figure out the bounds of the parent. RECT parent_rect = {0}; if (parent_window) { GetClientRect(parent_window, &parent_rect); } else { // If there is no parent, we consider the bounds of the monitor the window // is on to be the parent bounds. // If the child_window isn't visible yet and we've been given a valid, // visible insert after window, use that window to locate the correct // monitor instead. HWND window = child_window; if (!IsWindowVisible(window) && IsWindow(insert_after_window) && IsWindowVisible(insert_after_window)) window = insert_after_window; HMONITOR monitor = MonitorFromWindow(window, MONITOR_DEFAULTTONEAREST); if (monitor) { MONITORINFO mi = {0}; mi.cbSize = sizeof(mi); GetMonitorInfo(monitor, &mi); parent_rect = mi.rcWork; } else { NOTREACHED() << "Unable to get default monitor"; } } gfx::Rect actual_bounds = bounds; EnsureRectIsVisibleInRect(gfx::Rect(parent_rect), &actual_bounds, padding); SetWindowPos(child_window, insert_after_window, actual_bounds.x(), actual_bounds.y(), actual_bounds.width(), actual_bounds.height(), flags); } gfx::Rect GetMonitorBoundsForRect(const gfx::Rect& rect) { RECT p_rect = rect.ToRECT(); HMONITOR monitor = MonitorFromRect(&p_rect, MONITOR_DEFAULTTONEAREST); if (monitor) { MONITORINFO mi = {0}; mi.cbSize = sizeof(mi); GetMonitorInfo(monitor, &mi); return gfx::Rect(mi.rcWork); } NOTREACHED(); return gfx::Rect(); } bool IsNumPadDigit(int key_code, bool extended_key) { if (key_code >= VK_NUMPAD0 && key_code <= VK_NUMPAD9) return true; // Check for num pad keys without Num Lock. // Note: there is no easy way to know if a the key that was pressed comes from // the num pad or the rest of the keyboard. Investigating how // TranslateMessage() generates the WM_KEYCHAR from an // ALT + it appears it looks at the extended key flag // (which is on if the key pressed comes from one of the 3 clusters to // the left of the numeric keypad). So we use it as well. return !extended_key && ((key_code >= VK_PRIOR && key_code <= VK_DOWN) || // All keys but 5 // and 0. (key_code == VK_CLEAR) || // Key 5. (key_code == VK_INSERT)); // Key 0. } void GrabWindowSnapshot(HWND window_handle, std::vector* png_representation) { // Create a memory DC that's compatible with the window. CWindowDC window_hdc(window_handle); CDC mem_hdc(::CreateCompatibleDC(window_hdc)); // Create a DIB that's the same size as the window. RECT content_rect = {0, 0, 0, 0}; ::GetWindowRect(window_handle, &content_rect); content_rect.right++; // Match what PrintWindow wants. int width = content_rect.right - content_rect.left; int height = content_rect.bottom - content_rect.top; BITMAPINFOHEADER hdr; gfx::CreateBitmapHeader(width, height, &hdr); unsigned char *bit_ptr = NULL; CBitmap bitmap(::CreateDIBSection(mem_hdc, reinterpret_cast(&hdr), DIB_RGB_COLORS, reinterpret_cast(&bit_ptr), NULL, 0)); mem_hdc.SelectBitmap(bitmap); // Clear the bitmap to white (so that rounded corners on windows // show up on a white background, and strangely-shaped windows // look reasonable). Not capturing an alpha mask saves a // bit of space. mem_hdc.PatBlt(0, 0, width, height, WHITENESS); // Grab a copy of the window // First, see if PrintWindow is defined (it's not in Windows 2000). typedef BOOL (WINAPI *PrintWindowPointer)(HWND, HDC, UINT); PrintWindowPointer print_window = reinterpret_cast( GetProcAddress(GetModuleHandle(L"User32.dll"), "PrintWindow")); // If PrintWindow is defined, use it. It will work on partially // obscured windows, and works better for out of process sub-windows. // Otherwise grab the bits we can get with BitBlt; it's better // than nothing and will work fine in the average case (window is // completely on screen). if (print_window) (*print_window)(window_handle, mem_hdc, 0); else mem_hdc.BitBlt(0, 0, width, height, window_hdc, 0, 0, SRCCOPY); // We now have a copy of the window contents in a DIB, so // encode it into a useful format for posting to the bug report // server. PNGEncoder::Encode(bit_ptr, PNGEncoder::FORMAT_BGRA, width, height, width * 4, true, png_representation); } bool IsWindowActive(HWND hwnd) { WINDOWINFO info; return ::GetWindowInfo(hwnd, &info) && ((info.dwWindowStatus & WS_ACTIVECAPTION) != 0); } bool IsReservedName(const std::wstring& filename) { // This list is taken from the MSDN article "Naming a file" // http://msdn2.microsoft.com/en-us/library/aa365247(VS.85).aspx // I also added clock$ because GetSaveFileName seems to consider it as a // reserved name too. static const wchar_t* const known_devices[] = { L"con", L"prn", L"aux", L"nul", L"com1", L"com2", L"com3", L"com4", L"com5", L"com6", L"com7", L"com8", L"com9", L"lpt1", L"lpt2", L"lpt3", L"lpt4", L"lpt5", L"lpt6", L"lpt7", L"lpt8", L"lpt9", L"clock$" }; std::wstring filename_lower = StringToLowerASCII(filename); for (int i = 0; i < arraysize(known_devices); ++i) { // Exact match. if (filename_lower == known_devices[i]) return true; // Starts with "DEVICE.". if (filename_lower.find(std::wstring(known_devices[i]) + L".") == 0) return true; } static const wchar_t* const magic_names[] = { // These file names are used by the "Customize folder" feature of the shell. L"desktop.ini", L"thumbs.db", }; for (int i = 0; i < arraysize(magic_names); ++i) { if (filename_lower == magic_names[i]) return true; } return false; } bool IsShellIntegratedExtension(const std::wstring& extension) { std::wstring extension_lower = StringToLowerASCII(extension); static const wchar_t* const integrated_extensions[] = { // See . L"local", // Right-clicking on shortcuts can be magical. L"lnk", }; for (int i = 0; i < arraysize(integrated_extensions); ++i) { if (extension_lower == integrated_extensions[i]) return true; } // See . // That vulnerability report is not exactly on point, but files become magical // if their end in a CLSID. Here we block extensions that look like CLSIDs. if (extension_lower.size() > 0 && extension_lower.at(0) == L'{' && extension_lower.at(extension_lower.length() - 1) == L'}') return true; return false; } // In addition to passing the RTL flags to ::MessageBox if we are running in an // RTL locale, we need to make sure that LTR strings are rendered correctly by // adding the appropriate Unicode directionality marks. int MessageBox(HWND hwnd, const std::wstring& text, const std::wstring& caption, UINT flags) { UINT actual_flags = flags; if (l10n_util::GetTextDirection() == l10n_util::RIGHT_TO_LEFT) actual_flags |= MB_RIGHT | MB_RTLREADING; std::wstring localized_text; const wchar_t* text_ptr = text.c_str(); if (l10n_util::AdjustStringForLocaleDirection(text, &localized_text)) text_ptr = localized_text.c_str(); std::wstring localized_caption; const wchar_t* caption_ptr = caption.c_str(); if (l10n_util::AdjustStringForLocaleDirection(caption, &localized_caption)) caption_ptr = localized_caption.c_str(); return ::MessageBox(hwnd, text_ptr, caption_ptr, actual_flags); } } // namespace win_util