// 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 <atlbase.h>
#include <atlapp.h>
#include <commdlg.h>
#include <dwmapi.h>
#include <shellapi.h>
#include <shlobj.h>
#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<wchar_t *>(&string_buffer),
0, NULL);
std::wstring formatted_string;
if (string_buffer) {
formatted_string = string_buffer;
LocalFree(reinterpret_cast<HLOCAL>(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<SHOpenFolderAndSelectItemsFuncPtr>
(GetProcAddress(shell32_base, "SHOpenFolderAndSelectItems"));
}
if (!open_folder_and_select_itemsPtr) {
ShellExecute(NULL, _T("open"), dir.c_str(), NULL, NULL, SW_SHOW);
return;
}
CComPtr<IShellFolder> desktop;
HRESULT hr = SHGetDesktopFolder(&desktop);
if (FAILED(hr))
return;
CoMemReleaser<ITEMIDLIST> dir_item;
hr = desktop->ParseDisplayName(NULL, NULL,
const_cast<wchar_t *>(dir.c_str()),
NULL, &dir_item, NULL);
if (FAILED(hr))
return;
CoMemReleaser<ITEMIDLIST> file_item;
hr = desktop->ParseDisplayName(NULL, NULL,
const_cast<wchar_t *>(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<LONG_PTR>(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<LONG_PTR>(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<wchar_t>* 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<wchar_t> 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 + <numpad sequences> 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<unsigned char>* 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<BITMAPINFO*>(&hdr),
DIB_RGB_COLORS,
reinterpret_cast<void **>(&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<PrintWindowPointer>(
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 <http://msdn.microsoft.com/en-us/library/ms811694.aspx>.
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 <http://www.juniper.net/security/auto/vulnerabilities/vuln2612.html>.
// 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