blob: 08131e61107bc4163c4fb1e9a65ee5a1ecda6b04 [file] [log] [blame]
/*
* Copyright (C) 2018 Sony Interactive Entertainment Inc.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. 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.
*
* THIS SOFTWARE IS PROVIDED BY APPLE INC. ``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 APPLE INC. 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 "stdafx.h"
#include "MainWindow.h"
#include "Common.h"
#include "MiniBrowserLibResource.h"
#include <sstream>
#if USE(CF)
#include <CoreFoundation/CoreFoundation.h>
#endif
#if ENABLE(WEBKIT)
#include "WebKitBrowserWindow.h"
#endif
#if ENABLE(WEBKIT_LEGACY)
#include "WebKitLegacyBrowserWindow.h"
#endif
namespace WebCore {
float deviceScaleFactorForWindow(HWND);
}
static const wchar_t* kMiniBrowserRegistryKey = L"Software\\WebKit\\MiniBrowser";
static constexpr int kToolbarImageSize = 32;
static constexpr int kToolbarURLBarIndex = 4;
static constexpr int kToolbarProgressIndicatorIndex = 5;
static WNDPROC DefEditProc = nullptr;
static LRESULT CALLBACK EditProc(HWND, UINT, WPARAM, LPARAM);
static INT_PTR CALLBACK About(HWND, UINT, WPARAM, LPARAM);
std::wstring MainWindow::s_windowClass;
size_t MainWindow::s_numInstances;
static std::wstring loadString(int id)
{
constexpr size_t length = 100;
wchar_t buff[length];
LoadString(hInst, id, buff, length);
return buff;
}
void MainWindow::registerClass(HINSTANCE hInstance)
{
static bool initialized = false;
if (initialized)
return;
initialized = true;
s_windowClass = loadString(IDC_MINIBROWSER);
WNDCLASSEX wcex;
wcex.cbSize = sizeof(WNDCLASSEX);
wcex.style = CS_HREDRAW | CS_VREDRAW;
wcex.lpfnWndProc = WndProc;
wcex.cbClsExtra = 0;
wcex.cbWndExtra = 0;
wcex.hInstance = hInstance;
wcex.hIcon = LoadIcon(hInstance, MAKEINTRESOURCE(IDI_MINIBROWSER));
wcex.hCursor = LoadCursor(0, IDC_ARROW);
wcex.hbrBackground = 0;
wcex.lpszMenuName = MAKEINTRESOURCE(IDC_MINIBROWSER);
wcex.lpszClassName = s_windowClass.c_str();
wcex.hIconSm = LoadIcon(wcex.hInstance, MAKEINTRESOURCE(IDI_SMALL));
RegisterClassEx(&wcex);
}
bool MainWindow::isInstance(HWND hwnd)
{
wchar_t buff[64];
if (!GetClassName(hwnd, buff, _countof(buff)))
return false;
return s_windowClass == buff;
}
MainWindow::MainWindow()
{
s_numInstances++;
}
MainWindow::~MainWindow()
{
s_numInstances--;
}
Ref<MainWindow> MainWindow::create()
{
return adoptRef(*new MainWindow());
}
void MainWindow::createToolbar(HINSTANCE hInstance)
{
m_hToolbarWnd = CreateWindowEx(0, TOOLBARCLASSNAME, nullptr,
WS_CHILD | WS_BORDER | TBSTYLE_FLAT | TBSTYLE_LIST | TBSTYLE_TOOLTIPS, 0, 0, 0, 0,
m_hMainWnd, nullptr, hInstance, nullptr);
if (!m_hToolbarWnd)
return;
const int ImageListID = 0;
const int numButtons = 4;
HIMAGELIST hImageList;
hImageList = ImageList_LoadImage(hInstance, MAKEINTRESOURCE(IDB_TOOLBAR), kToolbarImageSize, 0, CLR_DEFAULT, IMAGE_BITMAP, 0);
SendMessage(m_hToolbarWnd, TB_SETIMAGELIST, ImageListID, reinterpret_cast<LPARAM>(hImageList));
SendMessage(m_hToolbarWnd, TB_SETEXTENDEDSTYLE, 0, TBSTYLE_EX_DRAWDDARROWS | TBSTYLE_EX_MIXEDBUTTONS);
const DWORD buttonStyles = BTNS_AUTOSIZE;
TBBUTTON tbButtons[] = {
{ MAKELONG(0, ImageListID), IDM_HISTORY_BACKWARD, TBSTATE_ENABLED, buttonStyles | BTNS_DROPDOWN, { }, 0, (INT_PTR)L"Back" },
{ MAKELONG(1, ImageListID), IDM_HISTORY_FORWARD, TBSTATE_ENABLED, buttonStyles | BTNS_DROPDOWN, { }, 0, (INT_PTR)L"Forward"},
{ MAKELONG(2, ImageListID), IDM_RELOAD, TBSTATE_ENABLED, buttonStyles, { }, 0, (INT_PTR)L"Reload"},
{ MAKELONG(3, ImageListID), IDM_GO_HOME, TBSTATE_ENABLED, buttonStyles, { }, 0, (INT_PTR)L"Home"},
{ 0, 0, TBSTATE_ENABLED, BTNS_SEP, { }, 0, 0}, // URL bar
{ 0, 0, TBSTATE_ENABLED, BTNS_SEP, { }, 0, 0}, // Progress indicator
};
ASSERT(tbButtons[kToolbarURLBarIndex].fsStyle == BTNS_SEP);
ASSERT(tbButtons[kToolbarProgressIndicatorIndex].fsStyle == BTNS_SEP);
SendMessage(m_hToolbarWnd, TB_BUTTONSTRUCTSIZE, sizeof(TBBUTTON), 0);
SendMessage(m_hToolbarWnd, TB_ADDBUTTONS, _countof(tbButtons), reinterpret_cast<LPARAM>(&tbButtons));
ShowWindow(m_hToolbarWnd, true);
m_hURLBarWnd = CreateWindow(L"EDIT", 0, WS_CHILD | WS_VISIBLE | WS_BORDER | ES_LEFT | ES_AUTOVSCROLL, 0, 0, 0, 0, m_hToolbarWnd, 0, hInstance, 0);
m_hProgressIndicator = CreateWindow(L"STATIC", 0, WS_CHILD | WS_VISIBLE | SS_CENTER | SS_CENTERIMAGE, 0, 0, 0, 0, m_hToolbarWnd, 0, hInstance, 0);
DefEditProc = reinterpret_cast<WNDPROC>(GetWindowLongPtr(m_hURLBarWnd, GWLP_WNDPROC));
SetWindowLongPtr(m_hURLBarWnd, GWLP_WNDPROC, reinterpret_cast<LONG_PTR>(EditProc));
}
void MainWindow::resizeToolbar(int parentWidth)
{
TBBUTTONINFO info { sizeof(TBBUTTONINFO), TBIF_BYINDEX | TBIF_SIZE };
info.cx = parentWidth - m_toolbarItemsWidth;
SendMessage(m_hToolbarWnd, TB_SETBUTTONINFO, kToolbarURLBarIndex, reinterpret_cast<LPARAM>(&info));
SendMessage(m_hToolbarWnd, TB_AUTOSIZE, 0, 0);
RECT rect;
SendMessage(m_hToolbarWnd, TB_GETITEMRECT, kToolbarURLBarIndex, reinterpret_cast<LPARAM>(&rect));
MoveWindow(m_hURLBarWnd, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, true);
SendMessage(m_hToolbarWnd, TB_GETITEMRECT, kToolbarProgressIndicatorIndex, reinterpret_cast<LPARAM>(&rect));
MoveWindow(m_hProgressIndicator, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, true);
}
void MainWindow::rescaleToolbar()
{
const float scaleFactor = WebCore::deviceScaleFactorForWindow(m_hMainWnd);
const int scaledImageSize = kToolbarImageSize * scaleFactor;
TBBUTTONINFO info { sizeof(TBBUTTONINFO), TBIF_BYINDEX | TBIF_SIZE };
info.cx = 0;
SendMessage(m_hToolbarWnd, TB_SETBUTTONINFO, kToolbarURLBarIndex, reinterpret_cast<LPARAM>(&info));
info.cx = scaledImageSize * 2;
SendMessage(m_hToolbarWnd, TB_SETBUTTONINFO, kToolbarProgressIndicatorIndex, reinterpret_cast<LPARAM>(&info));
SendMessage(m_hToolbarWnd, TB_AUTOSIZE, 0, 0);
int numItems = SendMessage(m_hToolbarWnd, TB_BUTTONCOUNT, 0, 0);
RECT rect;
SendMessage(m_hToolbarWnd, TB_GETITEMRECT, numItems-1, reinterpret_cast<LPARAM>(&rect));
m_toolbarItemsWidth = rect.right;
}
bool MainWindow::init(BrowserWindowFactory factory, HINSTANCE hInstance, bool usesLayeredWebView)
{
registerClass(hInstance);
auto title = loadString(IDS_APP_TITLE);
m_hMainWnd = CreateWindow(s_windowClass.c_str(), title.c_str(), WS_OVERLAPPEDWINDOW,
CW_USEDEFAULT, 0, CW_USEDEFAULT, 0, 0, 0, hInstance, this);
if (!m_hMainWnd)
return false;
#if !ENABLE(WEBKIT)
EnableMenuItem(GetMenu(m_hMainWnd), IDM_NEW_WEBKIT_WINDOW, MF_GRAYED);
#endif
#if !ENABLE(WEBKIT_LEGACY)
EnableMenuItem(GetMenu(m_hMainWnd), IDM_NEW_WEBKITLEGACY_WINDOW, MF_GRAYED);
#endif
createToolbar(hInstance);
if (!m_hToolbarWnd)
return false;
m_browserWindow = factory(*this, m_hMainWnd, usesLayeredWebView);
if (!m_browserWindow)
return false;
HRESULT hr = m_browserWindow->init();
if (FAILED(hr))
return false;
updateDeviceScaleFactor();
resizeSubViews();
SetFocus(m_hURLBarWnd);
return true;
}
void MainWindow::resizeSubViews()
{
RECT rcClient;
GetClientRect(m_hMainWnd, &rcClient);
resizeToolbar(rcClient.right);
if (m_browserWindow->usesLayeredWebView() || !m_browserWindow->hwnd())
return;
RECT rect;
GetWindowRect(m_hToolbarWnd, &rect);
POINT toolbarBottom = { 0, rect.bottom };
ScreenToClient(m_hMainWnd, &toolbarBottom);
auto height = toolbarBottom.y;
MoveWindow(m_browserWindow->hwnd(), 0, height, rcClient.right, rcClient.bottom - height, true);
}
LRESULT CALLBACK MainWindow::WndProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
LRESULT result = 0;
RefPtr<MainWindow> thisWindow = reinterpret_cast<MainWindow*>(GetWindowLongPtr(hWnd, GWLP_USERDATA));
switch (message) {
case WM_ACTIVATE:
switch (LOWORD(wParam)) {
case WA_ACTIVE:
case WA_CLICKACTIVE:
SetFocus(thisWindow->browserWindow()->hwnd());
}
break;
case WM_CREATE:
SetWindowLongPtr(hWnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(reinterpret_cast<LPCREATESTRUCT>(lParam)->lpCreateParams));
break;
case WM_APPCOMMAND: {
auto cmd = GET_APPCOMMAND_LPARAM(lParam);
switch (cmd) {
case APPCOMMAND_BROWSER_BACKWARD:
thisWindow->browserWindow()->navigateForwardOrBackward(false);
result = 1;
break;
case APPCOMMAND_BROWSER_FORWARD:
thisWindow->browserWindow()->navigateForwardOrBackward(true);
result = 1;
break;
case APPCOMMAND_BROWSER_HOME:
thisWindow->goHome();
break;
case APPCOMMAND_BROWSER_REFRESH:
thisWindow->browserWindow()->reload();
result = 1;
break;
case APPCOMMAND_BROWSER_STOP:
break;
}
break;
}
case WM_COMMAND: {
int wmId = LOWORD(wParam);
int wmEvent = HIWORD(wParam);
switch (wmEvent) {
case 0: // Menu or BN_CLICKED
case 1: // Accelerator
break;
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
if (wmId >= IDM_HISTORY_LINK0 && wmId <= IDM_HISTORY_LINK9) {
thisWindow->browserWindow()->navigateToHistory(wmId);
break;
}
// Parse the menu selections:
switch (wmId) {
case IDC_URL_BAR:
thisWindow->onURLBarEnter();
break;
#if ENABLE(WEBKIT)
case IDM_NEW_WEBKIT_WINDOW: {
auto& newWindow = MainWindow::create().leakRef();
newWindow.init(WebKitBrowserWindow::create, hInst);
ShowWindow(newWindow.hwnd(), SW_SHOW);
break;
}
#endif
#if ENABLE(WEBKIT_LEGACY)
case IDM_NEW_WEBKITLEGACY_WINDOW: {
auto& newWindow = MainWindow::create().leakRef();
newWindow.init(WebKitLegacyBrowserWindow::create, hInst);
ShowWindow(newWindow.hwnd(), SW_SHOW);
break;
}
#endif
case IDM_CLOSE_WINDOW:
PostMessage(hWnd, WM_CLOSE, 0, 0);
break;
case IDM_ABOUT:
DialogBox(hInst, MAKEINTRESOURCE(IDD_ABOUTBOX), hWnd, About);
break;
case IDM_GO_HOME:
thisWindow->goHome();
break;
case IDM_EXIT:
DestroyWindow(hWnd);
break;
case IDM_PRINT:
thisWindow->browserWindow()->print();
break;
case IDM_WEB_INSPECTOR:
thisWindow->browserWindow()->launchInspector();
break;
case IDM_PROXY_SETTINGS:
thisWindow->browserWindow()->openProxySettings();
break;
case IDM_SET_DEFAULT_URL:
thisWindow->setDefaultURLToCurrentURL();
break;
case IDM_CACHES:
if (!::IsWindow(thisWindow->m_hCacheWnd)) {
thisWindow->m_hCacheWnd = CreateDialogParam(hInst, MAKEINTRESOURCE(IDD_CACHES), hWnd, cachesDialogProc, reinterpret_cast<LPARAM>(thisWindow.get()));
::ShowWindow(thisWindow->m_hCacheWnd, SW_SHOW);
}
break;
case IDM_HISTORY_BACKWARD:
case IDM_HISTORY_FORWARD:
thisWindow->browserWindow()->navigateForwardOrBackward(wmId == IDM_HISTORY_FORWARD);
break;
case IDM_UA_OTHER:
DialogBoxParam(hInst, MAKEINTRESOURCE(IDD_USER_AGENT), hWnd, customUserAgentDialogProc, reinterpret_cast<LPARAM>(thisWindow.get()));
break;
case IDM_ACTUAL_SIZE:
thisWindow->browserWindow()->resetZoom();
break;
case IDM_RELOAD:
thisWindow->browserWindow()->reload();
break;
case IDM_ZOOM_IN:
thisWindow->browserWindow()->zoomIn();
break;
case IDM_ZOOM_OUT:
thisWindow->browserWindow()->zoomOut();
break;
case IDM_SHOW_LAYER_TREE:
thisWindow->browserWindow()->showLayerTree();
break;
default:
if (!thisWindow->toggleMenuItem(wmId))
return DefWindowProc(hWnd, message, wParam, lParam);
}
}
break;
case WM_DESTROY:
SetWindowLongPtr(hWnd, GWLP_USERDATA, 0);
thisWindow->deref();
if (s_numInstances > 1)
return 0;
#if USE(CF)
CFRunLoopStop(CFRunLoopGetMain());
#endif
PostQuitMessage(0);
break;
case WM_SIZE:
thisWindow->resizeSubViews();
break;
case WM_DPICHANGED: {
thisWindow->updateDeviceScaleFactor();
auto& rect = *reinterpret_cast<RECT*>(lParam);
SetWindowPos(hWnd, nullptr, rect.left, rect.top, rect.right - rect.left, rect.bottom - rect.top, SWP_NOZORDER | SWP_NOACTIVATE);
break;
}
default:
return DefWindowProc(hWnd, message, wParam, lParam);
}
return result;
}
static bool menuItemIsChecked(const MENUITEMINFO& info)
{
return info.fState & MFS_CHECKED;
}
static void turnOffOtherUserAgents(HMENU menu)
{
MENUITEMINFO info;
::memset(&info, 0x00, sizeof(info));
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE;
// Must unset the other menu items:
for (UINT menuToClear = IDM_UA_DEFAULT; menuToClear <= IDM_UA_OTHER; ++menuToClear) {
if (!::GetMenuItemInfo(menu, menuToClear, FALSE, &info))
continue;
if (!menuItemIsChecked(info))
continue;
info.fState = MFS_UNCHECKED;
::SetMenuItemInfo(menu, menuToClear, FALSE, &info);
}
}
void MainWindow::setDefaultURLToCurrentURL()
{
wchar_t url[INTERNET_MAX_URL_LENGTH];
GetWindowText(m_hURLBarWnd, url, INTERNET_MAX_URL_LENGTH);
auto length = wcslen(url);
if (!length)
return;
RegSetKeyValue(HKEY_CURRENT_USER, kMiniBrowserRegistryKey, L"DefaultURL", REG_SZ, url, (length + 1) * sizeof(wchar_t));
}
bool MainWindow::toggleMenuItem(UINT menuID)
{
HMENU menu = ::GetMenu(hwnd());
switch (menuID) {
case IDM_UA_DEFAULT:
case IDM_UA_SAFARI:
case IDM_UA_SAFARI_IOS_IPHONE:
case IDM_UA_SAFARI_IOS_IPAD:
case IDM_UA_EDGE:
case IDM_UA_IE_11:
case IDM_UA_CHROME_MAC:
case IDM_UA_CHROME_WIN:
case IDM_UA_FIREFOX_MAC:
case IDM_UA_FIREFOX_WIN:
m_browserWindow->setUserAgent(menuID);
turnOffOtherUserAgents(menu);
break;
case IDM_UA_OTHER:
// The actual user agent string will be set by the custom user agent dialog
turnOffOtherUserAgents(menu);
break;
}
MENUITEMINFO info = { };
info.cbSize = sizeof(info);
info.fMask = MIIM_STATE;
if (!::GetMenuItemInfo(menu, menuID, FALSE, &info))
return false;
BOOL newState = !menuItemIsChecked(info);
info.fState = (newState) ? MFS_CHECKED : MFS_UNCHECKED;
::SetMenuItemInfo(menu, menuID, FALSE, &info);
m_browserWindow->setPreference(menuID, newState);
return true;
}
LRESULT CALLBACK EditProc(HWND hWnd, UINT message, WPARAM wParam, LPARAM lParam)
{
switch (message) {
case WM_SETFOCUS:
PostMessage(hWnd, EM_SETSEL, 0, -1);
break;
case WM_CHAR:
if (wParam == 13) {
// Enter Key
::PostMessage(GetParent(hWnd), static_cast<UINT>(WM_COMMAND), MAKELPARAM(IDC_URL_BAR, 0), 0);
return 0;
}
break;
}
return CallWindowProc(DefEditProc, hWnd, message, wParam, lParam);
}
// Message handler for about box.
INT_PTR CALLBACK About(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
UNREFERENCED_PARAMETER(lParam);
switch (message) {
case WM_INITDIALOG:
return (INT_PTR)TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
INT_PTR CALLBACK MainWindow::cachesDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
MainWindow& thisWindow = *reinterpret_cast<MainWindow*>(GetWindowLongPtr(hDlg, DWLP_USER));
switch (message) {
case WM_INITDIALOG:
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
::SetTimer(hDlg, IDT_UPDATE_STATS, 1000, nullptr);
return (INT_PTR)TRUE;
case WM_COMMAND:
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
::KillTimer(hDlg, IDT_UPDATE_STATS);
::DestroyWindow(hDlg);
thisWindow.m_hCacheWnd = 0;
return (INT_PTR)TRUE;
}
break;
case IDT_UPDATE_STATS:
::InvalidateRect(hDlg, nullptr, FALSE);
return (INT_PTR)TRUE;
case WM_PAINT:
thisWindow.browserWindow()->updateStatistics(hDlg);
break;
}
return (INT_PTR)FALSE;
}
INT_PTR CALLBACK MainWindow::customUserAgentDialogProc(HWND hDlg, UINT message, WPARAM wParam, LPARAM lParam)
{
MainWindow& thisWindow = *reinterpret_cast<MainWindow*>(GetWindowLongPtr(hDlg, DWLP_USER));
switch (message) {
case WM_INITDIALOG: {
MainWindow& thisWindow = *reinterpret_cast<MainWindow*>(lParam);
SetWindowLongPtr(hDlg, DWLP_USER, lParam);
HWND edit = ::GetDlgItem(hDlg, IDC_USER_AGENT_INPUT);
_bstr_t userAgent;
userAgent = thisWindow.browserWindow()->userAgent();
::SetWindowText(edit, static_cast<LPCTSTR>(userAgent));
return (INT_PTR)TRUE;
}
case WM_COMMAND:
if (LOWORD(wParam) == IDOK) {
HWND edit = ::GetDlgItem(hDlg, IDC_USER_AGENT_INPUT);
TCHAR buffer[1024];
int strLen = ::GetWindowText(edit, buffer, 1024);
buffer[strLen] = 0;
_bstr_t bstr(buffer);
if (bstr.length()) {
thisWindow.browserWindow()->setUserAgent(bstr);
thisWindow.toggleMenuItem(IDM_UA_OTHER);
}
}
if (LOWORD(wParam) == IDOK || LOWORD(wParam) == IDCANCEL) {
::EndDialog(hDlg, LOWORD(wParam));
return (INT_PTR)TRUE;
}
break;
}
return (INT_PTR)FALSE;
}
void MainWindow::loadURL(std::wstring url)
{
if (::PathFileExists(url.c_str()) || ::PathIsUNC(url.c_str())) {
wchar_t fileURL[INTERNET_MAX_URL_LENGTH];
DWORD fileURLLength = _countof(fileURL);
if (SUCCEEDED(::UrlCreateFromPath(url.c_str(), fileURL, &fileURLLength, 0)))
url = fileURL;
}
if (url.find(L"://") == url.npos)
url = L"http://" + url;
if (FAILED(m_browserWindow->loadURL(_bstr_t(url.c_str()))))
return;
SetFocus(m_browserWindow->hwnd());
}
void MainWindow::goHome()
{
std::wstring defaultURL = L"https://www.webkit.org/";
wchar_t url[INTERNET_MAX_URL_LENGTH];
DWORD urlLength = sizeof(url);
if (!RegGetValue(HKEY_CURRENT_USER, kMiniBrowserRegistryKey, L"DefaultURL", RRF_RT_REG_SZ, nullptr, &url, &urlLength))
defaultURL = url;
loadURL(defaultURL);
}
void MainWindow::onURLBarEnter()
{
wchar_t url[INTERNET_MAX_URL_LENGTH];
GetWindowText(m_hURLBarWnd, url, INTERNET_MAX_URL_LENGTH);
loadURL(url);
}
void MainWindow::updateDeviceScaleFactor()
{
if (m_hURLBarFont)
::DeleteObject(m_hURLBarFont);
rescaleToolbar();
RECT rect;
GetClientRect(m_hToolbarWnd, &rect);
int fontHeight = rect.bottom * 3. / 4;
m_hURLBarFont = ::CreateFont(fontHeight, 0, 0, 0, FW_NORMAL, FALSE, FALSE, FALSE, DEFAULT_CHARSET,
OUT_TT_ONLY_PRECIS, CLIP_DEFAULT_PRECIS, CLEARTYPE_QUALITY, FF_DONTCARE, L"Tahoma");
::SendMessage(m_hURLBarWnd, static_cast<UINT>(WM_SETFONT), reinterpret_cast<WPARAM>(m_hURLBarFont), TRUE);
}
void MainWindow::progressChanged(double progress)
{
std::wostringstream text;
text << static_cast<int>(progress * 100) << L'%';
SetWindowText(m_hProgressIndicator, text.str().c_str());
}
void MainWindow::progressFinished()
{
SetWindowText(m_hProgressIndicator, L"");
}
void MainWindow::activeURLChanged(std::wstring url)
{
SetWindowText(m_hURLBarWnd, url.c_str());
}