Diff
Modified: trunk/Source/WebCore/ChangeLog (260064 => 260065)
--- trunk/Source/WebCore/ChangeLog 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebCore/ChangeLog 2020-04-14 09:50:31 UTC (rev 260065)
@@ -1,3 +1,72 @@
+2020-04-14 Carlos Garcia Campos <[email protected]>
+
+ [GTK] Bring back support for rendering scrollbars using the system appearance
+ https://bugs.webkit.org/show_bug.cgi?id=209805
+
+ Reviewed by Michael Catanzaro.
+
+ Bring back ScrollbarThemeGtk, RenderThemeGadget and RenderThemeWidget (renamed as RenderThemeScrollbar),
+ including only the code needed to render the scrollbars. ScrollbarThemeGtk inherits from ScrollbarThemeAdwaita
+ that is used when system appearance is disabled.
+
+ * PlatformGTK.cmake:
+ * SourcesGTK.txt:
+ * platform/adwaita/ScrollbarThemeAdwaita.cpp:
+ * platform/adwaita/ScrollbarThemeAdwaita.h:
+ * platform/gtk/RenderThemeGadget.cpp: Added.
+ (WebCore::RenderThemeGadget::create):
+ (WebCore::createStyleContext):
+ (WebCore::appendElementToPath):
+ (WebCore::RenderThemeGadget::RenderThemeGadget):
+ (WebCore::RenderThemeGadget::marginBox const):
+ (WebCore::RenderThemeGadget::borderBox const):
+ (WebCore::RenderThemeGadget::paddingBox const):
+ (WebCore::RenderThemeGadget::contentsBox const):
+ (WebCore::RenderThemeGadget::color const):
+ (WebCore::RenderThemeGadget::backgroundColor const):
+ (WebCore::RenderThemeGadget::opacity const):
+ (WebCore::RenderThemeGadget::state const):
+ (WebCore::RenderThemeGadget::setState):
+ (WebCore::RenderThemeGadget::minimumSize const):
+ (WebCore::RenderThemeGadget::preferredSize const):
+ (WebCore::RenderThemeGadget::render):
+ (WebCore::RenderThemeBoxGadget::RenderThemeBoxGadget):
+ (WebCore::RenderThemeBoxGadget::preferredSize const):
+ (WebCore::RenderThemeScrollbarGadget::RenderThemeScrollbarGadget):
+ (WebCore::RenderThemeScrollbarGadget::renderStepper):
+ * platform/gtk/RenderThemeGadget.h: Added.
+ (WebCore::RenderThemeGadget::context const):
+ * platform/gtk/RenderThemeScrollbar.cpp: Added.
+ (WebCore::widgetMap):
+ (WebCore::RenderThemeScrollbar::getOrCreate):
+ (WebCore::RenderThemeScrollbar::clearCache):
+ (WebCore::RenderThemeScrollbar::RenderThemeScrollbar):
+ (WebCore::RenderThemeScrollbar::stepper):
+ * platform/gtk/RenderThemeScrollbar.h: Added.
+ (WebCore::RenderThemeScrollbar::scrollbar const):
+ (WebCore::RenderThemeScrollbar::contents const):
+ (WebCore::RenderThemeScrollbar::slider const):
+ (WebCore::RenderThemeScrollbar::trough const):
+ * platform/gtk/ScrollbarThemeGtk.cpp: Added.
+ (WebCore::ScrollbarTheme::nativeTheme):
+ (WebCore::themeChangedCallback):
+ (WebCore::ScrollbarThemeGtk::ScrollbarThemeGtk):
+ (WebCore::ScrollbarThemeGtk::setUseSystemAppearance):
+ (WebCore::ScrollbarThemeGtk::themeChanged):
+ (WebCore::ScrollbarThemeGtk::updateThemeProperties):
+ (WebCore::ScrollbarThemeGtk::hasButtons):
+ (WebCore::scrollbarPartStateFlags):
+ (WebCore::widgetTypeForScrollbar):
+ (WebCore::contentsRectangle):
+ (WebCore::ScrollbarThemeGtk::trackRect):
+ (WebCore::ScrollbarThemeGtk::backButtonRect):
+ (WebCore::ScrollbarThemeGtk::forwardButtonRect):
+ (WebCore::ScrollbarThemeGtk::paint):
+ (WebCore::ScrollbarThemeGtk::handleMousePressEvent):
+ (WebCore::ScrollbarThemeGtk::scrollbarThickness):
+ (WebCore::ScrollbarThemeGtk::minimumThumbLength):
+ * platform/gtk/ScrollbarThemeGtk.h: Added.
+
2020-04-14 Youenn Fablet <[email protected]>
Add a timer to AVVideoCaptureSource to verify reception of frames
Modified: trunk/Source/WebCore/PlatformGTK.cmake (260064 => 260065)
--- trunk/Source/WebCore/PlatformGTK.cmake 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebCore/PlatformGTK.cmake 2020-04-14 09:50:31 UTC (rev 260065)
@@ -50,6 +50,8 @@
endif ()
list(APPEND WebCore_PRIVATE_FRAMEWORK_HEADERS
+ platform/adwaita/ScrollbarThemeAdwaita.h
+
platform/graphics/x11/PlatformDisplayX11.h
platform/graphics/x11/XErrorTrapper.h
platform/graphics/x11/XUniquePtr.h
@@ -59,6 +61,7 @@
platform/gtk/GUniquePtrGtk.h
platform/gtk/GtkUtilities.h
platform/gtk/PasteboardHelper.h
+ platform/gtk/ScrollbarThemeGtk.h
platform/gtk/SelectionData.h
platform/text/enchant/TextCheckerEnchant.h
Modified: trunk/Source/WebCore/SourcesGTK.txt (260064 => 260065)
--- trunk/Source/WebCore/SourcesGTK.txt 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebCore/SourcesGTK.txt 2020-04-14 09:50:31 UTC (rev 260065)
@@ -115,6 +115,9 @@
platform/gtk/PlatformPasteboardGtk.cpp
platform/gtk/PlatformScreenGtk.cpp
platform/gtk/PlatformWheelEventGtk.cpp
+platform/gtk/RenderThemeGadget.cpp
+platform/gtk/RenderThemeScrollbar.cpp
+platform/gtk/ScrollbarThemeGtk.cpp
platform/gtk/SelectionData.cpp
platform/gtk/ThemeGtk.cpp
platform/gtk/WidgetGtk.cpp
Modified: trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.cpp (260064 => 260065)
--- trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -220,10 +220,12 @@
return ScrollbarButtonPressAction::None;
}
+#if !PLATFORM(GTK) || USE(GTK4)
ScrollbarTheme& ScrollbarTheme::nativeTheme()
{
static ScrollbarThemeAdwaita theme;
return theme;
}
+#endif
} // namespace WebCore
Modified: trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.h (260064 => 260065)
--- trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebCore/platform/adwaita/ScrollbarThemeAdwaita.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -29,12 +29,12 @@
namespace WebCore {
-class ScrollbarThemeAdwaita final : public ScrollbarThemeComposite {
+class ScrollbarThemeAdwaita : public ScrollbarThemeComposite {
public:
ScrollbarThemeAdwaita() = default;
virtual ~ScrollbarThemeAdwaita() = default;
-private:
+protected:
bool usesOverlayScrollbars() const override;
bool invalidateOnMouseEnterExit() override { return usesOverlayScrollbars(); }
Added: trunk/Source/WebCore/platform/gtk/RenderThemeGadget.cpp (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/RenderThemeGadget.cpp (rev 0)
+++ trunk/Source/WebCore/platform/gtk/RenderThemeGadget.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,257 @@
+/*
+ * Copyright (C) 2016 Igalia S.L.
+ *
+ * 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 "config.h"
+#include "RenderThemeGadget.h"
+
+#if !USE(GTK4)
+
+#include "FloatRect.h"
+#include "GRefPtrGtk.h"
+
+namespace WebCore {
+
+std::unique_ptr<RenderThemeGadget> RenderThemeGadget::create(const RenderThemeGadget::Info& info, RenderThemeGadget* parent, const Vector<RenderThemeGadget::Info> siblings, unsigned position)
+{
+ switch (info.type) {
+ case RenderThemeGadget::Type::Generic:
+ return makeUnique<RenderThemeGadget>(info, parent, siblings, position);
+ case RenderThemeGadget::Type::Scrollbar:
+ return makeUnique<RenderThemeScrollbarGadget>(info, parent, siblings, position);
+ }
+
+ ASSERT_NOT_REACHED();
+ return nullptr;
+}
+
+static GRefPtr<GtkStyleContext> createStyleContext(GtkWidgetPath* path, GtkStyleContext* parent)
+{
+ GRefPtr<GtkStyleContext> context = adoptGRef(gtk_style_context_new());
+ gtk_style_context_set_path(context.get(), path);
+ gtk_style_context_set_parent(context.get(), parent);
+ return context;
+}
+
+static void appendElementToPath(GtkWidgetPath* path, const RenderThemeGadget::Info& info)
+{
+ // Scrollbars need to use its GType to be able to get non-CSS style properties.
+ gtk_widget_path_append_type(path, info.type == RenderThemeGadget::Type::Scrollbar ? GTK_TYPE_SCROLLBAR : G_TYPE_NONE);
+ gtk_widget_path_iter_set_object_name(path, -1, info.name);
+ for (const auto* className : info.classList)
+ gtk_widget_path_iter_add_class(path, -1, className);
+}
+
+RenderThemeGadget::RenderThemeGadget(const RenderThemeGadget::Info& info, RenderThemeGadget* parent, const Vector<RenderThemeGadget::Info> siblings, unsigned position)
+{
+ GRefPtr<GtkWidgetPath> path = parent ? adoptGRef(gtk_widget_path_copy(gtk_style_context_get_path(parent->context()))) : adoptGRef(gtk_widget_path_new());
+ if (!siblings.isEmpty()) {
+ GRefPtr<GtkWidgetPath> siblingsPath = adoptGRef(gtk_widget_path_new());
+ for (const auto& siblingInfo : siblings)
+ appendElementToPath(siblingsPath.get(), siblingInfo);
+ gtk_widget_path_append_with_siblings(path.get(), siblingsPath.get(), position);
+ } else
+ appendElementToPath(path.get(), info);
+ m_context = createStyleContext(path.get(), parent ? parent->context() : nullptr);
+}
+
+RenderThemeGadget::~RenderThemeGadget() = default;
+
+GtkBorder RenderThemeGadget::marginBox() const
+{
+ GtkBorder returnValue;
+ gtk_style_context_get_margin(m_context.get(), gtk_style_context_get_state(m_context.get()), &returnValue);
+ return returnValue;
+}
+
+GtkBorder RenderThemeGadget::borderBox() const
+{
+ GtkBorder returnValue;
+ gtk_style_context_get_border(m_context.get(), gtk_style_context_get_state(m_context.get()), &returnValue);
+ return returnValue;
+}
+
+GtkBorder RenderThemeGadget::paddingBox() const
+{
+ GtkBorder returnValue;
+ gtk_style_context_get_padding(m_context.get(), gtk_style_context_get_state(m_context.get()), &returnValue);
+ return returnValue;
+}
+
+GtkBorder RenderThemeGadget::contentsBox() const
+{
+ auto margin = marginBox();
+ auto border = borderBox();
+ auto padding = paddingBox();
+ padding.left += margin.left + border.left;
+ padding.right += margin.right + border.right;
+ padding.top += margin.top + border.top;
+ padding.bottom += margin.bottom + border.bottom;
+ return padding;
+}
+
+Color RenderThemeGadget::color() const
+{
+ GdkRGBA returnValue;
+ gtk_style_context_get_color(m_context.get(), gtk_style_context_get_state(m_context.get()), &returnValue);
+ return returnValue;
+}
+
+Color RenderThemeGadget::backgroundColor() const
+{
+ GdkRGBA returnValue;
+ gtk_style_context_get_background_color(m_context.get(), gtk_style_context_get_state(m_context.get()), &returnValue);
+ return returnValue;
+}
+
+double RenderThemeGadget::opacity() const
+{
+ double returnValue;
+ gtk_style_context_get(m_context.get(), gtk_style_context_get_state(m_context.get()), "opacity", &returnValue, nullptr);
+ return returnValue;
+}
+
+GtkStateFlags RenderThemeGadget::state() const
+{
+ return gtk_style_context_get_state(m_context.get());
+}
+
+void RenderThemeGadget::setState(GtkStateFlags state)
+{
+ gtk_style_context_set_state(m_context.get(), state);
+}
+
+IntSize RenderThemeGadget::minimumSize() const
+{
+ int width, height;
+ gtk_style_context_get(m_context.get(), gtk_style_context_get_state(m_context.get()), "min-width", &width, "min-height", &height, nullptr);
+ return IntSize(width, height);
+}
+
+IntSize RenderThemeGadget::preferredSize() const
+{
+ auto margin = marginBox();
+ auto border = borderBox();
+ auto padding = paddingBox();
+ auto minSize = minimumSize();
+ minSize.expand(margin.left + margin.right + border.left + border.right + padding.left + padding.right,
+ margin.top + margin.bottom + border.top + border.bottom + padding.top + padding.bottom);
+ return minSize;
+}
+
+bool RenderThemeGadget::render(cairo_t* cr, const FloatRect& paintRect, FloatRect* contentsRect)
+{
+ FloatRect rect = paintRect;
+
+ auto margin = marginBox();
+ rect.move(margin.left, margin.top);
+ rect.contract(margin.left + margin.right, margin.top + margin.bottom);
+
+ auto minSize = minimumSize();
+ rect.setWidth(std::max<float>(rect.width(), minSize.width()));
+ rect.setHeight(std::max<float>(rect.height(), minSize.height()));
+
+ gtk_render_background(m_context.get(), cr, rect.x(), rect.y(), rect.width(), rect.height());
+ gtk_render_frame(m_context.get(), cr, rect.x(), rect.y(), rect.width(), rect.height());
+
+ if (contentsRect) {
+ auto border = borderBox();
+ auto padding = paddingBox();
+ *contentsRect = rect;
+ contentsRect->move(border.left + padding.left, border.top + padding.top);
+ contentsRect->contract(border.left + border.right + padding.left + padding.right, border.top + border.bottom + padding.top + padding.bottom);
+ }
+
+ return true;
+}
+
+RenderThemeBoxGadget::RenderThemeBoxGadget(const RenderThemeGadget::Info& info, GtkOrientation orientation, const Vector<RenderThemeGadget::Info> children, RenderThemeGadget* parent)
+ : RenderThemeGadget(info, parent, Vector<RenderThemeGadget::Info>(), 0)
+ , m_orientation(orientation)
+{
+ m_children.reserveCapacity(children.size());
+ unsigned index = 0;
+ for (const auto& childInfo : children)
+ m_children.uncheckedAppend(RenderThemeGadget::create(childInfo, this, children, index++));
+}
+
+IntSize RenderThemeBoxGadget::preferredSize() const
+{
+ IntSize childrenSize;
+ for (const auto& child : m_children) {
+ IntSize childSize = child->preferredSize();
+ switch (m_orientation) {
+ case GTK_ORIENTATION_HORIZONTAL:
+ childrenSize.setWidth(childrenSize.width() + childSize.width());
+ childrenSize.setHeight(std::max(childrenSize.height(), childSize.height()));
+ break;
+ case GTK_ORIENTATION_VERTICAL:
+ childrenSize.setWidth(std::max(childrenSize.width(), childSize.width()));
+ childrenSize.setHeight(childrenSize.height() + childSize.height());
+ break;
+ }
+ }
+ return RenderThemeGadget::preferredSize().expandedTo(childrenSize);
+}
+
+RenderThemeScrollbarGadget::RenderThemeScrollbarGadget(const RenderThemeGadget::Info& info, RenderThemeGadget* parent, const Vector<RenderThemeGadget::Info> siblings, unsigned position)
+ : RenderThemeGadget(info, parent, siblings, position)
+{
+ gboolean hasBackward, hasForward, hasSecondaryBackward, hasSecondaryForward;
+ gtk_style_context_get_style(m_context.get(), "has-backward-stepper", &hasBackward, "has-forward-stepper", &hasForward,
+ "has-secondary-backward-stepper", &hasSecondaryBackward, "has-secondary-forward-stepper", &hasSecondaryForward, nullptr);
+ if (hasBackward)
+ m_steppers.add(Steppers::Backward);
+ if (hasForward)
+ m_steppers.add(Steppers::Forward);
+ if (hasSecondaryBackward)
+ m_steppers.add(Steppers::SecondaryBackward);
+ if (hasSecondaryForward)
+ m_steppers.add(Steppers::SecondaryForward);
+}
+
+void RenderThemeScrollbarGadget::renderStepper(cairo_t* cr, const FloatRect& paintRect, RenderThemeGadget* stepperGadget, GtkOrientation orientation, Steppers stepper)
+{
+ FloatRect contentsRect;
+ stepperGadget->render(cr, paintRect, &contentsRect);
+ double angle;
+ switch (stepper) {
+ case Steppers::Backward:
+ case Steppers::SecondaryBackward:
+ angle = orientation == GTK_ORIENTATION_VERTICAL ? 0 : 3 * (G_PI / 2);
+ break;
+ case Steppers::Forward:
+ case Steppers::SecondaryForward:
+ angle = orientation == GTK_ORIENTATION_VERTICAL ? G_PI / 2 : G_PI;
+ break;
+ }
+
+ int stepperSize = std::max(contentsRect.width(), contentsRect.height());
+ gtk_render_arrow(stepperGadget->context(), cr, angle, contentsRect.x() + (contentsRect.width() - stepperSize) / 2,
+ contentsRect.y() + (contentsRect.height() - stepperSize) / 2, stepperSize);
+}
+
+} // namespace WebCore
+
+#endif // !USE(GTK4)
Added: trunk/Source/WebCore/platform/gtk/RenderThemeGadget.h (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/RenderThemeGadget.h (rev 0)
+++ trunk/Source/WebCore/platform/gtk/RenderThemeGadget.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,115 @@
+/*
+ * Copyright (C) 2016 Igalia S.L.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#if !USE(GTK4)
+
+#include "Color.h"
+#include "IntSize.h"
+#include <gtk/gtk.h>
+#include <wtf/OptionSet.h>
+#include <wtf/Vector.h>
+#include <wtf/glib/GRefPtr.h>
+#include <wtf/text/CString.h>
+
+namespace WebCore {
+class FloatRect;
+
+class RenderThemeGadget {
+ WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(RenderThemeGadget);
+public:
+ enum class Type {
+ Generic,
+ Scrollbar,
+ };
+
+ struct Info {
+ Type type;
+ const char* name;
+ Vector<const char*> classList;
+ };
+
+ static std::unique_ptr<RenderThemeGadget> create(const Info&, RenderThemeGadget* parent = nullptr, const Vector<RenderThemeGadget::Info> siblings = Vector<RenderThemeGadget::Info>(), unsigned position = 0);
+ RenderThemeGadget(const Info&, RenderThemeGadget* parent, const Vector<RenderThemeGadget::Info> siblings, unsigned position);
+ virtual ~RenderThemeGadget();
+
+ virtual IntSize preferredSize() const;
+ virtual bool render(cairo_t*, const FloatRect&, FloatRect* = nullptr);
+ virtual IntSize minimumSize() const;
+
+ GtkBorder contentsBox() const;
+ Color color() const;
+ Color backgroundColor() const;
+ double opacity() const;
+
+ GtkStyleContext* context() const { return m_context.get(); }
+
+ GtkStateFlags state() const;
+ void setState(GtkStateFlags);
+
+protected:
+ GtkBorder marginBox() const;
+ GtkBorder borderBox() const;
+ GtkBorder paddingBox() const;
+
+ GRefPtr<GtkStyleContext> m_context;
+};
+
+class RenderThemeBoxGadget final : public RenderThemeGadget {
+public:
+ RenderThemeBoxGadget(const RenderThemeGadget::Info&, GtkOrientation, const Vector<RenderThemeGadget::Info> children, RenderThemeGadget* parent = nullptr);
+
+ IntSize preferredSize() const override;
+
+ RenderThemeGadget* child(unsigned index) const { return m_children[index].get(); }
+
+private:
+ Vector<std::unique_ptr<RenderThemeGadget>> m_children;
+ GtkOrientation m_orientation { GTK_ORIENTATION_HORIZONTAL };
+};
+
+class RenderThemeScrollbarGadget final : public RenderThemeGadget {
+public:
+ RenderThemeScrollbarGadget(const Info&, RenderThemeGadget* parent, const Vector<RenderThemeGadget::Info> siblings, unsigned position);
+
+ enum class Steppers {
+ Backward = 1 << 0,
+ Forward = 1 << 1,
+ SecondaryBackward = 1 << 2,
+ SecondaryForward = 1 << 3
+ };
+ OptionSet<Steppers> steppers() const { return m_steppers; };
+
+ void renderStepper(cairo_t*, const FloatRect&, RenderThemeGadget*, GtkOrientation, Steppers);
+
+private:
+ OptionSet<Steppers> m_steppers;
+};
+
+} // namespace WebCore
+
+#endif // !USE(GTK4)
Added: trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.cpp (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.cpp (rev 0)
+++ trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,138 @@
+/*
+ * Copyright (C) 2017 Igalia S.L.
+ *
+ * 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 "config.h"
+#include "RenderThemeScrollbar.h"
+
+#if !USE(GTK4)
+
+#include <wtf/HashMap.h>
+#include <wtf/NeverDestroyed.h>
+
+namespace WebCore {
+
+static HashMap<unsigned, std::unique_ptr<RenderThemeScrollbar>>& widgetMap()
+{
+ static NeverDestroyed<HashMap<unsigned, std::unique_ptr<RenderThemeScrollbar>>> map;
+ return map;
+}
+
+RenderThemeScrollbar& RenderThemeScrollbar::getOrCreate(Type widgetType)
+{
+ auto addResult = widgetMap().ensure(static_cast<unsigned>(widgetType), [widgetType]() -> std::unique_ptr<RenderThemeScrollbar> {
+ switch (widgetType) {
+ case RenderThemeScrollbar::Type::VerticalScrollbarRight:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_VERTICAL, RenderThemeScrollbar::Mode::Full);
+ case RenderThemeScrollbar::Type::VerticalScrollbarLeft:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_VERTICAL, RenderThemeScrollbar::Mode::Full, RenderThemeScrollbar::VerticalPosition::Left);
+ case RenderThemeScrollbar::Type::HorizontalScrollbar:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbar::Mode::Full);
+ case RenderThemeScrollbar::Type::VerticalScrollIndicatorRight:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_VERTICAL, RenderThemeScrollbar::Mode::Indicator);
+ case RenderThemeScrollbar::Type::VerticalScrollIndicatorLeft:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_VERTICAL, RenderThemeScrollbar::Mode::Indicator, RenderThemeScrollbar::VerticalPosition::Left);
+ case RenderThemeScrollbar::Type::HorizontalScrollIndicator:
+ return makeUnique<RenderThemeScrollbar>(GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbar::Mode::Indicator);
+ }
+ ASSERT_NOT_REACHED();
+ return nullptr;
+ });
+ return *addResult.iterator->value;
+}
+
+void RenderThemeScrollbar::clearCache()
+{
+ widgetMap().clear();
+}
+
+RenderThemeScrollbar::RenderThemeScrollbar(GtkOrientation orientation, Mode mode, VerticalPosition verticalPosition)
+{
+ RenderThemeGadget::Info info = { RenderThemeGadget::Type::Scrollbar, "scrollbar", { } };
+ if (orientation == GTK_ORIENTATION_VERTICAL) {
+ info.classList.append("vertical");
+ info.classList.append(verticalPosition == VerticalPosition::Right ? "right" : "left");
+ } else {
+ info.classList.append("horizontal");
+ info.classList.append("bottom");
+ }
+ static bool usesOverlayScrollbars = g_strcmp0(g_getenv("GTK_OVERLAY_SCROLLING"), "0");
+ if (usesOverlayScrollbars)
+ info.classList.append("overlay-indicator");
+ if (mode == Mode::Full)
+ info.classList.append("hovering");
+ m_scrollbar = RenderThemeGadget::create(info);
+
+ Vector<RenderThemeGadget::Info> children;
+ auto steppers = static_cast<RenderThemeScrollbarGadget*>(m_scrollbar.get())->steppers();
+ if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Backward)) {
+ m_steppersPosition[0] = children.size();
+ children.append({ RenderThemeGadget::Type::Generic, "button", { "up" } });
+ }
+ if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+ m_steppersPosition[1] = children.size();
+ children.append({ RenderThemeGadget::Type::Generic, "button", { "down" } });
+ }
+ m_troughPosition = children.size();
+ children.append({ RenderThemeGadget::Type::Generic, "trough", { } });
+ if (steppers.contains(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
+ m_steppersPosition[2] = children.size();
+ children.append({ RenderThemeGadget::Type::Generic, "button", { "up" } });
+ }
+ if (steppers.contains(RenderThemeScrollbarGadget::Steppers::Forward)) {
+ m_steppersPosition[3] = children.size();
+ children.append({ RenderThemeGadget::Type::Generic, "button", { "down" } });
+ }
+ info.type = RenderThemeGadget::Type::Generic;
+ info.name = "contents";
+ info.classList.clear();
+ m_contents = makeUnique<RenderThemeBoxGadget>(info, GTK_ORIENTATION_VERTICAL, children, m_scrollbar.get());
+ info.name = "slider";
+ m_slider = RenderThemeGadget::create(info, m_contents->child(m_troughPosition));
+}
+
+RenderThemeGadget* RenderThemeScrollbar::stepper(RenderThemeScrollbarGadget::Steppers scrollbarStepper)
+{
+ if (!static_cast<RenderThemeScrollbarGadget*>(m_scrollbar.get())->steppers().contains(scrollbarStepper))
+ return nullptr;
+
+ switch (scrollbarStepper) {
+ case RenderThemeScrollbarGadget::Steppers::Backward:
+ return m_contents->child(m_steppersPosition[0]);
+ case RenderThemeScrollbarGadget::Steppers::SecondaryForward:
+ return m_contents->child(m_steppersPosition[1]);
+ case RenderThemeScrollbarGadget::Steppers::SecondaryBackward:
+ return m_contents->child(m_steppersPosition[2]);
+ case RenderThemeScrollbarGadget::Steppers::Forward:
+ return m_contents->child(m_steppersPosition[3]);
+ default:
+ break;
+ }
+
+ return nullptr;
+}
+
+} // namepsace WebCore
+
+#endif // !USE(GTK4)
Added: trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.h (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.h (rev 0)
+++ trunk/Source/WebCore/platform/gtk/RenderThemeScrollbar.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2017 Igalia S.L.
+ *
+ * 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.
+ */
+
+#pragma once
+
+#if !USE(GTK4)
+
+#include "RenderThemeGadget.h"
+#include <gtk/gtk.h>
+
+namespace WebCore {
+
+class RenderThemeScrollbar {
+ WTF_MAKE_FAST_ALLOCATED;
+ WTF_MAKE_NONCOPYABLE(RenderThemeScrollbar);
+public:
+ enum class Type {
+ VerticalScrollbarRight = 1,
+ VerticalScrollbarLeft,
+ HorizontalScrollbar,
+ VerticalScrollIndicatorRight,
+ VerticalScrollIndicatorLeft,
+ HorizontalScrollIndicator,
+ };
+ static RenderThemeScrollbar& getOrCreate(Type);
+ static void clearCache();
+
+ enum class Mode { Full, Indicator };
+ enum class VerticalPosition { Right, Left };
+ RenderThemeScrollbar(GtkOrientation, Mode, VerticalPosition = VerticalPosition::Right);
+ ~RenderThemeScrollbar() = default;
+
+ RenderThemeGadget& scrollbar() const { return *m_scrollbar; }
+ RenderThemeGadget& contents() const { return *m_contents; }
+ RenderThemeGadget& slider() const { return *m_slider; }
+ RenderThemeGadget& trough() const { return *m_contents->child(m_troughPosition); }
+ RenderThemeGadget* stepper(RenderThemeScrollbarGadget::Steppers);
+
+private:
+ std::unique_ptr<RenderThemeGadget> m_scrollbar;
+ std::unique_ptr<RenderThemeBoxGadget> m_contents;
+ std::unique_ptr<RenderThemeGadget> m_slider;
+ unsigned m_troughPosition;
+ unsigned m_steppersPosition[4];
+};
+
+} // namespace WebCore
+
+#endif // !USE(GTK4)
Added: trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp (rev 0)
+++ trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,552 @@
+/*
+ * Copyright (C) 2016 Igalia S.L.
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 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 "config.h"
+#include "ScrollbarThemeGtk.h"
+
+#if !USE(GTK4)
+
+#include "GRefPtrGtk.h"
+#include "PlatformContextCairo.h"
+#include "PlatformMouseEvent.h"
+#include "RenderThemeScrollbar.h"
+#include "ScrollView.h"
+#include "Scrollbar.h"
+#include <cstdlib>
+#include <gtk/gtk.h>
+
+namespace WebCore {
+
+ScrollbarTheme& ScrollbarTheme::nativeTheme()
+{
+ static ScrollbarThemeGtk theme;
+ return theme;
+}
+
+ScrollbarThemeGtk::~ScrollbarThemeGtk() = default;
+
+static void themeChangedCallback()
+{
+ ScrollbarTheme::theme().themeChanged();
+}
+
+ScrollbarThemeGtk::ScrollbarThemeGtk()
+{
+ static bool themeMonitorInitialized = false;
+ if (!themeMonitorInitialized) {
+ g_signal_connect(gtk_settings_get_default(), "notify::gtk-theme-name", G_CALLBACK(themeChangedCallback), nullptr);
+ themeMonitorInitialized = true;
+ updateThemeProperties();
+ }
+}
+
+void ScrollbarThemeGtk::setUseSystemAppearance(bool useSystemAppearance)
+{
+ if (m_useSystemAppearance == useSystemAppearance)
+ return;
+
+ m_useSystemAppearance = useSystemAppearance;
+
+ RenderThemeScrollbar::clearCache();
+ if (m_useSystemAppearance)
+ updateThemeProperties();
+}
+
+void ScrollbarThemeGtk::themeChanged()
+{
+ if (!m_useSystemAppearance)
+ return;
+
+ RenderThemeScrollbar::clearCache();
+ updateThemeProperties();
+}
+
+void ScrollbarThemeGtk::updateThemeProperties()
+{
+ RELEASE_ASSERT(m_useSystemAppearance);
+ auto& scrollbar = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(RenderThemeScrollbar::Type::VerticalScrollbarRight));
+ m_hasBackButtonStartPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+ m_hasForwardButtonEndPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+ m_hasBackButtonEndPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+ m_hasForwardButtonStartPart = scrollbar.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward);
+}
+
+bool ScrollbarThemeGtk::hasButtons(Scrollbar& scrollbar)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::hasButtons(scrollbar);
+
+ return scrollbar.enabled() && (m_hasBackButtonStartPart || m_hasForwardButtonEndPart || m_hasBackButtonEndPart || m_hasForwardButtonStartPart);
+}
+
+static GtkStateFlags scrollbarPartStateFlags(Scrollbar& scrollbar, ScrollbarPart part, bool painting = false)
+{
+ unsigned stateFlags = 0;
+ switch (part) {
+ case AllParts:
+ if (!painting || scrollbar.hoveredPart() != NoPart)
+ stateFlags |= GTK_STATE_FLAG_PRELIGHT;
+ break;
+ case BackTrackPart:
+ case ForwardTrackPart:
+ if (scrollbar.hoveredPart() == BackTrackPart || scrollbar.hoveredPart() == ForwardTrackPart)
+ stateFlags |= GTK_STATE_FLAG_PRELIGHT;
+ if (scrollbar.pressedPart() == BackTrackPart || scrollbar.pressedPart() == ForwardTrackPart)
+ stateFlags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ case BackButtonStartPart:
+ case ForwardButtonStartPart:
+ case BackButtonEndPart:
+ case ForwardButtonEndPart:
+ if (((part == BackButtonStartPart || part == BackButtonEndPart) && !scrollbar.currentPos())
+ || ((part == ForwardButtonEndPart || part == ForwardButtonStartPart) && scrollbar.currentPos() == scrollbar.maximum())) {
+ stateFlags |= GTK_STATE_FLAG_INSENSITIVE;
+ break;
+ }
+ FALLTHROUGH;
+ default:
+ if (scrollbar.hoveredPart() == part)
+ stateFlags |= GTK_STATE_FLAG_PRELIGHT;
+
+ if (scrollbar.pressedPart() == part)
+ stateFlags |= GTK_STATE_FLAG_ACTIVE;
+ break;
+ }
+
+ return static_cast<GtkStateFlags>(stateFlags);
+}
+
+static RenderThemeScrollbar::Type widgetTypeForScrollbar(Scrollbar& scrollbar, GtkStateFlags scrollbarState)
+{
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ if (scrollbar.scrollableArea().shouldPlaceBlockDirectionScrollbarOnLeft())
+ return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeScrollbar::Type::VerticalScrollbarLeft : RenderThemeScrollbar::Type::VerticalScrollIndicatorLeft;
+ return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeScrollbar::Type::VerticalScrollbarRight : RenderThemeScrollbar::Type::VerticalScrollIndicatorRight;
+ }
+ return scrollbarState & GTK_STATE_FLAG_PRELIGHT ? RenderThemeScrollbar::Type::HorizontalScrollbar : RenderThemeScrollbar::Type::HorizontalScrollIndicator;
+}
+
+static IntRect contentsRectangle(Scrollbar& scrollbar, RenderThemeScrollbar& scrollbarWidget)
+{
+ GtkBorder scrollbarContentsBox = scrollbarWidget.scrollbar().contentsBox();
+ GtkBorder contentsContentsBox = scrollbarWidget.contents().contentsBox();
+ GtkBorder padding;
+ padding.left = scrollbarContentsBox.left + contentsContentsBox.left;
+ padding.right = scrollbarContentsBox.right + contentsContentsBox.right;
+ padding.top = scrollbarContentsBox.top + contentsContentsBox.top;
+ padding.bottom = scrollbarContentsBox.bottom + contentsContentsBox.bottom;
+ IntRect contentsRect = scrollbar.frameRect();
+ contentsRect.move(padding.left, padding.top);
+ contentsRect.contract(padding.left + padding.right, padding.top + padding.bottom);
+ return contentsRect;
+}
+
+IntRect ScrollbarThemeGtk::trackRect(Scrollbar& scrollbar, bool painting)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::trackRect(scrollbar, painting);
+
+ auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+ scrollbarWidget.scrollbar().setState(scrollbarState);
+
+ IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+ if (auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward)) {
+ backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+ IntSize stepperSize = backwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ rect.move(0, stepperSize.height());
+ rect.contract(0, stepperSize.height());
+ } else {
+ rect.move(stepperSize.width(), 0);
+ rect.contract(stepperSize.width(), 0);
+ }
+ }
+ if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+ secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+ IntSize stepperSize = secondaryForwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ rect.move(0, stepperSize.height());
+ rect.contract(0, stepperSize.height());
+ } else {
+ rect.move(stepperSize.width(), 0);
+ rect.contract(stepperSize.width(), 0);
+ }
+ }
+ if (auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
+ secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
+ if (scrollbar.orientation() == VerticalScrollbar)
+ rect.contract(0, secondaryBackwardStepper->preferredSize().height());
+ else
+ rect.contract(secondaryBackwardStepper->preferredSize().width(), 0);
+ }
+ if (auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward)) {
+ forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+ if (scrollbar.orientation() == VerticalScrollbar)
+ rect.contract(0, forwardStepper->preferredSize().height());
+ else
+ rect.contract(forwardStepper->preferredSize().width(), 0);
+ }
+
+ if (scrollbar.orientation() == VerticalScrollbar)
+ return scrollbar.height() < rect.height() ? IntRect() : rect;
+
+ return scrollbar.width() < rect.width() ? IntRect() : rect;
+}
+
+IntRect ScrollbarThemeGtk::backButtonRect(Scrollbar& scrollbar, ScrollbarPart part, bool painting)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::backButtonRect(scrollbar, part, painting);
+
+ ASSERT(part == BackButtonStartPart || part == BackButtonEndPart);
+ if ((part == BackButtonEndPart && !m_hasBackButtonEndPart) || (part == BackButtonStartPart && !m_hasBackButtonStartPart))
+ return IntRect();
+
+ auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+ scrollbarWidget.scrollbar().setState(scrollbarState);
+
+ IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+ if (part == BackButtonStartPart) {
+ auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+ ASSERT(backwardStepper);
+ backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+ return IntRect(rect.location(), backwardStepper->preferredSize());
+ }
+
+ if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+ secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+ IntSize preferredSize = secondaryForwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ rect.move(0, preferredSize.height());
+ rect.contract(0, preferredSize.height());
+ } else {
+ rect.move(preferredSize.width(), 0);
+ rect.contract(0, preferredSize.width());
+ }
+ }
+
+ if (auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward)) {
+ secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
+ if (scrollbar.orientation() == VerticalScrollbar)
+ rect.contract(0, secondaryBackwardStepper->preferredSize().height());
+ else
+ rect.contract(secondaryBackwardStepper->preferredSize().width(), 0);
+ }
+
+ auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+ ASSERT(forwardStepper);
+ forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+ IntSize preferredSize = forwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar)
+ rect.move(0, rect.height() - preferredSize.height());
+ else
+ rect.move(rect.width() - preferredSize.width(), 0);
+
+ return IntRect(rect.location(), preferredSize);
+}
+
+IntRect ScrollbarThemeGtk::forwardButtonRect(Scrollbar& scrollbar, ScrollbarPart part, bool painting)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::forwardButtonRect(scrollbar, part, painting);
+
+ ASSERT(part == ForwardButtonStartPart || part == ForwardButtonEndPart);
+ if ((part == ForwardButtonStartPart && !m_hasForwardButtonStartPart) || (part == ForwardButtonEndPart && !m_hasForwardButtonEndPart))
+ return IntRect();
+
+ auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts);
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+ scrollbarWidget.scrollbar().setState(scrollbarState);
+
+ IntRect rect = contentsRectangle(scrollbar, scrollbarWidget);
+ if (auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward)) {
+ backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+ IntSize preferredSize = backwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ rect.move(0, preferredSize.height());
+ rect.contract(0, preferredSize.height());
+ } else {
+ rect.move(preferredSize.width(), 0);
+ rect.contract(preferredSize.width(), 0);
+ }
+ }
+
+ if (auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward)) {
+ secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+ IntSize preferredSize = secondaryForwardStepper->preferredSize();
+ if (part == ForwardButtonStartPart)
+ return IntRect(rect.location(), preferredSize);
+
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ rect.move(0, preferredSize.height());
+ rect.contract(0, preferredSize.height());
+ } else {
+ rect.move(preferredSize.width(), 0);
+ rect.contract(preferredSize.width(), 0);
+ }
+ }
+
+ auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+ ASSERT(forwardStepper);
+ forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+ IntSize preferredSize = forwardStepper->preferredSize();
+ if (scrollbar.orientation() == VerticalScrollbar)
+ rect.move(0, rect.height() - preferredSize.height());
+ else
+ rect.move(rect.width() - preferredSize.width(), 0);
+
+ return IntRect(rect.location(), preferredSize);
+}
+
+bool ScrollbarThemeGtk::paint(Scrollbar& scrollbar, GraphicsContext& graphicsContext, const IntRect& damageRect)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::paint(scrollbar, graphicsContext, damageRect);
+
+ if (graphicsContext.paintingDisabled())
+ return false;
+
+ if (!scrollbar.enabled())
+ return true;
+
+ double opacity = scrollbar.hoveredPart() == NoPart ? scrollbar.opacity() : 1;
+ if (!opacity)
+ return true;
+
+ IntRect rect = scrollbar.frameRect();
+ if (!rect.intersects(damageRect))
+ return true;
+
+ auto scrollbarState = scrollbarPartStateFlags(scrollbar, AllParts, true);
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(widgetTypeForScrollbar(scrollbar, scrollbarState)));
+ auto& scrollbarGadget = scrollbarWidget.scrollbar();
+ scrollbarGadget.setState(scrollbarState);
+ if (usesOverlayScrollbars())
+ opacity *= scrollbarGadget.opacity();
+ if (!opacity)
+ return true;
+
+ auto& trough = scrollbarWidget.trough();
+ trough.setState(scrollbarPartStateFlags(scrollbar, BackTrackPart));
+
+ auto* backwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Backward);
+ if (backwardStepper)
+ backwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonStartPart));
+ auto* secondaryForwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryForward);
+ if (secondaryForwardStepper)
+ secondaryForwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonStartPart));
+ auto* secondaryBackwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+ if (secondaryBackwardStepper)
+ secondaryBackwardStepper->setState(scrollbarPartStateFlags(scrollbar, BackButtonEndPart));
+ auto* forwardStepper = scrollbarWidget.stepper(RenderThemeScrollbarGadget::Steppers::Forward);
+ if (forwardStepper)
+ forwardStepper->setState(scrollbarPartStateFlags(scrollbar, ForwardButtonEndPart));
+
+ IntSize preferredSize = scrollbarWidget.contents().preferredSize();
+ int thumbSize = thumbLength(scrollbar);
+ if (thumbSize) {
+ scrollbarWidget.slider().setState(scrollbarPartStateFlags(scrollbar, ThumbPart));
+ preferredSize = preferredSize.expandedTo(scrollbarWidget.slider().preferredSize());
+ }
+ preferredSize += scrollbarGadget.preferredSize() - scrollbarGadget.minimumSize();
+
+ FloatRect contentsRect(rect);
+ // When using overlay scrollbars we always claim the size of the scrollbar when hovered, so when
+ // drawing the indicator we need to adjust the rectangle to its actual size in indicator mode.
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ if (rect.width() != preferredSize.width()) {
+ if (!scrollbar.scrollableArea().shouldPlaceBlockDirectionScrollbarOnLeft())
+ contentsRect.move(std::abs(rect.width() - preferredSize.width()), 0);
+ contentsRect.setWidth(preferredSize.width());
+ }
+ } else {
+ if (rect.height() != preferredSize.height()) {
+ contentsRect.move(0, std::abs(rect.height() - preferredSize.height()));
+ contentsRect.setHeight(preferredSize.height());
+ }
+ }
+
+ if (opacity != 1) {
+ graphicsContext.save();
+ graphicsContext.clip(damageRect);
+ graphicsContext.beginTransparencyLayer(opacity);
+ }
+
+ scrollbarGadget.render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+ scrollbarWidget.contents().render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+
+ if (backwardStepper) {
+ FloatRect buttonRect = contentsRect;
+ if (scrollbar.orientation() == VerticalScrollbar)
+ buttonRect.setHeight(backwardStepper->preferredSize().height());
+ else
+ buttonRect.setWidth(backwardStepper->preferredSize().width());
+ static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, backwardStepper,
+ scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::Backward);
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ contentsRect.move(0, buttonRect.height());
+ contentsRect.contract(0, buttonRect.height());
+ } else {
+ contentsRect.move(buttonRect.width(), 0);
+ contentsRect.contract(buttonRect.width(), 0);
+ }
+ }
+ if (secondaryForwardStepper) {
+ FloatRect buttonRect = contentsRect;
+ if (scrollbar.orientation() == VerticalScrollbar)
+ buttonRect.setHeight(secondaryForwardStepper->preferredSize().height());
+ else
+ buttonRect.setWidth(secondaryForwardStepper->preferredSize().width());
+ static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, secondaryForwardStepper,
+ scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::SecondaryForward);
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ contentsRect.move(0, buttonRect.height());
+ contentsRect.contract(0, buttonRect.height());
+ } else {
+ contentsRect.move(buttonRect.width(), 0);
+ contentsRect.contract(buttonRect.width(), 0);
+ }
+ }
+ if (secondaryBackwardStepper) {
+ FloatRect buttonRect = contentsRect;
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ buttonRect.setHeight(secondaryBackwardStepper->preferredSize().height());
+ buttonRect.move(0, contentsRect.height() - buttonRect.height());
+ } else {
+ buttonRect.setWidth(secondaryBackwardStepper->preferredSize().width());
+ buttonRect.move(contentsRect.width() - buttonRect.width(), 0);
+ }
+ static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, secondaryBackwardStepper,
+ scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::SecondaryBackward);
+ if (scrollbar.orientation() == VerticalScrollbar)
+ contentsRect.contract(0, buttonRect.height());
+ else
+ contentsRect.contract(buttonRect.width(), 0);
+ }
+ if (forwardStepper) {
+ FloatRect buttonRect = contentsRect;
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ buttonRect.setHeight(forwardStepper->preferredSize().height());
+ buttonRect.move(0, contentsRect.height() - buttonRect.height());
+ } else {
+ buttonRect.setWidth(forwardStepper->preferredSize().width());
+ buttonRect.move(contentsRect.width() - buttonRect.width(), 0);
+ }
+ static_cast<RenderThemeScrollbarGadget&>(scrollbarGadget).renderStepper(graphicsContext.platformContext()->cr(), buttonRect, forwardStepper,
+ scrollbar.orientation() == VerticalScrollbar ? GTK_ORIENTATION_VERTICAL : GTK_ORIENTATION_HORIZONTAL, RenderThemeScrollbarGadget::Steppers::Forward);
+ if (scrollbar.orientation() == VerticalScrollbar)
+ contentsRect.contract(0, buttonRect.height());
+ else
+ contentsRect.contract(buttonRect.width(), 0);
+ }
+
+ trough.render(graphicsContext.platformContext()->cr(), contentsRect, &contentsRect);
+
+ if (thumbSize) {
+ if (scrollbar.orientation() == VerticalScrollbar) {
+ contentsRect.move(0, thumbPosition(scrollbar));
+ contentsRect.setWidth(scrollbarWidget.slider().preferredSize().width());
+ contentsRect.setHeight(thumbSize);
+ } else {
+ contentsRect.move(thumbPosition(scrollbar), 0);
+ contentsRect.setWidth(thumbSize);
+ contentsRect.setHeight(scrollbarWidget.slider().preferredSize().height());
+ }
+ if (contentsRect.intersects(damageRect))
+ scrollbarWidget.slider().render(graphicsContext.platformContext()->cr(), contentsRect);
+ }
+
+ if (opacity != 1) {
+ graphicsContext.endTransparencyLayer();
+ graphicsContext.restore();
+ }
+
+ return true;
+}
+
+ScrollbarButtonPressAction ScrollbarThemeGtk::handleMousePressEvent(Scrollbar& scrollbar, const PlatformMouseEvent& event, ScrollbarPart pressedPart)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::handleMousePressEvent(scrollbar, event, pressedPart);
+
+ gboolean warpSlider = FALSE;
+ switch (pressedPart) {
+ case BackTrackPart:
+ case ForwardTrackPart:
+ g_object_get(gtk_settings_get_default(),
+ "gtk-primary-button-warps-slider",
+ &warpSlider, nullptr);
+ // The shift key or middle/right button reverses the sense.
+ if (event.shiftKey() || event.button() != LeftButton)
+ warpSlider = !warpSlider;
+ return warpSlider ?
+ ScrollbarButtonPressAction::CenterOnThumb:
+ ScrollbarButtonPressAction::Scroll;
+ case ThumbPart:
+ if (event.button() != RightButton)
+ return ScrollbarButtonPressAction::StartDrag;
+ break;
+ case BackButtonStartPart:
+ case ForwardButtonStartPart:
+ case BackButtonEndPart:
+ case ForwardButtonEndPart:
+ return ScrollbarButtonPressAction::Scroll;
+ default:
+ break;
+ }
+
+ return ScrollbarButtonPressAction::None;
+}
+
+int ScrollbarThemeGtk::scrollbarThickness(ScrollbarControlSize controlSize, ScrollbarExpansionState expansionState)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::scrollbarThickness(controlSize, expansionState);
+
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(RenderThemeScrollbar::Type::VerticalScrollbarRight));
+ scrollbarWidget.scrollbar().setState(GTK_STATE_FLAG_PRELIGHT);
+ IntSize contentsPreferredSize = scrollbarWidget.contents().preferredSize();
+ contentsPreferredSize = contentsPreferredSize.expandedTo(scrollbarWidget.slider().preferredSize());
+ IntSize preferredSize = contentsPreferredSize + scrollbarWidget.scrollbar().preferredSize() - scrollbarWidget.scrollbar().minimumSize();
+ return preferredSize.width();
+}
+
+int ScrollbarThemeGtk::minimumThumbLength(Scrollbar& scrollbar)
+{
+ if (!m_useSystemAppearance)
+ return ScrollbarThemeAdwaita::minimumThumbLength(scrollbar);
+
+ auto& scrollbarWidget = static_cast<RenderThemeScrollbar&>(RenderThemeScrollbar::getOrCreate(RenderThemeScrollbar::Type::VerticalScrollbarRight));
+ scrollbarWidget.scrollbar().setState(GTK_STATE_FLAG_PRELIGHT);
+ IntSize minSize = scrollbarWidget.slider().minimumSize();
+ return scrollbar.orientation() == VerticalScrollbar ? minSize.height() : minSize.width();
+}
+
+} // namespace WebCore
+
+#endif // !USE(GTK4)
Added: trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.h (0 => 260065)
--- trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.h (rev 0)
+++ trunk/Source/WebCore/platform/gtk/ScrollbarThemeGtk.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -0,0 +1,64 @@
+/*
+ * Copyright (C) 2008 Apple Inc. All Rights Reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ * 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.
+ */
+
+#pragma once
+
+#if !USE(GTK4)
+
+#include "ScrollbarThemeAdwaita.h"
+
+namespace WebCore {
+
+class ScrollbarThemeGtk final : public ScrollbarThemeAdwaita {
+public:
+ ScrollbarThemeGtk();
+ virtual ~ScrollbarThemeGtk();
+
+ void setUseSystemAppearance(bool);
+
+private:
+ bool hasButtons(Scrollbar&) override;
+ IntRect backButtonRect(Scrollbar&, ScrollbarPart, bool) override;
+ IntRect forwardButtonRect(Scrollbar&, ScrollbarPart, bool) override;
+ IntRect trackRect(Scrollbar&, bool) override;
+
+ bool paint(Scrollbar&, GraphicsContext&, const IntRect& damageRect) override;
+ ScrollbarButtonPressAction handleMousePressEvent(Scrollbar&, const PlatformMouseEvent&, ScrollbarPart) override;
+ int scrollbarThickness(ScrollbarControlSize, ScrollbarExpansionState = ScrollbarExpansionState::Expanded) override;
+ int minimumThumbLength(Scrollbar&) override;
+
+ void themeChanged() override;
+ void updateThemeProperties();
+
+ bool m_hasForwardButtonStartPart : 1;
+ bool m_hasForwardButtonEndPart : 1;
+ bool m_hasBackButtonStartPart : 1;
+ bool m_hasBackButtonEndPart : 1;
+ bool m_useSystemAppearance { true };
+};
+
+} // namespace WebCore
+
+#endif // !USE(GTK4)
Modified: trunk/Source/WebKit/ChangeLog (260064 => 260065)
--- trunk/Source/WebKit/ChangeLog 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/ChangeLog 2020-04-14 09:50:31 UTC (rev 260065)
@@ -1,3 +1,38 @@
+2020-04-14 Carlos Garcia Campos <[email protected]>
+
+ [GTK] Bring back support for rendering scrollbars using the system appearance
+ https://bugs.webkit.org/show_bug.cgi?id=209805
+
+ Reviewed by Michael Catanzaro.
+
+ Add WebKitWebContext:use-system-appearance-for-scrollbars property. It's enabled by default to keep backwards
+ compatibility.
+
+ * Shared/WebProcessCreationParameters.cpp:
+ (WebKit::WebProcessCreationParameters::encode const): Encode useSystemAppearanceForScrollbars.
+ (WebKit::WebProcessCreationParameters::decode): Decode useSystemAppearanceForScrollbars.
+ * Shared/WebProcessCreationParameters.h:
+ * UIProcess/API/APIProcessPoolConfiguration.cpp:
+ (API::ProcessPoolConfiguration::copy): Copy m_useSystemAppearanceForScrollbars;
+ * UIProcess/API/APIProcessPoolConfiguration.h:
+ * UIProcess/API/glib/WebKitWebContext.cpp:
+ (webkitWebContextGetProperty):
+ (webkitWebContextSetProperty):
+ (webkitWebContextConstructed):
+ (webkit_web_context_class_init):
+ (webkit_web_context_set_use_system_appearance_for_scrollbars):
+ (webkit_web_context_get_use_system_appearance_for_scrollbars):
+ * UIProcess/API/gtk/WebKitWebContext.h:
+ * UIProcess/API/gtk/docs/webkit2gtk-4.0-sections.txt:
+ * UIProcess/glib/WebProcessPoolGLib.cpp:
+ (WebKit::WebProcessPool::platformInitializeWebProcess): Initialize useSystemAppearanceForScrollbars parameter.
+ * WebProcess/WebProcess.h:
+ * WebProcess/WebProcess.messages.in:
+ * WebProcess/glib/WebProcessGLib.cpp:
+ (WebKit::WebProcess::platformInitializeWebProcess): Call setUseSystemAppearanceForScrollbars to set
+ useSystemAppearanceForScrollbars parameter.
+ (WebKit::WebProcess::setUseSystemAppearanceForScrollbars): Call ScrollbarThemeGtk::setUseSystemAppearance().
+
2020-04-14 Youenn Fablet <[email protected]>
WebSocketChannel should remove itself from its manager map
Modified: trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp (260064 => 260065)
--- trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/Shared/WebProcessCreationParameters.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -190,6 +190,10 @@
encoder << preferencesExtensionHandle;
#endif
#endif
+
+#if PLATFORM(GTK)
+ encoder << useSystemAppearanceForScrollbars;
+#endif
}
bool WebProcessCreationParameters::decode(IPC::Decoder& decoder, WebProcessCreationParameters& parameters)
@@ -521,6 +525,14 @@
#endif
#endif
+#if PLATFORM(GTK)
+ Optional<bool> useSystemAppearanceForScrollbars;
+ decoder >> useSystemAppearanceForScrollbars;
+ if (!useSystemAppearanceForScrollbars)
+ return false;
+ parameters.useSystemAppearanceForScrollbars = WTFMove(*useSystemAppearanceForScrollbars);
+#endif
+
return true;
}
Modified: trunk/Source/WebKit/Shared/WebProcessCreationParameters.h (260064 => 260065)
--- trunk/Source/WebKit/Shared/WebProcessCreationParameters.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/Shared/WebProcessCreationParameters.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -229,6 +229,10 @@
Optional<SandboxExtension::Handle> preferencesExtensionHandle;
#endif
#endif
+
+#if PLATFORM(GTK)
+ bool useSystemAppearanceForScrollbars { false };
+#endif
};
} // namespace WebKit
Modified: trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.cpp (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -68,6 +68,9 @@
copy->m_usesBackForwardCache = this->m_usesBackForwardCache;
copy->m_customWebContentServiceBundleIdentifier = this->m_customWebContentServiceBundleIdentifier;
copy->m_usesSingleWebProcess = m_usesSingleWebProcess;
+#if PLATFORM(GTK) && !USE(GTK4)
+ copy->m_useSystemAppearanceForScrollbars = m_useSystemAppearanceForScrollbars;
+#endif
return copy;
}
Modified: trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.h (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/API/APIProcessPoolConfiguration.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -131,6 +131,11 @@
const WTF::String& customWebContentServiceBundleIdentifier() const { return m_customWebContentServiceBundleIdentifier; }
void setCustomWebContentServiceBundleIdentifier(const WTF::String& customWebContentServiceBundleIdentifier) { m_customWebContentServiceBundleIdentifier = customWebContentServiceBundleIdentifier; }
+#if PLATFORM(GTK) && !USE(GTK4)
+ bool useSystemAppearanceForScrollbars() const { return m_useSystemAppearanceForScrollbars; }
+ void setUseSystemAppearanceForScrollbars(bool useSystemAppearanceForScrollbars) { m_useSystemAppearanceForScrollbars = useSystemAppearanceForScrollbars; }
+#endif
+
private:
WTF::String m_injectedBundlePath;
Vector<WTF::String> m_customClassesForParameterCoder;
@@ -157,6 +162,9 @@
bool m_shouldConfigureJSCForTesting { false };
bool m_isJITEnabled { true };
bool m_usesSingleWebProcess { false };
+#if PLATFORM(GTK) && !USE(GTK4)
+ bool m_useSystemAppearanceForScrollbars { false };
+#endif
};
} // namespace API
Modified: trunk/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/API/glib/WebKitWebContext.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -120,7 +120,8 @@
#endif
PROP_WEBSITE_DATA_MANAGER,
#if PLATFORM(GTK)
- PROP_PSON_ENABLED
+ PROP_PSON_ENABLED,
+ PROP_USE_SYSYEM_APPEARANCE_FOR_SCROLLBARS
#endif
};
@@ -204,7 +205,10 @@
bool clientsDetached;
#if PLATFORM(GTK)
bool psonEnabled;
+#if !USE(GTK4)
+ bool useSystemAppearanceForScrollbars;
#endif
+#endif
GRefPtr<WebKitFaviconDatabase> faviconDatabase;
GRefPtr<WebKitSecurityManager> securityManager;
@@ -333,6 +337,9 @@
case PROP_PSON_ENABLED:
g_value_set_boolean(value, context->priv->psonEnabled);
break;
+ case PROP_USE_SYSYEM_APPEARANCE_FOR_SCROLLBARS:
+ g_value_set_boolean(value, webkit_web_context_get_use_system_appearance_for_scrollbars(context));
+ break;
#endif
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
@@ -358,6 +365,9 @@
case PROP_PSON_ENABLED:
context->priv->psonEnabled = g_value_get_boolean(value);
break;
+ case PROP_USE_SYSYEM_APPEARANCE_FOR_SCROLLBARS:
+ webkit_web_context_set_use_system_appearance_for_scrollbars(context, g_value_get_boolean(value));
+ break;
#endif
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, propID, paramSpec);
@@ -377,7 +387,10 @@
configuration.setInjectedBundlePath(FileSystem::stringFromFileSystemRepresentation(bundleFilename.get()));
#if PLATFORM(GTK)
configuration.setProcessSwapsOnNavigation(priv->psonEnabled);
+#if !USE(GTK4)
+ configuration.setUseSystemAppearanceForScrollbars(priv->useSystemAppearanceForScrollbars);
#endif
+#endif
if (!priv->websiteDataManager)
priv->websiteDataManager = adoptGRef(webkit_website_data_manager_new("local-storage-directory", priv->localStorageDirectory.data(), nullptr));
@@ -519,6 +532,27 @@
_("Whether swap Web processes on cross-site navigations is enabled"),
FALSE,
static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY)));
+
+ /**
+ * WebKitWebContext:use-system-appearance-for-scrollbars:
+ *
+ * Whether to use system appearance for rendering scrollbars.
+ *
+ * This is enabled by default for backwards compatibility, but it's only
+ * recommened to use when the application includes other widgets to ensure
+ * consistency, or when consistency with other applications is required too.
+ *
+ * Since: 2.30
+ */
+ g_object_class_install_property(
+ gObjectClass,
+ PROP_USE_SYSYEM_APPEARANCE_FOR_SCROLLBARS,
+ g_param_spec_boolean(
+ "use-system-appearance-for-scrollbars",
+ _("Use system appearance for scrollbars"),
+ _("Whether to use system appearance for rendering scrollbars"),
+ TRUE,
+ static_cast<GParamFlags>(WEBKIT_PARAM_READWRITE | G_PARAM_CONSTRUCT)));
#endif
/**
@@ -1763,6 +1797,51 @@
process->send(Messages::WebProcess::SendMessageToWebExtension(webkitUserMessageGetMessage(message)), 0);
}
+#if PLATFORM(GTK) && !USE(GTK4)
+/**
+ * webkit_web_context_set_use_system_appearance_for_scrollbars:
+ * @context: a #WebKitWebContext
+ * @enabled: value to set
+ *
+ * Set the #WebKitWebContext:use-system-appearance-for-scrollbars property.
+ *
+ * Since: 2.30
+ */
+void webkit_web_context_set_use_system_appearance_for_scrollbars(WebKitWebContext* context, gboolean enabled)
+{
+ g_return_if_fail(WEBKIT_IS_WEB_CONTEXT(context));
+
+ if (context->priv->useSystemAppearanceForScrollbars == enabled)
+ return;
+
+ context->priv->useSystemAppearanceForScrollbars = enabled;
+ g_object_notify(G_OBJECT(context), "use-system-appearance-for-scrollbars");
+
+ if (!context->priv->processPool)
+ return;
+
+ context->priv->processPool->configuration().setUseSystemAppearanceForScrollbars(enabled);
+ context->priv->processPool->sendToAllProcesses(Messages::WebProcess::SetUseSystemAppearanceForScrollbars(enabled));
+}
+
+/**
+ * webkit_web_context_get_use_system_appearance_for_scrollbars:
+ * @context: a #WebKitWebContext
+ *
+ * Get the #WebKitWebContext:use-system-appearance-for-scrollbars property.
+ *
+ * Returns: %TRUE if scrollbars are rendering using the system appearance, or %FALSE otherwise
+ *
+ * Since: 2.30
+ */
+gboolean webkit_web_context_get_use_system_appearance_for_scrollbars(WebKitWebContext* context)
+{
+ g_return_val_if_fail(WEBKIT_IS_WEB_CONTEXT(context), TRUE);
+
+ return context->priv->useSystemAppearanceForScrollbars;
+}
+#endif
+
void webkitWebContextInitializeNotificationPermissions(WebKitWebContext* context)
{
g_signal_emit(context, signals[INITIALIZE_NOTIFICATION_PERMISSIONS], 0);
Modified: trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/API/gtk/WebKitWebContext.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -324,6 +324,13 @@
webkit_web_context_send_message_to_all_extensions (WebKitWebContext *context,
WebKitUserMessage *message);
+WEBKIT_API void
+webkit_web_context_set_use_system_appearance_for_scrollbars (WebKitWebContext *context,
+ gboolean enabled);
+
+WEBKIT_API gboolean
+webkit_web_context_get_use_system_appearance_for_scrollbars (WebKitWebContext *context);
+
G_END_DECLS
#endif
Modified: trunk/Source/WebKit/UIProcess/API/gtk/docs/webkit2gtk-4.0-sections.txt (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/API/gtk/docs/webkit2gtk-4.0-sections.txt 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/API/gtk/docs/webkit2gtk-4.0-sections.txt 2020-04-14 09:50:31 UTC (rev 260065)
@@ -71,6 +71,8 @@
webkit_web_context_set_process_model
webkit_web_context_initialize_notification_permissions
webkit_web_context_send_message_to_all_extensions
+webkit_web_context_set_use_system_appearance_for_scrollbars
+webkit_web_context_get_use_system_appearance_for_scrollbars
<SUBSECTION URI Scheme>
WebKitURISchemeRequestCallback
Modified: trunk/Source/WebKit/UIProcess/glib/WebProcessPoolGLib.cpp (260064 => 260065)
--- trunk/Source/WebKit/UIProcess/glib/WebProcessPoolGLib.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/UIProcess/glib/WebProcessPoolGLib.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -135,6 +135,10 @@
#if USE(GSTREAMER)
parameters.gstreamerOptions = WebCore::extractGStreamerOptionsFromCommandLine();
#endif
+
+#if PLATFORM(GTK)
+ parameters.useSystemAppearanceForScrollbars = m_configuration->useSystemAppearanceForScrollbars();
+#endif
}
void WebProcessPool::platformInvalidateContext()
Modified: trunk/Source/WebKit/WebProcess/WebProcess.h (260064 => 260065)
--- trunk/Source/WebKit/WebProcess/WebProcess.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/WebProcess/WebProcess.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -503,6 +503,10 @@
void sendMessageToWebExtension(UserMessage&&);
#endif
+#if PLATFORM(GTK) && !USE(GTK4)
+ void setUseSystemAppearanceForScrollbars(bool);
+#endif
+
bool isAlwaysOnLoggingAllowed() { return m_sessionID ? m_sessionID->isAlwaysOnLoggingAllowed() : true; }
RefPtr<WebConnectionToUIProcess> m_webConnection;
Modified: trunk/Source/WebKit/WebProcess/WebProcess.messages.in (260064 => 260065)
--- trunk/Source/WebKit/WebProcess/WebProcess.messages.in 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/WebProcess/WebProcess.messages.in 2020-04-14 09:50:31 UTC (rev 260065)
@@ -173,4 +173,8 @@
UnblockPreferenceService(WebKit::SandboxExtension::Handle handle)
#endif
#endif
+
+#if PLATFORM(GTK) && !USE(GTK4)
+ SetUseSystemAppearanceForScrollbars(bool useSystemAppearanceForScrollbars)
+#endif
}
Modified: trunk/Source/WebKit/WebProcess/glib/WebProcessGLib.cpp (260064 => 260065)
--- trunk/Source/WebKit/WebProcess/glib/WebProcessGLib.cpp 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Source/WebKit/WebProcess/glib/WebProcessGLib.cpp 2020-04-14 09:50:31 UTC (rev 260065)
@@ -46,6 +46,10 @@
#include <wpe/wpe.h>
#endif
+#if PLATFORM(GTK) && !USE(GTK4)
+#include <WebCore/ScrollbarThemeGtk.h>
+#endif
+
namespace WebKit {
using namespace WebCore;
@@ -89,6 +93,10 @@
#if USE(GSTREAMER)
WebCore::initializeGStreamer(WTFMove(parameters.gstreamerOptions));
#endif
+
+#if PLATFORM(GTK) && !USE(GTK4)
+ setUseSystemAppearanceForScrollbars(parameters.useSystemAppearanceForScrollbars);
+#endif
}
void WebProcess::platformSetWebsiteDataStoreParameters(WebProcessDataStoreParameters&&)
@@ -105,4 +113,11 @@
webkitWebExtensionDidReceiveUserMessage(extension, WTFMove(message));
}
+#if PLATFORM(GTK) && !USE(GTK4)
+void WebProcess::setUseSystemAppearanceForScrollbars(bool useSystemAppearanceForScrollbars)
+{
+ static_cast<ScrollbarThemeGtk&>(ScrollbarTheme::theme()).setUseSystemAppearance(useSystemAppearanceForScrollbars);
+}
+#endif
+
} // namespace WebKit
Modified: trunk/Tools/ChangeLog (260064 => 260065)
--- trunk/Tools/ChangeLog 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Tools/ChangeLog 2020-04-14 09:50:31 UTC (rev 260065)
@@ -1,3 +1,17 @@
+2020-04-14 Carlos Garcia Campos <[email protected]>
+
+ [GTK] Bring back support for rendering scrollbars using the system appearance
+ https://bugs.webkit.org/show_bug.cgi?id=209805
+
+ Reviewed by Michael Catanzaro.
+
+ Do not use system appearance for scrollbars in MiniBrowser and unit tests.
+
+ * MiniBrowser/gtk/main.c:
+ (main):
+ * TestWebKitAPI/glib/WebKitGLib/TestMain.h:
+ (Test::Test):
+
2020-04-13 Devin Rousso <[email protected]>
REGRESSION (r259900) : Speedometer failing on Catalina-Release-WK2-Perf bot
Modified: trunk/Tools/MiniBrowser/gtk/main.c (260064 => 260065)
--- trunk/Tools/MiniBrowser/gtk/main.c 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Tools/MiniBrowser/gtk/main.c 2020-04-14 09:50:31 UTC (rev 260065)
@@ -542,7 +542,8 @@
}
WebKitWebsiteDataManager *manager = (privateMode || automationMode) ? webkit_website_data_manager_new_ephemeral() : webkit_website_data_manager_new(NULL);
- WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "website-data-manager", manager, "process-swap-on-cross-site-navigation-enabled", TRUE, NULL);
+ WebKitWebContext *webContext = g_object_new(WEBKIT_TYPE_WEB_CONTEXT, "website-data-manager", manager, "process-swap-on-cross-site-navigation-enabled", TRUE,
+ "use-system-appearance-for-scrollbars", FALSE, NULL);
g_object_unref(manager);
if (cookiesPolicy) {
Modified: trunk/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h (260064 => 260065)
--- trunk/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h 2020-04-14 09:36:06 UTC (rev 260064)
+++ trunk/Tools/TestWebKitAPI/glib/WebKitGLib/TestMain.h 2020-04-14 09:50:31 UTC (rev 260065)
@@ -133,6 +133,7 @@
"website-data-manager", websiteDataManager.get(),
#if PLATFORM(GTK)
"process-swap-on-cross-site-navigation-enabled", TRUE,
+ "use-system-appearance-for-scrollbars", FALSE,
#endif
nullptr)));
assertObjectIsDeletedWhenTestFinishes(G_OBJECT(m_webContext.get()));
