2020-06-08 20:31:49 +02:00
|
|
|
/*
|
2023-12-04 21:57:13 +13:00
|
|
|
* Copyright (c) 2020-2023, Andreas Kling <kling@serenityos.org>
|
2022-10-12 23:49:23 +02:00
|
|
|
* Copyright (c) 2021-2022, Linus Groh <linusg@serenityos.org>
|
2022-11-25 17:07:19 +00:00
|
|
|
* Copyright (c) 2022, Sam Atkins <atkinssj@serenityos.org>
|
2023-12-04 21:57:13 +13:00
|
|
|
* Copyright (c) 2023, Shannon Booth <shannon@serenityos.org>
|
2020-06-08 20:31:49 +02:00
|
|
|
*
|
2021-04-22 01:24:48 -07:00
|
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
2020-06-08 20:31:49 +02:00
|
|
|
*/
|
|
|
|
|
|
|
|
#pragma once
|
|
|
|
|
|
|
|
#include <AK/Noncopyable.h>
|
|
|
|
#include <AK/OwnPtr.h>
|
|
|
|
#include <AK/RefPtr.h>
|
2020-09-28 11:55:26 +02:00
|
|
|
#include <AK/URL.h>
|
2021-02-10 08:25:35 +01:00
|
|
|
#include <AK/WeakPtr.h>
|
|
|
|
#include <AK/Weakable.h>
|
2020-08-02 12:10:01 +02:00
|
|
|
#include <Kernel/API/KeyCode.h>
|
2020-06-08 20:31:49 +02:00
|
|
|
#include <LibGfx/Forward.h>
|
|
|
|
#include <LibGfx/Palette.h>
|
2022-11-01 14:55:53 -04:00
|
|
|
#include <LibGfx/Point.h>
|
2022-11-21 16:10:57 -05:00
|
|
|
#include <LibGfx/Rect.h>
|
2022-11-01 14:55:53 -04:00
|
|
|
#include <LibGfx/Size.h>
|
2021-02-10 08:25:35 +01:00
|
|
|
#include <LibGfx/StandardCursor.h>
|
2023-06-16 10:51:38 -04:00
|
|
|
#include <LibIPC/Forward.h>
|
2023-12-04 21:40:33 +13:00
|
|
|
#include <LibJS/Heap/Cell.h>
|
2022-10-17 11:06:50 +02:00
|
|
|
#include <LibJS/Heap/Handle.h>
|
2021-10-26 17:00:10 +01:00
|
|
|
#include <LibWeb/CSS/PreferredColorScheme.h>
|
2023-11-23 12:22:23 -05:00
|
|
|
#include <LibWeb/CSS/Selector.h>
|
2022-11-21 16:10:57 -05:00
|
|
|
#include <LibWeb/Cookie/Cookie.h>
|
2020-06-08 20:31:49 +02:00
|
|
|
#include <LibWeb/Forward.h>
|
2023-03-20 18:39:20 -04:00
|
|
|
#include <LibWeb/HTML/ActivateTab.h>
|
2022-02-26 17:50:31 +01:00
|
|
|
#include <LibWeb/Loader/FileRequest.h>
|
2022-11-25 17:07:19 +00:00
|
|
|
#include <LibWeb/PixelUnits.h>
|
2020-06-08 20:31:49 +02:00
|
|
|
|
|
|
|
namespace Web {
|
|
|
|
|
|
|
|
class PageClient;
|
|
|
|
|
2023-12-03 16:56:32 +13:00
|
|
|
class Page final : public JS::Cell {
|
2023-12-04 21:57:13 +13:00
|
|
|
JS_CELL(Page, JS::Cell);
|
2020-06-08 20:31:49 +02:00
|
|
|
|
|
|
|
public:
|
2023-12-04 21:57:13 +13:00
|
|
|
static JS::NonnullGCPtr<Page> create(JS::VM&, JS::NonnullGCPtr<PageClient>);
|
|
|
|
|
2020-06-08 20:31:49 +02:00
|
|
|
~Page();
|
|
|
|
|
|
|
|
PageClient& client() { return m_client; }
|
2022-04-01 20:58:27 +03:00
|
|
|
PageClient const& client() const { return m_client; }
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2023-11-29 09:34:38 -07:00
|
|
|
void set_top_level_traversable(JS::NonnullGCPtr<HTML::TraversableNavigable>);
|
|
|
|
|
2023-05-27 18:37:02 +02:00
|
|
|
// FIXME: This is a hack.
|
2023-08-27 17:06:39 +02:00
|
|
|
bool top_level_traversable_is_initialized() const;
|
2023-05-27 18:37:02 +02:00
|
|
|
|
2022-10-17 11:06:50 +02:00
|
|
|
HTML::BrowsingContext& top_level_browsing_context();
|
|
|
|
HTML::BrowsingContext const& top_level_browsing_context() const;
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2023-08-27 17:06:39 +02:00
|
|
|
JS::NonnullGCPtr<HTML::TraversableNavigable> top_level_traversable() const;
|
|
|
|
|
2021-11-18 15:01:28 +01:00
|
|
|
HTML::BrowsingContext& focused_context();
|
|
|
|
HTML::BrowsingContext const& focused_context() const { return const_cast<Page*>(this)->focused_context(); }
|
2020-08-14 11:33:20 +02:00
|
|
|
|
2021-11-18 15:01:28 +01:00
|
|
|
void set_focused_browsing_context(Badge<EventHandler>, HTML::BrowsingContext&);
|
2020-08-14 11:33:20 +02:00
|
|
|
|
2021-09-13 00:33:23 +03:00
|
|
|
void load(const AK::URL&);
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2023-09-17 17:12:17 +02:00
|
|
|
void load_html(StringView);
|
2020-10-08 21:11:01 +01:00
|
|
|
|
2022-11-25 17:07:19 +00:00
|
|
|
CSSPixelPoint device_to_css_point(DevicePixelPoint) const;
|
|
|
|
DevicePixelPoint css_to_device_point(CSSPixelPoint) const;
|
|
|
|
CSSPixelRect device_to_css_rect(DevicePixelRect) const;
|
|
|
|
DevicePixelRect enclosing_device_rect(CSSPixelRect) const;
|
|
|
|
DevicePixelRect rounded_device_rect(CSSPixelRect) const;
|
|
|
|
|
2023-09-08 18:48:44 +02:00
|
|
|
bool handle_mouseup(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
|
|
|
|
bool handle_mousedown(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
|
|
|
|
bool handle_mousemove(DevicePixelPoint, DevicePixelPoint screen_position, unsigned buttons, unsigned modifiers);
|
|
|
|
bool handle_mousewheel(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers, int wheel_delta_x, int wheel_delta_y);
|
|
|
|
bool handle_doubleclick(DevicePixelPoint, DevicePixelPoint screen_position, unsigned button, unsigned buttons, unsigned modifiers);
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2020-08-02 12:10:01 +02:00
|
|
|
bool handle_keydown(KeyCode, unsigned modifiers, u32 code_point);
|
2021-09-28 15:39:35 +02:00
|
|
|
bool handle_keyup(KeyCode, unsigned modifiers, u32 code_point);
|
2020-08-02 12:10:01 +02:00
|
|
|
|
2020-06-08 20:31:49 +02:00
|
|
|
Gfx::Palette palette() const;
|
2022-11-25 17:07:19 +00:00
|
|
|
CSSPixelRect web_exposed_screen_area() const;
|
2021-10-26 17:00:10 +01:00
|
|
|
CSS::PreferredColorScheme preferred_color_scheme() const;
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2021-09-12 02:10:43 +02:00
|
|
|
bool is_same_origin_policy_enabled() const { return m_same_origin_policy_enabled; }
|
|
|
|
void set_same_origin_policy_enabled(bool b) { m_same_origin_policy_enabled = b; }
|
|
|
|
|
2022-03-30 22:42:09 +01:00
|
|
|
bool is_scripting_enabled() const { return m_is_scripting_enabled; }
|
|
|
|
void set_is_scripting_enabled(bool b) { m_is_scripting_enabled = b; }
|
|
|
|
|
2022-11-15 02:01:13 +02:00
|
|
|
bool should_block_pop_ups() const { return m_should_block_pop_ups; }
|
|
|
|
void set_should_block_pop_ups(bool b) { m_should_block_pop_ups = b; }
|
|
|
|
|
2022-10-12 23:49:23 +02:00
|
|
|
bool is_webdriver_active() const { return m_is_webdriver_active; }
|
|
|
|
void set_is_webdriver_active(bool b) { m_is_webdriver_active = b; }
|
|
|
|
|
2022-11-03 12:49:54 +00:00
|
|
|
DevicePixelPoint window_position() const { return m_window_position; }
|
|
|
|
void set_window_position(DevicePixelPoint position) { m_window_position = position; }
|
2022-11-01 14:55:53 -04:00
|
|
|
|
2022-11-03 12:49:54 +00:00
|
|
|
DevicePixelSize window_size() const { return m_window_size; }
|
|
|
|
void set_window_size(DevicePixelSize size) { m_window_size = size; }
|
2022-11-01 14:55:53 -04:00
|
|
|
|
2023-03-13 17:30:51 -04:00
|
|
|
void did_request_alert(String const& message);
|
2022-11-21 15:18:42 -05:00
|
|
|
void alert_closed();
|
|
|
|
|
2023-03-13 17:30:51 -04:00
|
|
|
bool did_request_confirm(String const& message);
|
2022-11-21 15:18:42 -05:00
|
|
|
void confirm_closed(bool accepted);
|
|
|
|
|
2023-03-13 17:30:51 -04:00
|
|
|
Optional<String> did_request_prompt(String const& message, String const& default_);
|
|
|
|
void prompt_closed(Optional<String> response);
|
2022-11-21 15:18:42 -05:00
|
|
|
|
|
|
|
enum class PendingDialog {
|
|
|
|
None,
|
|
|
|
Alert,
|
|
|
|
Confirm,
|
|
|
|
Prompt,
|
|
|
|
};
|
|
|
|
bool has_pending_dialog() const { return m_pending_dialog != PendingDialog::None; }
|
|
|
|
PendingDialog pending_dialog() const { return m_pending_dialog; }
|
2023-03-13 17:30:51 -04:00
|
|
|
Optional<String> const& pending_dialog_text() const { return m_pending_dialog_text; }
|
2022-11-21 15:18:42 -05:00
|
|
|
void dismiss_dialog();
|
|
|
|
void accept_dialog();
|
|
|
|
|
2023-09-04 11:32:40 +02:00
|
|
|
void did_request_color_picker(WeakPtr<HTML::HTMLInputElement> target, Color current_color);
|
|
|
|
void color_picker_closed(Optional<Color> picked_color);
|
|
|
|
|
|
|
|
enum class PendingNonBlockingDialog {
|
|
|
|
None,
|
|
|
|
ColorPicker,
|
|
|
|
};
|
|
|
|
|
2023-06-16 10:51:38 -04:00
|
|
|
struct MediaContextMenu {
|
|
|
|
AK::URL media_url;
|
|
|
|
bool is_video { false };
|
|
|
|
bool is_playing { false };
|
2023-06-16 11:29:54 -04:00
|
|
|
bool is_muted { false };
|
2023-06-16 10:51:38 -04:00
|
|
|
bool has_user_agent_controls { false };
|
|
|
|
bool is_looping { false };
|
|
|
|
};
|
|
|
|
void did_request_media_context_menu(i32 media_id, CSSPixelPoint, DeprecatedString const& target, unsigned modifiers, MediaContextMenu);
|
|
|
|
WebIDL::ExceptionOr<void> toggle_media_play_state();
|
2023-06-16 11:29:54 -04:00
|
|
|
void toggle_media_mute_state();
|
2023-06-16 10:51:38 -04:00
|
|
|
WebIDL::ExceptionOr<void> toggle_media_loop_state();
|
|
|
|
WebIDL::ExceptionOr<void> toggle_media_controls_state();
|
2023-05-15 09:42:56 -04:00
|
|
|
|
2023-08-21 15:50:01 +01:00
|
|
|
Optional<String> const& user_style() const { return m_user_style_sheet_source; }
|
|
|
|
void set_user_style(String source);
|
|
|
|
|
2023-02-28 00:20:09 +00:00
|
|
|
bool pdf_viewer_supported() const { return m_pdf_viewer_supported; }
|
|
|
|
|
2020-06-08 20:31:49 +02:00
|
|
|
private:
|
2023-12-04 21:57:13 +13:00
|
|
|
explicit Page(JS::NonnullGCPtr<PageClient>);
|
|
|
|
virtual void visit_edges(Visitor&) override;
|
|
|
|
|
2023-06-16 10:51:38 -04:00
|
|
|
JS::GCPtr<HTML::HTMLMediaElement> media_context_menu_element();
|
2023-05-15 11:17:58 -04:00
|
|
|
|
2023-12-04 21:57:13 +13:00
|
|
|
JS::NonnullGCPtr<PageClient> m_client;
|
2020-06-08 20:31:49 +02:00
|
|
|
|
2021-11-18 15:01:28 +01:00
|
|
|
WeakPtr<HTML::BrowsingContext> m_focused_context;
|
2021-09-12 02:10:43 +02:00
|
|
|
|
2023-12-04 21:57:13 +13:00
|
|
|
JS::GCPtr<HTML::TraversableNavigable> m_top_level_traversable;
|
2023-08-27 17:06:39 +02:00
|
|
|
|
2021-10-03 23:39:07 +02:00
|
|
|
// FIXME: Enable this by default once CORS preflight checks are supported.
|
|
|
|
bool m_same_origin_policy_enabled { false };
|
2022-03-30 22:42:09 +01:00
|
|
|
|
|
|
|
bool m_is_scripting_enabled { true };
|
2022-10-12 23:49:23 +02:00
|
|
|
|
2022-11-15 02:01:13 +02:00
|
|
|
bool m_should_block_pop_ups { true };
|
|
|
|
|
2022-10-12 23:49:23 +02:00
|
|
|
// https://w3c.github.io/webdriver/#dfn-webdriver-active-flag
|
|
|
|
// The webdriver-active flag is set to true when the user agent is under remote control. It is initially false.
|
|
|
|
bool m_is_webdriver_active { false };
|
2022-11-01 14:55:53 -04:00
|
|
|
|
2022-11-03 12:49:54 +00:00
|
|
|
DevicePixelPoint m_window_position {};
|
|
|
|
DevicePixelSize m_window_size {};
|
2022-11-21 15:18:42 -05:00
|
|
|
|
|
|
|
PendingDialog m_pending_dialog { PendingDialog::None };
|
2023-03-13 17:30:51 -04:00
|
|
|
Optional<String> m_pending_dialog_text;
|
2022-11-21 15:18:42 -05:00
|
|
|
Optional<Empty> m_pending_alert_response;
|
|
|
|
Optional<bool> m_pending_confirm_response;
|
2023-03-13 17:30:51 -04:00
|
|
|
Optional<Optional<String>> m_pending_prompt_response;
|
2023-02-28 00:20:09 +00:00
|
|
|
|
2023-09-04 11:32:40 +02:00
|
|
|
PendingNonBlockingDialog m_pending_non_blocking_dialog { PendingNonBlockingDialog::None };
|
|
|
|
WeakPtr<HTML::HTMLInputElement> m_pending_non_blocking_dialog_target;
|
|
|
|
|
2023-06-16 10:51:38 -04:00
|
|
|
Optional<int> m_media_context_menu_element_id;
|
2023-05-15 09:42:56 -04:00
|
|
|
|
2023-08-21 15:50:01 +01:00
|
|
|
Optional<String> m_user_style_sheet_source;
|
|
|
|
|
2023-02-28 00:20:09 +00:00
|
|
|
// https://html.spec.whatwg.org/multipage/system-state.html#pdf-viewer-supported
|
|
|
|
// Each user agent has a PDF viewer supported boolean, whose value is implementation-defined (and might vary according to user preferences).
|
|
|
|
// Spec Note: This value also impacts the navigation processing model.
|
|
|
|
// FIXME: Actually support pdf viewing
|
|
|
|
bool m_pdf_viewer_supported { false };
|
2020-06-08 20:31:49 +02:00
|
|
|
};
|
|
|
|
|
2023-12-04 21:40:33 +13:00
|
|
|
class PageClient : public JS::Cell {
|
|
|
|
JS_CELL(PageClient, JS::Cell);
|
|
|
|
|
2020-06-08 20:31:49 +02:00
|
|
|
public:
|
2022-11-21 15:22:26 -05:00
|
|
|
virtual Page& page() = 0;
|
|
|
|
virtual Page const& page() const = 0;
|
2022-11-21 15:18:42 -05:00
|
|
|
virtual bool is_connection_open() const = 0;
|
2020-06-17 20:26:59 +02:00
|
|
|
virtual Gfx::Palette palette() const = 0;
|
2022-11-25 17:07:19 +00:00
|
|
|
virtual DevicePixelRect screen_rect() const = 0;
|
2023-05-24 10:50:57 +02:00
|
|
|
virtual double device_pixels_per_css_pixel() const = 0;
|
2021-10-26 17:00:10 +01:00
|
|
|
virtual CSS::PreferredColorScheme preferred_color_scheme() const = 0;
|
2022-11-25 17:07:19 +00:00
|
|
|
virtual void paint(DevicePixelRect const&, Gfx::Bitmap&) = 0;
|
2022-12-04 18:02:33 +00:00
|
|
|
virtual void page_did_change_title(DeprecatedString const&) { }
|
2022-11-21 16:10:57 -05:00
|
|
|
virtual void page_did_request_navigate_back() { }
|
|
|
|
virtual void page_did_request_navigate_forward() { }
|
|
|
|
virtual void page_did_request_refresh() { }
|
2022-12-06 21:35:32 +00:00
|
|
|
virtual Gfx::IntSize page_did_request_resize_window(Gfx::IntSize) { return {}; }
|
2022-12-06 20:27:44 +00:00
|
|
|
virtual Gfx::IntPoint page_did_request_reposition_window(Gfx::IntPoint) { return {}; }
|
2022-11-21 16:10:57 -05:00
|
|
|
virtual void page_did_request_restore_window() { }
|
|
|
|
virtual Gfx::IntRect page_did_request_maximize_window() { return {}; }
|
|
|
|
virtual Gfx::IntRect page_did_request_minimize_window() { return {}; }
|
|
|
|
virtual Gfx::IntRect page_did_request_fullscreen_window() { return {}; }
|
2022-11-10 00:29:35 +01:00
|
|
|
virtual void page_did_start_loading(const AK::URL&, bool is_redirect) { (void)is_redirect; }
|
2023-09-07 12:11:37 +02:00
|
|
|
virtual void page_did_create_new_document(Web::DOM::Document&) { }
|
2023-09-17 16:11:16 +02:00
|
|
|
virtual void page_did_destroy_document(Web::DOM::Document&) { }
|
2021-09-13 00:33:23 +03:00
|
|
|
virtual void page_did_finish_loading(const AK::URL&) { }
|
2020-06-08 20:31:49 +02:00
|
|
|
virtual void page_did_change_selection() { }
|
2020-09-10 19:25:13 +02:00
|
|
|
virtual void page_did_request_cursor_change(Gfx::StandardCursor) { }
|
2022-11-02 17:35:53 +00:00
|
|
|
virtual void page_did_request_context_menu(CSSPixelPoint) { }
|
|
|
|
virtual void page_did_request_link_context_menu(CSSPixelPoint, AK::URL const&, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers) { }
|
|
|
|
virtual void page_did_request_image_context_menu(CSSPixelPoint, AK::URL const&, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers, Gfx::Bitmap const*) { }
|
2023-06-16 10:51:38 -04:00
|
|
|
virtual void page_did_request_media_context_menu(CSSPixelPoint, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers, Page::MediaContextMenu) { }
|
2022-12-04 18:02:33 +00:00
|
|
|
virtual void page_did_click_link(const AK::URL&, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers) { }
|
|
|
|
virtual void page_did_middle_click_link(const AK::URL&, [[maybe_unused]] DeprecatedString const& target, [[maybe_unused]] unsigned modifiers) { }
|
2022-11-02 17:35:53 +00:00
|
|
|
virtual void page_did_enter_tooltip_area(CSSPixelPoint, DeprecatedString const&) { }
|
2020-06-08 20:31:49 +02:00
|
|
|
virtual void page_did_leave_tooltip_area() { }
|
2021-09-13 00:33:23 +03:00
|
|
|
virtual void page_did_hover_link(const AK::URL&) { }
|
2020-06-08 20:31:49 +02:00
|
|
|
virtual void page_did_unhover_link() { }
|
2022-11-02 17:35:53 +00:00
|
|
|
virtual void page_did_invalidate(CSSPixelRect const&) { }
|
2022-04-01 20:58:27 +03:00
|
|
|
virtual void page_did_change_favicon(Gfx::Bitmap const&) { }
|
2020-06-23 18:02:08 +02:00
|
|
|
virtual void page_did_layout() { }
|
2021-09-08 11:22:44 +01:00
|
|
|
virtual void page_did_request_scroll(i32, i32) { }
|
2022-11-02 17:35:53 +00:00
|
|
|
virtual void page_did_request_scroll_to(CSSPixelPoint) { }
|
|
|
|
virtual void page_did_request_scroll_into_view(CSSPixelRect const&) { }
|
2023-03-13 17:30:51 -04:00
|
|
|
virtual void page_did_request_alert(String const&) { }
|
|
|
|
virtual void page_did_request_confirm(String const&) { }
|
|
|
|
virtual void page_did_request_prompt(String const&, String const&) { }
|
|
|
|
virtual void page_did_request_set_prompt_text(String const&) { }
|
2022-11-21 15:18:42 -05:00
|
|
|
virtual void page_did_request_accept_dialog() { }
|
|
|
|
virtual void page_did_request_dismiss_dialog() { }
|
2022-11-21 16:10:57 -05:00
|
|
|
virtual Vector<Web::Cookie::Cookie> page_did_request_all_cookies(AK::URL const&) { return {}; }
|
2022-12-04 18:02:33 +00:00
|
|
|
virtual Optional<Web::Cookie::Cookie> page_did_request_named_cookie(AK::URL const&, DeprecatedString const&) { return {}; }
|
|
|
|
virtual DeprecatedString page_did_request_cookie(const AK::URL&, Cookie::Source) { return {}; }
|
2022-04-01 20:58:27 +03:00
|
|
|
virtual void page_did_set_cookie(const AK::URL&, Cookie::ParsedCookie const&, Cookie::Source) { }
|
2022-11-28 11:24:04 -05:00
|
|
|
virtual void page_did_update_cookie(Web::Cookie::Cookie) { }
|
2022-02-20 17:03:39 -05:00
|
|
|
virtual void page_did_update_resource_count(i32) { }
|
2023-03-20 18:39:20 -04:00
|
|
|
virtual String page_did_request_new_tab(HTML::ActivateTab) { return {}; }
|
2023-03-20 19:52:00 -04:00
|
|
|
virtual void page_did_request_activate_tab() { }
|
2022-09-21 01:17:01 +02:00
|
|
|
virtual void page_did_close_browsing_context(HTML::BrowsingContext const&) { }
|
2021-04-15 10:43:29 -07:00
|
|
|
|
2023-01-30 16:35:47 -05:00
|
|
|
virtual void request_file(FileRequest) = 0;
|
2022-02-26 17:50:31 +01:00
|
|
|
|
2022-10-03 23:39:53 -06:00
|
|
|
// https://html.spec.whatwg.org/multipage/input.html#show-the-picker,-if-applicable
|
|
|
|
virtual void page_did_request_file_picker(WeakPtr<DOM::EventTarget>, [[maybe_unused]] bool multiple) {};
|
2023-09-04 11:32:40 +02:00
|
|
|
virtual void page_did_request_color_picker([[maybe_unused]] Color current_color) {};
|
2022-10-03 23:39:53 -06:00
|
|
|
|
2023-09-14 19:17:32 +02:00
|
|
|
virtual void page_did_finish_text_test() {};
|
|
|
|
|
2023-09-19 01:51:48 +02:00
|
|
|
virtual void page_did_change_theme_color(Gfx::Color) { }
|
|
|
|
|
2023-11-10 13:29:20 -05:00
|
|
|
virtual void page_did_insert_clipboard_entry([[maybe_unused]] String data, [[maybe_unused]] String presentation_style, [[maybe_unused]] String mime_type) { }
|
|
|
|
|
2023-11-23 12:22:23 -05:00
|
|
|
virtual void inspector_did_load() { }
|
|
|
|
virtual void inspector_did_select_dom_node([[maybe_unused]] i32 node_id, [[maybe_unused]] Optional<CSS::Selector::PseudoElement> const& pseudo_element) { }
|
2023-12-03 11:49:08 -05:00
|
|
|
virtual void inspector_did_set_dom_node_text([[maybe_unused]] i32 node_id, [[maybe_unused]] String const& text) { }
|
|
|
|
virtual void inspector_did_set_dom_node_tag([[maybe_unused]] i32 node_id, [[maybe_unused]] String const& tag) { }
|
2023-12-05 16:43:14 -05:00
|
|
|
virtual void inspector_did_add_dom_node_attributes([[maybe_unused]] i32 node_id, [[maybe_unused]] JS::NonnullGCPtr<DOM::NamedNodeMap> attributes) { }
|
2023-12-05 14:47:56 -05:00
|
|
|
virtual void inspector_did_replace_dom_node_attribute([[maybe_unused]] i32 node_id, [[maybe_unused]] String const& name, [[maybe_unused]] JS::NonnullGCPtr<DOM::NamedNodeMap> replacement_attributes) { }
|
|
|
|
virtual void inspector_did_request_dom_tree_context_menu([[maybe_unused]] i32 node_id, [[maybe_unused]] CSSPixelPoint position, [[maybe_unused]] String const& type, [[maybe_unused]] Optional<String> const& tag_or_attribute_name) { }
|
2023-11-30 19:27:32 -05:00
|
|
|
virtual void inspector_did_execute_console_script([[maybe_unused]] String const& script) { }
|
2023-11-23 12:22:23 -05:00
|
|
|
|
2021-04-15 10:43:29 -07:00
|
|
|
protected:
|
|
|
|
virtual ~PageClient() = default;
|
2020-06-08 20:31:49 +02:00
|
|
|
};
|
|
|
|
|
|
|
|
}
|
2023-06-16 10:51:38 -04:00
|
|
|
|
|
|
|
namespace IPC {
|
|
|
|
|
|
|
|
template<>
|
|
|
|
ErrorOr<void> encode(Encoder&, Web::Page::MediaContextMenu const&);
|
|
|
|
|
|
|
|
template<>
|
|
|
|
ErrorOr<Web::Page::MediaContextMenu> decode(Decoder&);
|
|
|
|
|
|
|
|
}
|