2013-04-03 20:20:59 +02:00
|
|
|
// Copyright (c) 2013 The Chromium Embedded Framework Authors. All rights
|
2012-04-03 03:34:16 +02:00
|
|
|
// reserved. Use of this source code is governed by a BSD-style license that
|
|
|
|
|
// can be found in the LICENSE file.
|
|
|
|
|
|
2015-01-31 01:55:56 +01:00
|
|
|
#include "cefclient/browser/client_handler.h"
|
2015-01-26 20:34:26 +01:00
|
|
|
|
2012-04-03 03:34:16 +02:00
|
|
|
#include <stdio.h>
|
2013-04-16 21:23:00 +02:00
|
|
|
#include <algorithm>
|
2015-02-11 19:15:04 +01:00
|
|
|
#include <iomanip>
|
2012-04-03 03:34:16 +02:00
|
|
|
#include <sstream>
|
|
|
|
|
#include <string>
|
2013-04-16 21:23:00 +02:00
|
|
|
|
2014-07-15 00:18:51 +02:00
|
|
|
#include "include/base/cef_bind.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
#include "include/cef_browser.h"
|
|
|
|
|
#include "include/cef_frame.h"
|
2015-04-09 16:59:34 +02:00
|
|
|
#include "include/cef_parser.h"
|
2014-07-15 00:18:51 +02:00
|
|
|
#include "include/wrapper/cef_closure_task.h"
|
2015-01-31 01:55:56 +01:00
|
|
|
#include "cefclient/browser/main_context.h"
|
|
|
|
|
#include "cefclient/browser/resource_util.h"
|
|
|
|
|
#include "cefclient/browser/root_window_manager.h"
|
|
|
|
|
#include "cefclient/browser/test_runner.h"
|
|
|
|
|
#include "cefclient/common/client_switches.h"
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2015-01-23 20:09:34 +01:00
|
|
|
namespace client {
|
|
|
|
|
|
2015-01-22 22:39:36 +01:00
|
|
|
#if defined(OS_WIN)
|
|
|
|
|
#define NEWLINE "\r\n"
|
|
|
|
|
#else
|
|
|
|
|
#define NEWLINE "\n"
|
|
|
|
|
#endif
|
|
|
|
|
|
2013-04-03 20:20:59 +02:00
|
|
|
namespace {
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2012-04-19 22:31:46 +02:00
|
|
|
// Custom menu command Ids.
|
|
|
|
|
enum client_menu_ids {
|
|
|
|
|
CLIENT_ID_SHOW_DEVTOOLS = MENU_ID_USER_FIRST,
|
2013-11-08 17:06:06 +01:00
|
|
|
CLIENT_ID_CLOSE_DEVTOOLS,
|
2014-10-11 02:12:01 +02:00
|
|
|
CLIENT_ID_INSPECT_ELEMENT,
|
2012-04-19 22:31:46 +02:00
|
|
|
CLIENT_ID_TESTMENU_SUBMENU,
|
|
|
|
|
CLIENT_ID_TESTMENU_CHECKITEM,
|
|
|
|
|
CLIENT_ID_TESTMENU_RADIOITEM1,
|
|
|
|
|
CLIENT_ID_TESTMENU_RADIOITEM2,
|
|
|
|
|
CLIENT_ID_TESTMENU_RADIOITEM3,
|
|
|
|
|
};
|
|
|
|
|
|
2015-01-31 01:55:56 +01:00
|
|
|
// Musr match the value in client_renderer.cc.
|
|
|
|
|
const char kFocusedNodeChangedMessage[] = "ClientRenderer.FocusedNodeChanged";
|
|
|
|
|
|
2015-02-11 19:15:04 +01:00
|
|
|
std::string GetTimeString(const CefTime& value) {
|
|
|
|
|
if (value.GetTimeT() == 0)
|
|
|
|
|
return "Unspecified";
|
|
|
|
|
|
|
|
|
|
static const char* kMonths[] = {
|
|
|
|
|
"January", "February", "March", "April", "May", "June", "July", "August",
|
|
|
|
|
"September", "October", "November", "December"
|
|
|
|
|
};
|
|
|
|
|
std::string month;
|
|
|
|
|
if (value.month >= 1 && value.month <= 12)
|
|
|
|
|
month = kMonths[value.month - 1];
|
|
|
|
|
else
|
|
|
|
|
month = "Invalid";
|
|
|
|
|
|
|
|
|
|
std::stringstream ss;
|
|
|
|
|
ss << month << " " << value.day_of_month << ", " << value.year << " " <<
|
|
|
|
|
std::setfill('0') << std::setw(2) << value.hour << ":" <<
|
|
|
|
|
std::setfill('0') << std::setw(2) << value.minute << ":" <<
|
|
|
|
|
std::setfill('0') << std::setw(2) << value.second;
|
|
|
|
|
return ss.str();
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
std::string GetBinaryString(CefRefPtr<CefBinaryValue> value) {
|
|
|
|
|
if (!value.get())
|
|
|
|
|
return " ";
|
|
|
|
|
|
|
|
|
|
// Retrieve the value.
|
|
|
|
|
const size_t size = value->GetSize();
|
|
|
|
|
std::string src;
|
|
|
|
|
src.resize(size);
|
|
|
|
|
value->GetData(const_cast<char*>(src.data()), size, 0);
|
|
|
|
|
|
|
|
|
|
// Encode the value.
|
|
|
|
|
return CefBase64Encode(src.data(), src.size());
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Load a data: URI containing the error message.
|
|
|
|
|
void LoadErrorPage(CefRefPtr<CefFrame> frame,
|
|
|
|
|
const std::string& failed_url,
|
|
|
|
|
cef_errorcode_t error_code,
|
|
|
|
|
const std::string& other_info) {
|
|
|
|
|
std::stringstream ss;
|
|
|
|
|
ss << "<html><head><title>Page failed to load</title></head>"
|
|
|
|
|
"<body bgcolor=\"white\">"
|
|
|
|
|
"<h3>Page failed to load.</h3>"
|
|
|
|
|
"URL: <a href=\"" << failed_url << "\">"<< failed_url << "</a>"
|
2015-02-14 00:17:08 +01:00
|
|
|
"<br/>Error: " << test_runner::GetErrorString(error_code) <<
|
2015-02-11 19:15:04 +01:00
|
|
|
" (" << error_code << ")";
|
|
|
|
|
|
|
|
|
|
if (!other_info.empty())
|
|
|
|
|
ss << "<br/>" << other_info;
|
|
|
|
|
|
|
|
|
|
ss << "</body></html>";
|
|
|
|
|
frame->LoadURL(test_runner::GetDataURI(ss.str(), "text/html"));
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-03 20:20:59 +02:00
|
|
|
} // namespace
|
|
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
ClientHandler::ClientHandler(Delegate* delegate,
|
|
|
|
|
bool is_osr,
|
|
|
|
|
const std::string& startup_url)
|
|
|
|
|
: is_osr_(is_osr),
|
|
|
|
|
startup_url_(startup_url),
|
|
|
|
|
delegate_(delegate),
|
2015-01-26 20:34:26 +01:00
|
|
|
browser_count_(0),
|
2015-01-23 20:09:34 +01:00
|
|
|
console_log_file_(MainContext::Get()->GetConsoleLogPath()),
|
2015-01-22 22:39:36 +01:00
|
|
|
first_console_message_(true),
|
2014-07-11 22:28:37 +02:00
|
|
|
focus_on_editable_field_(false) {
|
2015-01-23 21:03:47 +01:00
|
|
|
DCHECK(!console_log_file_.empty());
|
|
|
|
|
|
2014-07-09 19:13:06 +02:00
|
|
|
#if defined(OS_LINUX)
|
2015-01-23 21:03:47 +01:00
|
|
|
// Provide the GTK-based dialog implementation on Linux.
|
2015-01-26 20:34:26 +01:00
|
|
|
dialog_handler_ = new ClientDialogHandlerGtk();
|
2014-07-09 19:13:06 +02:00
|
|
|
#endif
|
|
|
|
|
|
2015-05-23 03:57:31 +02:00
|
|
|
resource_manager_ = new CefResourceManager();
|
|
|
|
|
test_runner::SetupResourceManager(resource_manager_);
|
|
|
|
|
|
2012-06-26 18:47:05 +02:00
|
|
|
// Read command line settings.
|
|
|
|
|
CefRefPtr<CefCommandLine> command_line =
|
|
|
|
|
CefCommandLine::GetGlobalCommandLine();
|
2014-07-11 22:28:37 +02:00
|
|
|
mouse_cursor_change_disabled_ =
|
2015-01-23 20:09:34 +01:00
|
|
|
command_line->HasSwitch(switches::kMouseCursorChangeDisabled);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
void ClientHandler::DetachDelegate() {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(base::Bind(&ClientHandler::DetachDelegate, this));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
DCHECK(delegate_);
|
|
|
|
|
delegate_ = NULL;
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
2012-06-11 22:03:49 +02:00
|
|
|
bool ClientHandler::OnProcessMessageReceived(
|
2012-04-12 22:21:50 +02:00
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefProcessId source_process,
|
|
|
|
|
CefRefPtr<CefProcessMessage> message) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2014-01-28 00:31:03 +01:00
|
|
|
if (message_router_->OnProcessMessageReceived(browser, source_process,
|
|
|
|
|
message)) {
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
// Check for messages from the client renderer.
|
|
|
|
|
std::string message_name = message->GetName();
|
2015-01-31 01:55:56 +01:00
|
|
|
if (message_name == kFocusedNodeChangedMessage) {
|
2012-06-11 17:52:49 +02:00
|
|
|
// A message is sent from ClientRenderDelegate to tell us whether the
|
2014-07-11 22:28:37 +02:00
|
|
|
// currently focused DOM node is editable. Use of |focus_on_editable_field_|
|
2012-06-11 17:52:49 +02:00
|
|
|
// is redundant with CefKeyEvent.focus_on_editable_field in OnPreKeyEvent
|
|
|
|
|
// but is useful for demonstration purposes.
|
2014-07-11 22:28:37 +02:00
|
|
|
focus_on_editable_field_ = message->GetArgumentList()->GetBool(0);
|
2012-06-11 17:52:49 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2014-01-28 00:31:03 +01:00
|
|
|
return false;
|
2012-04-12 22:21:50 +02:00
|
|
|
}
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
void ClientHandler::OnBeforeContextMenu(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
CefRefPtr<CefContextMenuParams> params,
|
|
|
|
|
CefRefPtr<CefMenuModel> model) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
if ((params->GetTypeFlags() & (CM_TYPEFLAG_PAGE | CM_TYPEFLAG_FRAME)) != 0) {
|
|
|
|
|
// Add a separator if the menu already has items.
|
|
|
|
|
if (model->GetCount() > 0)
|
2012-08-29 18:58:40 +02:00
|
|
|
model->AddSeparator();
|
2012-06-11 17:52:49 +02:00
|
|
|
|
2013-11-08 17:06:06 +01:00
|
|
|
// Add DevTools items to all context menus.
|
2012-06-11 17:52:49 +02:00
|
|
|
model->AddItem(CLIENT_ID_SHOW_DEVTOOLS, "&Show DevTools");
|
2013-11-08 17:06:06 +01:00
|
|
|
model->AddItem(CLIENT_ID_CLOSE_DEVTOOLS, "Close DevTools");
|
2014-10-11 02:12:01 +02:00
|
|
|
model->AddSeparator();
|
|
|
|
|
model->AddItem(CLIENT_ID_INSPECT_ELEMENT, "Inspect Element");
|
2012-06-11 17:52:49 +02:00
|
|
|
|
|
|
|
|
// Test context menu features.
|
|
|
|
|
BuildTestMenu(model);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ClientHandler::OnContextMenuCommand(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
CefRefPtr<CefContextMenuParams> params,
|
|
|
|
|
int command_id,
|
|
|
|
|
EventFlags event_flags) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
switch (command_id) {
|
|
|
|
|
case CLIENT_ID_SHOW_DEVTOOLS:
|
2014-10-11 02:12:01 +02:00
|
|
|
ShowDevTools(browser, CefPoint());
|
2012-06-11 17:52:49 +02:00
|
|
|
return true;
|
2013-11-08 17:06:06 +01:00
|
|
|
case CLIENT_ID_CLOSE_DEVTOOLS:
|
|
|
|
|
CloseDevTools(browser);
|
|
|
|
|
return true;
|
2014-10-11 02:12:01 +02:00
|
|
|
case CLIENT_ID_INSPECT_ELEMENT:
|
|
|
|
|
ShowDevTools(browser, CefPoint(params->GetXCoord(), params->GetYCoord()));
|
|
|
|
|
return true;
|
2012-06-11 17:52:49 +02:00
|
|
|
default: // Allow default handling, if any.
|
|
|
|
|
return ExecuteTestMenu(command_id);
|
|
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
void ClientHandler::OnAddressChange(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
const CefString& url) {
|
|
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
|
|
|
|
// Only update the address for the main (top-level) frame.
|
|
|
|
|
if (frame->IsMain())
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyAddress(url);
|
2015-01-26 20:34:26 +01:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::OnTitleChange(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefString& title) {
|
|
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyTitle(title);
|
2015-01-26 20:34:26 +01:00
|
|
|
}
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
bool ClientHandler::OnConsoleMessage(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefString& message,
|
|
|
|
|
const CefString& source,
|
|
|
|
|
int line) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-06-11 17:52:49 +02:00
|
|
|
|
2015-01-22 22:39:36 +01:00
|
|
|
FILE* file = fopen(console_log_file_.c_str(), "a");
|
2012-06-11 17:52:49 +02:00
|
|
|
if (file) {
|
|
|
|
|
std::stringstream ss;
|
2015-01-22 22:39:36 +01:00
|
|
|
ss << "Message: " << message.ToString() << NEWLINE <<
|
|
|
|
|
"Source: " << source.ToString() << NEWLINE <<
|
|
|
|
|
"Line: " << line << NEWLINE <<
|
|
|
|
|
"-----------------------" << NEWLINE;
|
2012-06-11 17:52:49 +02:00
|
|
|
fputs(ss.str().c_str(), file);
|
|
|
|
|
fclose(file);
|
|
|
|
|
|
2015-01-22 22:39:36 +01:00
|
|
|
if (first_console_message_) {
|
2015-01-23 20:09:34 +01:00
|
|
|
test_runner::Alert(
|
2015-01-22 22:39:36 +01:00
|
|
|
browser, "Console messages written to \"" + console_log_file_ + "\"");
|
|
|
|
|
first_console_message_ = false;
|
|
|
|
|
}
|
2012-06-11 17:52:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-28 19:21:18 +02:00
|
|
|
void ClientHandler::OnBeforeDownload(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefDownloadItem> download_item,
|
|
|
|
|
const CefString& suggested_name,
|
|
|
|
|
CefRefPtr<CefBeforeDownloadCallback> callback) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2014-07-15 00:18:51 +02:00
|
|
|
|
2012-06-28 19:21:18 +02:00
|
|
|
// Continue the download and show the "Save As" dialog.
|
2015-01-23 20:09:34 +01:00
|
|
|
callback->Continue(MainContext::Get()->GetDownloadPath(suggested_name), true);
|
2012-06-28 19:21:18 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::OnDownloadUpdated(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefDownloadItem> download_item,
|
|
|
|
|
CefRefPtr<CefDownloadItemCallback> callback) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2014-07-15 00:18:51 +02:00
|
|
|
|
2012-06-28 19:21:18 +02:00
|
|
|
if (download_item->IsComplete()) {
|
2015-01-23 20:09:34 +01:00
|
|
|
test_runner::Alert(
|
2015-01-22 22:39:36 +01:00
|
|
|
browser,
|
|
|
|
|
"File \"" + download_item->GetFullPath().ToString() +
|
|
|
|
|
"\" downloaded successfully.");
|
2012-06-28 19:21:18 +02:00
|
|
|
}
|
|
|
|
|
}
|
|
|
|
|
|
2013-06-24 17:45:58 +02:00
|
|
|
bool ClientHandler::OnDragEnter(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefDragData> dragData,
|
2014-07-01 00:30:29 +02:00
|
|
|
CefDragHandler::DragOperationsMask mask) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2013-06-24 17:45:58 +02:00
|
|
|
|
|
|
|
|
// Forbid dragging of link URLs.
|
2013-07-24 22:15:18 +02:00
|
|
|
if (mask & DRAG_OPERATION_LINK)
|
2013-06-24 17:45:58 +02:00
|
|
|
return true;
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-24 15:48:32 +02:00
|
|
|
void ClientHandler::OnDraggableRegionsChanged(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const std::vector<CefDraggableRegion>& regions) {
|
|
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
|
|
|
|
NotifyDraggableRegions(regions);
|
|
|
|
|
}
|
|
|
|
|
|
2014-07-02 20:25:22 +02:00
|
|
|
bool ClientHandler::OnRequestGeolocationPermission(
|
2012-06-11 17:52:49 +02:00
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefString& requesting_url,
|
|
|
|
|
int request_id,
|
|
|
|
|
CefRefPtr<CefGeolocationCallback> callback) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
// Allow geolocation access from all websites.
|
|
|
|
|
callback->Continue(true);
|
2014-07-02 20:25:22 +02:00
|
|
|
return true;
|
2012-06-11 17:52:49 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ClientHandler::OnPreKeyEvent(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefKeyEvent& event,
|
|
|
|
|
CefEventHandle os_event,
|
|
|
|
|
bool* is_keyboard_shortcut) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2012-06-11 17:52:49 +02:00
|
|
|
if (!event.focus_on_editable_field && event.windows_key_code == 0x20) {
|
|
|
|
|
// Special handling for the space character when an input element does not
|
|
|
|
|
// have focus. Handling the event in OnPreKeyEvent() keeps the event from
|
|
|
|
|
// being processed in the renderer. If we instead handled the event in the
|
|
|
|
|
// OnKeyEvent() method the space key would cause the window to scroll in
|
|
|
|
|
// addition to showing the alert box.
|
2015-01-26 20:34:26 +01:00
|
|
|
if (event.type == KEYEVENT_RAWKEYDOWN)
|
|
|
|
|
test_runner::Alert(browser, "You pressed the space bar!");
|
2012-06-11 17:52:49 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-09 21:22:31 +01:00
|
|
|
bool ClientHandler::OnBeforePopup(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
const CefString& target_url,
|
|
|
|
|
const CefString& target_frame_name,
|
|
|
|
|
CefLifeSpanHandler::WindowOpenDisposition target_disposition,
|
|
|
|
|
bool user_gesture,
|
|
|
|
|
const CefPopupFeatures& popupFeatures,
|
|
|
|
|
CefWindowInfo& windowInfo,
|
|
|
|
|
CefRefPtr<CefClient>& client,
|
|
|
|
|
CefBrowserSettings& settings,
|
|
|
|
|
bool* no_javascript_access) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_IO_THREAD();
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
// Return true to cancel the popup window.
|
2015-01-27 01:03:25 +01:00
|
|
|
return !CreatePopupWindow(browser, false, popupFeatures, windowInfo, client,
|
|
|
|
|
settings);
|
2014-07-01 00:30:29 +02:00
|
|
|
}
|
|
|
|
|
|
2012-04-03 03:34:16 +02:00
|
|
|
void ClientHandler::OnAfterCreated(CefRefPtr<CefBrowser> browser) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
browser_count_++;
|
|
|
|
|
|
2014-02-10 19:53:56 +01:00
|
|
|
if (!message_router_) {
|
|
|
|
|
// Create the browser-side router for query handling.
|
|
|
|
|
CefMessageRouterConfig config;
|
|
|
|
|
message_router_ = CefMessageRouterBrowserSide::Create(config);
|
|
|
|
|
|
|
|
|
|
// Register handlers with the router.
|
2015-01-23 20:09:34 +01:00
|
|
|
test_runner::CreateMessageHandlers(message_handler_set_);
|
2014-02-10 19:53:56 +01:00
|
|
|
MessageHandlerSet::const_iterator it = message_handler_set_.begin();
|
|
|
|
|
for (; it != message_handler_set_.end(); ++it)
|
|
|
|
|
message_router_->AddHandler(*(it), false);
|
|
|
|
|
}
|
|
|
|
|
|
2013-04-05 19:05:37 +02:00
|
|
|
// Disable mouse cursor change if requested via the command-line flag.
|
2014-07-11 22:28:37 +02:00
|
|
|
if (mouse_cursor_change_disabled_)
|
2013-04-05 19:05:37 +02:00
|
|
|
browser->GetHost()->SetMouseCursorChangeDisabled(true);
|
|
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyBrowserCreated(browser);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ClientHandler::DoClose(CefRefPtr<CefBrowser> browser) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyBrowserClosing(browser);
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2013-03-19 23:59:33 +01:00
|
|
|
// Allow the close. For windowed browsers this will result in the OS close
|
|
|
|
|
// event being sent.
|
2012-04-03 03:34:16 +02:00
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::OnBeforeClose(CefRefPtr<CefBrowser> browser) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2014-07-11 22:28:37 +02:00
|
|
|
if (--browser_count_ == 0) {
|
2014-01-28 00:31:03 +01:00
|
|
|
// Remove and delete message router handlers.
|
2015-01-26 20:34:26 +01:00
|
|
|
MessageHandlerSet::const_iterator it =
|
|
|
|
|
message_handler_set_.begin();
|
2014-01-28 00:31:03 +01:00
|
|
|
for (; it != message_handler_set_.end(); ++it) {
|
|
|
|
|
message_router_->RemoveHandler(*(it));
|
|
|
|
|
delete *(it);
|
|
|
|
|
}
|
|
|
|
|
message_handler_set_.clear();
|
|
|
|
|
message_router_ = NULL;
|
2013-03-19 23:59:33 +01:00
|
|
|
}
|
2015-01-26 20:34:26 +01:00
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyBrowserClosed(browser);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
2013-09-12 22:34:18 +02:00
|
|
|
void ClientHandler::OnLoadingStateChange(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
bool isLoading,
|
|
|
|
|
bool canGoBack,
|
|
|
|
|
bool canGoForward) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-04-03 03:34:16 +02:00
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
NotifyLoadingState(isLoading, canGoBack, canGoForward);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::OnLoadError(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
ErrorCode errorCode,
|
|
|
|
|
const CefString& errorText,
|
|
|
|
|
const CefString& failedUrl) {
|
2014-07-11 22:10:05 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
2012-04-11 20:00:55 +02:00
|
|
|
|
2012-06-11 19:35:23 +02:00
|
|
|
// Don't display an error for downloaded files.
|
|
|
|
|
if (errorCode == ERR_ABORTED)
|
|
|
|
|
return;
|
|
|
|
|
|
2012-06-25 23:21:27 +02:00
|
|
|
// Don't display an error for external protocols that we allow the OS to
|
|
|
|
|
// handle. See OnProtocolExecution().
|
|
|
|
|
if (errorCode == ERR_UNKNOWN_URL_SCHEME) {
|
|
|
|
|
std::string urlStr = frame->GetURL();
|
|
|
|
|
if (urlStr.find("spotify:") == 0)
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-11 19:15:04 +01:00
|
|
|
// Load the error page.
|
|
|
|
|
LoadErrorPage(frame, failedUrl, errorCode, errorText);
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
|
|
|
|
|
2014-01-28 00:31:03 +01:00
|
|
|
bool ClientHandler::OnBeforeBrowse(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
CefRefPtr<CefRequest> request,
|
|
|
|
|
bool is_redirect) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2014-01-28 00:31:03 +01:00
|
|
|
message_router_->OnBeforeBrowse(browser, frame);
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-03-09 21:22:31 +01:00
|
|
|
bool ClientHandler::OnOpenURLFromTab(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
const CefString& target_url,
|
|
|
|
|
CefRequestHandler::WindowOpenDisposition target_disposition,
|
|
|
|
|
bool user_gesture) {
|
|
|
|
|
if (user_gesture && target_disposition == WOD_NEW_BACKGROUND_TAB) {
|
|
|
|
|
// Handle middle-click and ctrl + left-click by opening the URL in a new
|
|
|
|
|
// browser window.
|
|
|
|
|
MainContext::Get()->GetRootWindowManager()->CreateRootWindow(
|
|
|
|
|
true, is_osr(), CefRect(), target_url);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Open the URL in the current browser window.
|
|
|
|
|
return false;
|
|
|
|
|
}
|
|
|
|
|
|
2015-05-23 03:57:31 +02:00
|
|
|
cef_return_value_t ClientHandler::OnBeforeResourceLoad(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
CefRefPtr<CefRequest> request,
|
|
|
|
|
CefRefPtr<CefRequestCallback> callback) {
|
|
|
|
|
CEF_REQUIRE_IO_THREAD();
|
|
|
|
|
|
|
|
|
|
return resource_manager_->OnBeforeResourceLoad(browser, frame, request,
|
|
|
|
|
callback);
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-12 22:21:50 +02:00
|
|
|
CefRefPtr<CefResourceHandler> ClientHandler::GetResourceHandler(
|
2014-01-28 00:31:03 +01:00
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
CefRefPtr<CefFrame> frame,
|
|
|
|
|
CefRefPtr<CefRequest> request) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_IO_THREAD();
|
2015-01-26 20:34:26 +01:00
|
|
|
|
2015-05-23 03:57:31 +02:00
|
|
|
return resource_manager_->GetResourceHandler(browser, frame, request);
|
2012-04-12 22:21:50 +02:00
|
|
|
}
|
|
|
|
|
|
2012-09-28 00:52:15 +02:00
|
|
|
bool ClientHandler::OnQuotaRequest(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefString& origin_url,
|
|
|
|
|
int64 new_size,
|
2015-04-02 17:21:46 +02:00
|
|
|
CefRefPtr<CefRequestCallback> callback) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_IO_THREAD();
|
|
|
|
|
|
2012-09-28 00:52:15 +02:00
|
|
|
static const int64 max_size = 1024 * 1024 * 20; // 20mb.
|
|
|
|
|
|
|
|
|
|
// Grant the quota request if the size is reasonable.
|
|
|
|
|
callback->Continue(new_size <= max_size);
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
2012-06-25 23:21:27 +02:00
|
|
|
void ClientHandler::OnProtocolExecution(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefString& url,
|
|
|
|
|
bool& allow_os_execution) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2012-06-25 23:21:27 +02:00
|
|
|
std::string urlStr = url;
|
|
|
|
|
|
|
|
|
|
// Allow OS execution of Spotify URIs.
|
|
|
|
|
if (urlStr.find("spotify:") == 0)
|
|
|
|
|
allow_os_execution = true;
|
|
|
|
|
}
|
|
|
|
|
|
2015-02-11 19:15:04 +01:00
|
|
|
bool ClientHandler::OnCertificateError(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
ErrorCode cert_error,
|
|
|
|
|
const CefString& request_url,
|
|
|
|
|
CefRefPtr<CefSSLInfo> ssl_info,
|
2015-04-02 17:21:46 +02:00
|
|
|
CefRefPtr<CefRequestCallback> callback) {
|
2015-02-11 19:15:04 +01:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
|
|
|
|
CefRefPtr<CefSSLCertPrincipal> subject = ssl_info->GetSubject();
|
|
|
|
|
CefRefPtr<CefSSLCertPrincipal> issuer = ssl_info->GetIssuer();
|
|
|
|
|
|
|
|
|
|
// Build a table showing certificate information.
|
|
|
|
|
std::stringstream ss;
|
|
|
|
|
ss << "X.509 Certificate Information:"
|
|
|
|
|
"<table border=1><tr><th>Field</th><th>Value</th></tr>" <<
|
|
|
|
|
"<tr><td>Subject</td><td>" <<
|
|
|
|
|
(subject.get() ? subject->GetDisplayName().ToString() : " ") <<
|
|
|
|
|
"</td></tr>"
|
|
|
|
|
"<tr><td>Issuer</td><td>" <<
|
|
|
|
|
(issuer.get() ? issuer->GetDisplayName().ToString() : " ") <<
|
|
|
|
|
"</td></tr>"
|
|
|
|
|
"<tr><td>Serial #*</td><td>" <<
|
|
|
|
|
GetBinaryString(ssl_info->GetSerialNumber()) << "</td></tr>"
|
|
|
|
|
"<tr><td>Valid Start</td><td>" <<
|
|
|
|
|
GetTimeString(ssl_info->GetValidStart()) << "</td></tr>"
|
|
|
|
|
"<tr><td>Valid Expiry</td><td>" <<
|
|
|
|
|
GetTimeString(ssl_info->GetValidExpiry()) << "</td></tr>"
|
|
|
|
|
"<tr><td>DER Encoded*</td>"
|
|
|
|
|
"<td style=\"max-width:800px;overflow:scroll;\">" <<
|
|
|
|
|
GetBinaryString(ssl_info->GetDEREncoded()) << "</td></tr>"
|
|
|
|
|
"<tr><td>PEM Encoded*</td>"
|
|
|
|
|
"<td style=\"max-width:800px;overflow:scroll;\">" <<
|
|
|
|
|
GetBinaryString(ssl_info->GetPEMEncoded()) << "</td></tr>"
|
|
|
|
|
"</table> * Displayed value is base64 encoded.";
|
|
|
|
|
|
|
|
|
|
// Load the error page.
|
|
|
|
|
LoadErrorPage(browser->GetMainFrame(), request_url, cert_error, ss.str());
|
|
|
|
|
|
|
|
|
|
return false; // Cancel the request.
|
|
|
|
|
}
|
|
|
|
|
|
2013-09-12 22:34:18 +02:00
|
|
|
void ClientHandler::OnRenderProcessTerminated(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
TerminationStatus status) {
|
2014-07-15 00:18:51 +02:00
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
|
2014-01-28 00:31:03 +01:00
|
|
|
message_router_->OnRenderProcessTerminated(browser);
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
// Don't reload if there's no start URL, or if the crash URL was specified.
|
|
|
|
|
if (startup_url_.empty() || startup_url_ == "chrome://crash")
|
|
|
|
|
return;
|
|
|
|
|
|
2013-09-12 22:34:18 +02:00
|
|
|
CefRefPtr<CefFrame> frame = browser->GetMainFrame();
|
|
|
|
|
std::string url = frame->GetURL();
|
2014-07-01 00:30:29 +02:00
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
// Don't reload if the termination occurred before any URL had successfully
|
|
|
|
|
// loaded.
|
|
|
|
|
if (url.empty())
|
2014-07-01 00:30:29 +02:00
|
|
|
return;
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
std::string start_url = startup_url_;
|
2014-07-01 00:30:29 +02:00
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
// Convert URLs to lowercase for easier comparison.
|
|
|
|
|
std::transform(url.begin(), url.end(), url.begin(), tolower);
|
|
|
|
|
std::transform(start_url.begin(), start_url.end(), start_url.begin(),
|
|
|
|
|
tolower);
|
2014-07-01 00:30:29 +02:00
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
// Don't reload the URL that just resulted in termination.
|
|
|
|
|
if (url.find(start_url) == 0)
|
2014-07-01 00:30:29 +02:00
|
|
|
return;
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
frame->LoadURL(startup_url_);
|
2014-07-01 00:30:29 +02:00
|
|
|
}
|
|
|
|
|
|
2015-01-26 20:34:26 +01:00
|
|
|
int ClientHandler::GetBrowserCount() const {
|
|
|
|
|
CEF_REQUIRE_UI_THREAD();
|
|
|
|
|
return browser_count_;
|
2014-07-15 00:18:51 +02:00
|
|
|
}
|
|
|
|
|
|
2014-10-11 02:12:01 +02:00
|
|
|
void ClientHandler::ShowDevTools(CefRefPtr<CefBrowser> browser,
|
|
|
|
|
const CefPoint& inspect_element_at) {
|
2013-11-08 17:06:06 +01:00
|
|
|
CefWindowInfo windowInfo;
|
2015-01-26 20:34:26 +01:00
|
|
|
CefRefPtr<CefClient> client;
|
2013-11-08 17:06:06 +01:00
|
|
|
CefBrowserSettings settings;
|
2012-06-26 18:47:05 +02:00
|
|
|
|
2015-01-27 01:03:25 +01:00
|
|
|
if (CreatePopupWindow(browser, true, CefPopupFeatures(), windowInfo, client,
|
2015-01-26 20:34:26 +01:00
|
|
|
settings)) {
|
|
|
|
|
browser->GetHost()->ShowDevTools(windowInfo, client, settings,
|
|
|
|
|
inspect_element_at);
|
|
|
|
|
}
|
2013-11-08 17:06:06 +01:00
|
|
|
}
|
2012-06-26 18:47:05 +02:00
|
|
|
|
2013-11-08 17:06:06 +01:00
|
|
|
void ClientHandler::CloseDevTools(CefRefPtr<CefBrowser> browser) {
|
|
|
|
|
browser->GetHost()->CloseDevTools();
|
2012-04-03 03:34:16 +02:00
|
|
|
}
|
2012-04-12 22:21:50 +02:00
|
|
|
|
2015-01-30 19:55:55 +01:00
|
|
|
|
|
|
|
|
bool ClientHandler::CreatePopupWindow(
|
|
|
|
|
CefRefPtr<CefBrowser> browser,
|
|
|
|
|
bool is_devtools,
|
|
|
|
|
const CefPopupFeatures& popupFeatures,
|
|
|
|
|
CefWindowInfo& windowInfo,
|
|
|
|
|
CefRefPtr<CefClient>& client,
|
|
|
|
|
CefBrowserSettings& settings) {
|
|
|
|
|
// Note: This method will be called on multiple threads.
|
|
|
|
|
|
|
|
|
|
// The popup browser will be parented to a new native window.
|
|
|
|
|
// Don't show URL bar and navigation buttons on DevTools windows.
|
|
|
|
|
MainContext::Get()->GetRootWindowManager()->CreateRootWindowAsPopup(
|
|
|
|
|
!is_devtools, is_osr(), popupFeatures, windowInfo, client, settings);
|
|
|
|
|
|
|
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyBrowserCreated(CefRefPtr<CefBrowser> browser) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyBrowserCreated, this, browser));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnBrowserCreated(browser);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyBrowserClosing(CefRefPtr<CefBrowser> browser) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyBrowserClosing, this, browser));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnBrowserClosing(browser);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyBrowserClosed(CefRefPtr<CefBrowser> browser) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyBrowserClosed, this, browser));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnBrowserClosed(browser);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyAddress(const CefString& url) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyAddress, this, url));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnSetAddress(url);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyTitle(const CefString& title) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyTitle, this, title));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnSetTitle(title);
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
void ClientHandler::NotifyLoadingState(bool isLoading,
|
|
|
|
|
bool canGoBack,
|
|
|
|
|
bool canGoForward) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyLoadingState, this,
|
|
|
|
|
isLoading, canGoBack, canGoForward));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnSetLoadingState(isLoading, canGoBack, canGoForward);
|
|
|
|
|
}
|
|
|
|
|
|
2015-04-24 15:48:32 +02:00
|
|
|
void ClientHandler::NotifyDraggableRegions(
|
|
|
|
|
const std::vector<CefDraggableRegion>& regions) {
|
|
|
|
|
if (!CURRENTLY_ON_MAIN_THREAD()) {
|
|
|
|
|
// Execute this method on the main thread.
|
|
|
|
|
MAIN_POST_CLOSURE(
|
|
|
|
|
base::Bind(&ClientHandler::NotifyDraggableRegions, this, regions));
|
|
|
|
|
return;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
if (delegate_)
|
|
|
|
|
delegate_->OnSetDraggableRegions(regions);
|
|
|
|
|
}
|
|
|
|
|
|
2012-04-19 22:31:46 +02:00
|
|
|
void ClientHandler::BuildTestMenu(CefRefPtr<CefMenuModel> model) {
|
|
|
|
|
if (model->GetCount() > 0)
|
2012-08-29 18:58:40 +02:00
|
|
|
model->AddSeparator();
|
2012-04-19 22:31:46 +02:00
|
|
|
|
|
|
|
|
// Build the sub menu.
|
|
|
|
|
CefRefPtr<CefMenuModel> submenu =
|
|
|
|
|
model->AddSubMenu(CLIENT_ID_TESTMENU_SUBMENU, "Context Menu Test");
|
|
|
|
|
submenu->AddCheckItem(CLIENT_ID_TESTMENU_CHECKITEM, "Check Item");
|
|
|
|
|
submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM1, "Radio Item 1", 0);
|
|
|
|
|
submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM2, "Radio Item 2", 0);
|
|
|
|
|
submenu->AddRadioItem(CLIENT_ID_TESTMENU_RADIOITEM3, "Radio Item 3", 0);
|
|
|
|
|
|
|
|
|
|
// Check the check item.
|
2014-07-11 22:28:37 +02:00
|
|
|
if (test_menu_state_.check_item)
|
2012-04-19 22:31:46 +02:00
|
|
|
submenu->SetChecked(CLIENT_ID_TESTMENU_CHECKITEM, true);
|
|
|
|
|
|
|
|
|
|
// Check the selected radio item.
|
|
|
|
|
submenu->SetChecked(
|
2014-07-11 22:28:37 +02:00
|
|
|
CLIENT_ID_TESTMENU_RADIOITEM1 + test_menu_state_.radio_item, true);
|
2012-04-19 22:31:46 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
bool ClientHandler::ExecuteTestMenu(int command_id) {
|
|
|
|
|
if (command_id == CLIENT_ID_TESTMENU_CHECKITEM) {
|
|
|
|
|
// Toggle the check item.
|
2014-07-11 22:28:37 +02:00
|
|
|
test_menu_state_.check_item ^= 1;
|
2012-04-19 22:31:46 +02:00
|
|
|
return true;
|
|
|
|
|
} else if (command_id >= CLIENT_ID_TESTMENU_RADIOITEM1 &&
|
|
|
|
|
command_id <= CLIENT_ID_TESTMENU_RADIOITEM3) {
|
|
|
|
|
// Store the selected radio item.
|
2014-07-11 22:28:37 +02:00
|
|
|
test_menu_state_.radio_item = (command_id - CLIENT_ID_TESTMENU_RADIOITEM1);
|
2012-04-19 22:31:46 +02:00
|
|
|
return true;
|
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
// Allow default handling to proceed.
|
|
|
|
|
return false;
|
|
|
|
|
}
|
2015-01-23 20:09:34 +01:00
|
|
|
|
|
|
|
|
} // namespace client
|
