mirrors/serenity
1
0
Fork 0
mirror of https://github.com/SerenityOS/serenity.git synced 2025-01-24 02:12:09 -05:00
Code Issues Projects Releases Packages Wiki Activity
serenity/Libraries/LibWeb/OutOfProcessWebView.cpp

199 lines
7.2 KiB
C++
Raw Normal View History

WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
/*
* Copyright (c) 2020, Andreas Kling <kling@serenityos.org>
* All rights reserved.
*
* 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 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 HOLDER 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.
*/
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
#include "OutOfProcessWebView.h"
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
#include "WebContentClient.h"
#include <AK/SharedBuffer.h>
#include <LibGUI/Painter.h>
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
#include <LibGUI/ScrollBar.h>
LibWeb: Make WebContentView show the hover hand over links :^)
2020-07-06 23:32:12 +02:00
#include <LibGUI/Window.h>
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
#include <LibGfx/SystemTheme.h>
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
namespace Web {
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
OutOfProcessWebView::OutOfProcessWebView()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
LibWeb: Don't show unnecessary scrollbars in WebContentView This behaves a little weird right now, and will probably require more coordination between the widget and the WebContent process.
2020-07-06 22:02:38 +02:00
set_should_hide_unnecessary_scrollbars(true);
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
m_client = WebContentClient::construct(*this);
client().post_message(Messages::WebContentServer::UpdateSystemTheme(Gfx::current_system_theme_buffer_id()));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
OutOfProcessWebView::~OutOfProcessWebView()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::load(const URL& url)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
Browser+LibWeb: Pave the way for using WebContentView in Browser This commit sets everything up, but we still always instantiate a plain Web::PageView in Browser::Tab..
2020-07-06 21:46:37 +02:00
m_url = url;
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
client().post_message(Messages::WebContentServer::LoadURL(url));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::paint_event(GUI::PaintEvent& event)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
GUI::ScrollableWidget::paint_event(event);
WebContent: Give the WebContentView a proper GUI::Frame look :^)
2020-07-04 23:27:36 +02:00
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
GUI::Painter painter(*this);
WebContent: Give the WebContentView a proper GUI::Frame look :^)
2020-07-04 23:27:36 +02:00
painter.add_clip_rect(frame_inner_rect());
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
painter.add_clip_rect(event.rect());
WebContent: Give the WebContentView a proper GUI::Frame look :^)
2020-07-04 23:27:36 +02:00
painter.translate(frame_thickness(), frame_thickness());
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
ASSERT(m_front_bitmap);
painter.blit({ 0, 0 }, *m_front_bitmap, m_front_bitmap->rect());
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::resize_event(GUI::ResizeEvent& event)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
GUI::ScrollableWidget::resize_event(event);
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
m_front_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::RGB32, available_size())->to_bitmap_backed_by_shared_buffer();
m_front_bitmap->shared_buffer()->share_with(client().server_pid());
m_back_bitmap = Gfx::Bitmap::create(Gfx::BitmapFormat::RGB32, available_size())->to_bitmap_backed_by_shared_buffer();
m_back_bitmap->shared_buffer()->share_with(client().server_pid());
client().post_message(Messages::WebContentServer::SetViewportRect(Gfx::IntRect({ horizontal_scrollbar().value(), vertical_scrollbar().value() }, available_size())));
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
request_repaint();
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::keydown_event(GUI::KeyEvent& event)
LibWeb: Send key events to the WebContent process This makes contenteditable work in multi-process mode. :^)
2020-08-03 19:58:59 +02:00
{
client().post_message(Messages::WebContentServer::KeyDown(event.key(), event.modifiers(), event.code_point()));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousedown_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseDown(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mouseup_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseUp(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::mousemove_event(GUI::MouseEvent& event)
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
{
WebContent: Translate mouse event coordinates into content space The WebContentView widget now passes content space coordinates along with the various mouse events. :^)
2020-07-04 23:23:36 +02:00
client().post_message(Messages::WebContentServer::MouseMove(to_content_position(event.position()), event.button(), event.buttons(), event.modifiers()));
WebContent: Pass mouse events through to the WebContent process Just send the incoming mouse events across to the other side and let LibWeb deal with them. :^)
2020-06-17 18:05:08 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_paint(Badge<WebContentClient>, i32 shbuf_id)
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
if (m_back_bitmap->shbuf_id() == shbuf_id) {
swap(m_back_bitmap, m_front_bitmap);
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
update();
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
}
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_invalidate_content_rect(Badge<WebContentClient>, [[maybe_unused]] const Gfx::IntRect& content_rect)
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
{
WebContent: Put some debug spam behind an #ifdef
2020-07-04 23:19:12 +02:00
#ifdef DEBUG_SPAM
Libraries: Unbreak building with extra debug macros
2020-08-27 00:34:59 +02:00
dbg() << "server did invalidate content_rect: " << content_rect << ", current front_shbuf_id=" << m_front_bitmap->shbuf_id() << ", current back_shbuf_id=" << m_back_bitmap->shbuf_id();
WebContent: Put some debug spam behind an #ifdef
2020-07-04 23:19:12 +02:00
#endif
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_change_selection(Badge<WebContentClient>)
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
{
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_layout(Badge<WebContentClient>, const Gfx::IntSize& content_size)
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
{
set_content_size(content_size);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_change_title(Badge<WebContentClient>, const String& title)
WebContent: Plumb title changes over to the WebContentView WebContentView now fires its on_title_change hook, like Web::PageView. We use this in the WebView test app to update the window title. :^)
2020-07-04 23:40:17 +02:00
{
if (on_title_change)
on_title_change(title);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_scroll_into_view(Badge<WebContentClient>, const Gfx::IntRect& rect)
WebContent: Plumb scroll-into-view requests from server to client The WebContentView widget will now be able to react to scroll-into-view requests from the WebContent process.
2020-07-05 15:43:43 +02:00
{
scroll_into_view(rect, true, true);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_hover_link(Badge<WebContentClient>, const URL& url)
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
{
LibWeb: Use widget override cursors
2020-09-11 14:28:05 +02:00
set_override_cursor(Gfx::StandardCursor::Hand);
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
if (on_link_hover)
on_link_hover(url);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_unhover_link(Badge<WebContentClient>)
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
{
LibWeb: Use widget override cursors
2020-09-11 14:28:05 +02:00
set_override_cursor(Gfx::StandardCursor::None);
WebContent: Plumb hovered links from WebContent process over to widget Also add a little GUI::StatusBar to the demo app so we can see the hovered link URL's live. :^)
2020-07-05 16:59:20 +02:00
if (on_link_hover)
on_link_hover({});
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_click_link(Badge<WebContentClient>, const URL& url, const String& target, unsigned int modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
if (on_link_click)
on_link_click(url, target, modifiers);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_middle_click_link(Badge<WebContentClient>, const URL& url, const String& target, unsigned int modifiers)
WebContent: Plumb link clicks to the WebContentView :^) You can now react to links being clicked via the on_link_click hook.
2020-07-06 20:01:46 +02:00
{
if (on_link_middle_click)
on_link_middle_click(url, target, modifiers);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_start_loading(Badge<WebContentClient>, const URL& url)
LibWeb: Make the WebContentView::on_load_start hook actually work :^)
2020-07-06 21:58:16 +02:00
{
if (on_load_start)
on_load_start(url);
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_context_menu(Badge<WebContentClient>, const Gfx::IntPoint& content_position)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
if (on_context_menu_request)
on_context_menu_request(screen_relative_rect().location().translated(to_widget_position(content_position)));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::notify_server_did_request_link_context_menu(Badge<WebContentClient>, const Gfx::IntPoint& content_position, const URL& url, const String&, unsigned)
LibWeb: Make context menus work in WebContentView As usual, this was just a matter of plumbing the PageClient calls from the WebContent side over to the WebContentView side. :^)
2020-07-07 12:24:29 +02:00
{
if (on_link_context_menu_request)
on_link_context_menu_request(url, screen_relative_rect().location().translated(to_widget_position(content_position)));
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::did_scroll()
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
{
WebContent: Use available size for bitmap (#2701) After adding the scrolling feature, content available space reduced and thus the bitmap size was always larger, than the inner size. This lead to the horizontal scrollbar always beeing engaged.
2020-07-05 12:45:56 +02:00
client().post_message(Messages::WebContentServer::SetViewportRect(visible_content_rect()));
WebContent: Basic scrolling support! :^) The WebContentView widget now inherits from GUI::ScrollableWidget and will pass its scroll offset over to the WebContent process as it's changing. This is not super efficient and can get a bit laggy, but it will do fine as an initial scrolling implementation. Just like the single-process Web::PageView widget, WebContentView also paints scrolled content by translating the Gfx::Painter.
2020-07-04 23:19:32 +02:00
request_repaint();
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
void OutOfProcessWebView::request_repaint()
WebContent: Notify client when web content selection changes The WebContentView widgets reacts to this by requesting a repaint.
2020-07-04 20:57:57 +02:00
{
WebContent: Add double buffering to the WebContentView This removes the remaining flicker in the WebContentView widget and makes it feel pretty good to use it. :^) The increase in memory use is something we'll have to address in the future with more sophisticated solutions like tiling, etc.
2020-07-05 16:31:50 +02:00
client().post_message(Messages::WebContentServer::Paint(m_back_bitmap->rect().translated(horizontal_scrollbar().value(), vertical_scrollbar().value()), m_back_bitmap->shbuf_id()));
WebContent: Allow the WebContent process to trigger repaints After layout, we may want to repaint the page, so we now listen for the PageClient::page_did_invalidate() notification and use it to drive a client-side repaint. Note that an invalidation request from LibWeb makes a full roundtrip to the WebContent client and back since the client drives painting.
2020-06-17 18:00:18 +02:00
}
LibWeb: Rename WebContentView => OutOfProcessWebView
2020-08-17 16:20:47 +02:00
WebContentClient& OutOfProcessWebView::client()
WebContent: Start work on browser process separation :^) The "WebContent" service provides a very restricted instance of LibWeb running as an unprivileged user account. This will be used to implement process separation in Browser, among other things. This first cut of the service only spawns a single WebContent process when someone connects to /tmp/portal/webcontent. We will soon switch this over to spawning a new process for each connection. Since this feature is very immature, we'll be bringing it up inside of Demos/WebView as a separate demo program. Eventually this will become a reusable widget that anyone can embed and easily get out-of-process web content in their GUI. This is pretty, pretty cool! :^)
2020-06-17 17:31:42 +02:00
{
return *m_client;
}
LibWeb: Move OutOfProcessWebView into the Web namespace
2020-08-24 15:33:18 +04:30
}
Reference in a new issue Copy permalink