RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-28 05:47:34 +00:00
Code Issues Activity Actions

Everywhere: Run clang-format

Browse source
This commit is contained in:
Idan Horowitz 2022-04-01 20:58:27 +03:00 • committed by Linus Groh
parent 0376c127f6
commit 086969277e
1665 changed files with 8479 additions and 8479 deletions
Download patch file Download diff file Expand all files Collapse all files

22
Userland/Libraries/LibGfx/AffineTransform.cpp
View file

@ -60,7 +60,7 @@ AffineTransform& AffineTransform::scale(float sx, float sy)
return *this;
}
AffineTransform& AffineTransform::scale(const FloatPoint& s)
AffineTransform& AffineTransform::scale(FloatPoint const& s)
{
return scale(s.x(), s.y());
}
@ -74,7 +74,7 @@ AffineTransform& AffineTransform::set_scale(float sx, float sy)
return *this;
}
AffineTransform& AffineTransform::set_scale(const FloatPoint& s)
AffineTransform& AffineTransform::set_scale(FloatPoint const& s)
{
return set_scale(s.x(), s.y());
}
@ -86,7 +86,7 @@ AffineTransform& AffineTransform::translate(float tx, float ty)
return *this;
}
AffineTransform& AffineTransform::translate(const FloatPoint& t)
AffineTransform& AffineTransform::translate(FloatPoint const& t)
{
return translate(t.x(), t.y());
}
@ -98,12 +98,12 @@ AffineTransform& AffineTransform::set_translation(float tx, float ty)
return *this;
}
AffineTransform& AffineTransform::set_translation(const FloatPoint& t)
AffineTransform& AffineTransform::set_translation(FloatPoint const& t)
{
return set_translation(t.x(), t.y());
}
AffineTransform& AffineTransform::multiply(const AffineTransform& other)
AffineTransform& AffineTransform::multiply(AffineTransform const& other)
{
AffineTransform result;
result.m_values[0] = other.a() * a() + other.b() * c();
@ -147,7 +147,7 @@ void AffineTransform::map(float unmapped_x, float unmapped_y, float& mapped_x, f
}
template<>
IntPoint AffineTransform::map(const IntPoint& point) const
IntPoint AffineTransform::map(IntPoint const& point) const
{
float mapped_x;
float mapped_y;
@ -156,7 +156,7 @@ IntPoint AffineTransform::map(const IntPoint& point) const
}
template<>
FloatPoint AffineTransform::map(const FloatPoint& point) const
FloatPoint AffineTransform::map(FloatPoint const& point) const
{
float mapped_x;
float mapped_y;
@ -165,7 +165,7 @@ FloatPoint AffineTransform::map(const FloatPoint& point) const
}
template<>
IntSize AffineTransform::map(const IntSize& size) const
IntSize AffineTransform::map(IntSize const& size) const
{
return {
roundf(static_cast<float>(size.width()) * x_scale()),
@ -174,7 +174,7 @@ IntSize AffineTransform::map(const IntSize& size) const
}
template<>
FloatSize AffineTransform::map(const FloatSize& size) const
FloatSize AffineTransform::map(FloatSize const& size) const
{
return { size.width() * x_scale(), size.height() * y_scale() };
}
@ -192,7 +192,7 @@ static T largest_of(T p1, T p2, T p3, T p4)
}
template<>
FloatRect AffineTransform::map(const FloatRect& rect) const
FloatRect AffineTransform::map(FloatRect const& rect) const
{
FloatPoint p1 = map(rect.top_left());
FloatPoint p2 = map(rect.top_right().translated(1, 0));
@ -206,7 +206,7 @@ FloatRect AffineTransform::map(const FloatRect& rect) const
}
template<>
IntRect AffineTransform::map(const IntRect& rect) const
IntRect AffineTransform::map(IntRect const& rect) const
{
return enclosing_int_rect(map(FloatRect(rect)));
}

16
Userland/Libraries/LibGfx/AffineTransform.h
View file

@ -29,13 +29,13 @@ public:
void map(float unmapped_x, float unmapped_y, float& mapped_x, float& mapped_y) const;
template<typename T>
Point<T> map(const Point<T>&) const;
Point<T> map(Point<T> const&) const;
template<typename T>
Size<T> map(const Size<T>&) const;
Size<T> map(Size<T> const&) const;
template<typename T>
Rect<T> map(const Rect<T>&) const;
Rect<T> map(Rect<T> const&) const;
[[nodiscard]] ALWAYS_INLINE float a() const { return m_values[0]; }
[[nodiscard]] ALWAYS_INLINE float b() const { return m_values[1]; }
@ -52,15 +52,15 @@ public:
[[nodiscard]] FloatPoint translation() const;
AffineTransform& scale(float sx, float sy);
AffineTransform& scale(const FloatPoint& s);
AffineTransform& scale(FloatPoint const& s);
AffineTransform& set_scale(float sx, float sy);
AffineTransform& set_scale(const FloatPoint& s);
AffineTransform& set_scale(FloatPoint const& s);
AffineTransform& translate(float tx, float ty);
AffineTransform& translate(const FloatPoint& t);
AffineTransform& translate(FloatPoint const& t);
AffineTransform& set_translation(float tx, float ty);
AffineTransform& set_translation(const FloatPoint& t);
AffineTransform& set_translation(FloatPoint const& t);
AffineTransform& rotate_radians(float);
AffineTransform& multiply(const AffineTransform&);
AffineTransform& multiply(AffineTransform const&);
Optional<AffineTransform> inverse() const;

6
Userland/Libraries/LibGfx/AntiAliasingPainter.cpp
View file

@ -179,7 +179,7 @@ void Gfx::AntiAliasingPainter::draw_quadratic_bezier_curve(FloatPoint const& con
});
}
void Gfx::AntiAliasingPainter::draw_cubic_bezier_curve(const FloatPoint& control_point_0, const FloatPoint& control_point_1, const FloatPoint& p1, const FloatPoint& p2, Color color, float thickness, Painter::LineStyle style)
void Gfx::AntiAliasingPainter::draw_cubic_bezier_curve(FloatPoint const& control_point_0, FloatPoint const& control_point_1, FloatPoint const& p1, FloatPoint const& p2, Color color, float thickness, Painter::LineStyle style)
{
Gfx::Painter::for_each_line_segment_on_cubic_bezier_curve(control_point_0, control_point_1, p1, p2, [&](FloatPoint const& fp1, FloatPoint const& fp2) {
draw_line(fp1, fp2, color, thickness, style);
@ -200,9 +200,9 @@ void Gfx::AntiAliasingPainter::draw_circle(IntPoint center, int radius, Color co
// These happen to be the same here, but are treated separately in the paper:
// intensity is the fill alpha
const int intensity = color.alpha();
int const intensity = color.alpha();
// 0 to subpixel_resolution is the range of alpha values for the circle edges
const int subpixel_resolution = intensity;
int const subpixel_resolution = intensity;
// Note: Variable names below are based off the paper

8
Userland/Libraries/LibGfx/BMPLoader.cpp
View file

@ -130,7 +130,7 @@ struct BMPLoadingContext {
};
State state { State::NotDecoded };
const u8* file_bytes { nullptr };
u8 const* file_bytes { nullptr };
size_t file_size { 0 };
u32 data_offset { 0 };
@ -167,7 +167,7 @@ struct BMPLoadingContext {
class InputStreamer {
public:
InputStreamer(const u8* data, size_t size)
InputStreamer(u8 const* data, size_t size)
: m_data_ptr(data)
, m_size_remaining(size)
{
@ -217,7 +217,7 @@ public:
size_t remaining() const { return m_size_remaining; }
private:
const u8* m_data_ptr { nullptr };
u8 const* m_data_ptr { nullptr };
size_t m_size_remaining { 0 };
};
@ -1300,7 +1300,7 @@ static bool decode_bmp_pixel_data(BMPLoadingContext& context)
return true;
}
BMPImageDecoderPlugin::BMPImageDecoderPlugin(const u8* data, size_t data_size)
BMPImageDecoderPlugin::BMPImageDecoderPlugin(u8 const* data, size_t data_size)
{
m_context = make<BMPLoadingContext>();
m_context->file_bytes = data;

2
Userland/Libraries/LibGfx/BMPLoader.h
View file

@ -15,7 +15,7 @@ struct BMPLoadingContext;
class BMPImageDecoderPlugin final : public ImageDecoderPlugin {
public:
virtual ~BMPImageDecoderPlugin() override;
BMPImageDecoderPlugin(const u8*, size_t);
BMPImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;

6
Userland/Libraries/LibGfx/BMPWriter.cpp
View file

@ -42,7 +42,7 @@ private:
u8* m_data;
};
static ByteBuffer write_pixel_data(const RefPtr<Bitmap> bitmap, int pixel_row_data_size, int bytes_per_pixel, bool include_alpha_channel)
static ByteBuffer write_pixel_data(RefPtr<Bitmap> const bitmap, int pixel_row_data_size, int bytes_per_pixel, bool include_alpha_channel)
{
int image_size = pixel_row_data_size * bitmap->height();
auto buffer_result = ByteBuffer::create_uninitialized(image_size);
@ -67,7 +67,7 @@ static ByteBuffer write_pixel_data(const RefPtr<Bitmap> bitmap, int pixel_row_da
return buffer;
}
static ByteBuffer compress_pixel_data(const ByteBuffer& pixel_data, BMPWriter::Compression compression)
static ByteBuffer compress_pixel_data(ByteBuffer const& pixel_data, BMPWriter::Compression compression)
{
switch (compression) {
case BMPWriter::Compression::BI_BITFIELDS:
@ -78,7 +78,7 @@ static ByteBuffer compress_pixel_data(const ByteBuffer& pixel_data, BMPWriter::C
VERIFY_NOT_REACHED();
}
ByteBuffer BMPWriter::dump(const RefPtr<Bitmap> bitmap, DibHeader dib_header)
ByteBuffer BMPWriter::dump(RefPtr<Bitmap> const bitmap, DibHeader dib_header)
{
switch (dib_header) {

2
Userland/Libraries/LibGfx/BMPWriter.h
View file

@ -27,7 +27,7 @@ public:
V4 = 108,
};
ByteBuffer dump(const RefPtr<Bitmap>, DibHeader dib_header = DibHeader::V4);
ByteBuffer dump(RefPtr<Bitmap> const, DibHeader dib_header = DibHeader::V4);
inline void set_compression(Compression compression) { m_compression = compression; }

2
Userland/Libraries/LibGfx/BitmapFont.cpp
View file

@ -173,7 +173,7 @@ BitmapFont::~BitmapFont()
RefPtr<BitmapFont> BitmapFont::load_from_memory(u8 const* data)
{
auto const& header = *reinterpret_cast<const FontFileHeader*>(data);
auto const& header = *reinterpret_cast<FontFileHeader const*>(data);
if (memcmp(header.magic, "!Fnt", 4)) {
dbgln("header.magic != '!Fnt', instead it's '{:c}{:c}{:c}{:c}'", header.magic[0], header.magic[1], header.magic[2], header.magic[3]);
return nullptr;

22
Userland/Libraries/LibGfx/ClassicWindowTheme.cpp
View file

@ -16,7 +16,7 @@ namespace Gfx {
static constexpr int menubar_height = 20;
Gfx::IntRect ClassicWindowTheme::titlebar_icon_rect(WindowType window_type, const IntRect& window_rect, const Palette& palette) const
Gfx::IntRect ClassicWindowTheme::titlebar_icon_rect(WindowType window_type, IntRect const& window_rect, Palette const& palette) const
{
if (window_type == WindowType::ToolWindow)
return {};
@ -33,7 +33,7 @@ Gfx::IntRect ClassicWindowTheme::titlebar_icon_rect(WindowType window_type, cons
return icon_rect;
}
Gfx::IntRect ClassicWindowTheme::titlebar_text_rect(WindowType window_type, const IntRect& window_rect, const Palette& palette) const
Gfx::IntRect ClassicWindowTheme::titlebar_text_rect(WindowType window_type, IntRect const& window_rect, Palette const& palette) const
{
auto titlebar_rect = this->titlebar_rect(window_type, window_rect, palette);
auto titlebar_icon_rect = this->titlebar_icon_rect(window_type, window_rect, palette);
@ -45,7 +45,7 @@ Gfx::IntRect ClassicWindowTheme::titlebar_text_rect(WindowType window_type, cons
};
}
void ClassicWindowTheme::paint_normal_frame(Painter& painter, WindowState window_state, const IntRect& window_rect, StringView window_title, const Bitmap& icon, const Palette& palette, const IntRect& leftmost_button_rect, int menu_row_count, [[maybe_unused]] bool window_modified) const
void ClassicWindowTheme::paint_normal_frame(Painter& painter, WindowState window_state, IntRect const& window_rect, StringView window_title, Bitmap const& icon, Palette const& palette, IntRect const& leftmost_button_rect, int menu_row_count, [[maybe_unused]] bool window_modified) const
{
auto frame_rect = frame_rect_for_window(WindowType::Normal, window_rect, palette, menu_row_count);
frame_rect.set_location({ 0, 0 });
@ -112,7 +112,7 @@ void ClassicWindowTheme::paint_normal_frame(Painter& painter, WindowState window
painter.draw_scaled_bitmap(titlebar_icon_rect, icon, icon.rect());
}
void ClassicWindowTheme::paint_tool_window_frame(Painter& painter, WindowState window_state, const IntRect& window_rect, StringView title_text, const Palette& palette, const IntRect& leftmost_button_rect) const
void ClassicWindowTheme::paint_tool_window_frame(Painter& painter, WindowState window_state, IntRect const& window_rect, StringView title_text, Palette const& palette, IntRect const& leftmost_button_rect) const
{
auto frame_rect = frame_rect_for_window(WindowType::ToolWindow, window_rect, palette, 0);
frame_rect.set_location({ 0, 0 });
@ -143,14 +143,14 @@ void ClassicWindowTheme::paint_tool_window_frame(Painter& painter, WindowState w
}
}
IntRect ClassicWindowTheme::menubar_rect(WindowType window_type, const IntRect& window_rect, const Palette& palette, int menu_row_count) const
IntRect ClassicWindowTheme::menubar_rect(WindowType window_type, IntRect const& window_rect, Palette const& palette, int menu_row_count) const
{
if (window_type != WindowType::Normal)
return {};
return { palette.window_border_thickness(), palette.window_border_thickness() - 1 + titlebar_height(window_type, palette) + 2, window_rect.width(), menubar_height * menu_row_count };
}
IntRect ClassicWindowTheme::titlebar_rect(WindowType window_type, const IntRect& window_rect, const Palette& palette) const
IntRect ClassicWindowTheme::titlebar_rect(WindowType window_type, IntRect const& window_rect, Palette const& palette) const
{
auto& title_font = FontDatabase::default_font().bold_variant();
auto window_titlebar_height = titlebar_height(window_type, palette);
@ -162,7 +162,7 @@ IntRect ClassicWindowTheme::titlebar_rect(WindowType window_type, const IntRect&
return { palette.window_border_thickness(), palette.window_border_thickness(), window_rect.width(), window_titlebar_height };
}
ClassicWindowTheme::FrameColors ClassicWindowTheme::compute_frame_colors(WindowState state, const Palette& palette) const
ClassicWindowTheme::FrameColors ClassicWindowTheme::compute_frame_colors(WindowState state, Palette const& palette) const
{
switch (state) {
case WindowState::Highlighted:
@ -178,7 +178,7 @@ ClassicWindowTheme::FrameColors ClassicWindowTheme::compute_frame_colors(WindowS
}
}
void ClassicWindowTheme::paint_notification_frame(Painter& painter, const IntRect& window_rect, const Palette& palette, const IntRect& close_button_rect) const
void ClassicWindowTheme::paint_notification_frame(Painter& painter, IntRect const& window_rect, Palette const& palette, IntRect const& close_button_rect) const
{
auto frame_rect = frame_rect_for_window(WindowType::Notification, window_rect, palette, 0);
frame_rect.set_location({ 0, 0 });
@ -198,7 +198,7 @@ void ClassicWindowTheme::paint_notification_frame(Painter& painter, const IntRec
}
}
IntRect ClassicWindowTheme::frame_rect_for_window(WindowType window_type, const IntRect& window_rect, const Gfx::Palette& palette, int menu_row_count) const
IntRect ClassicWindowTheme::frame_rect_for_window(WindowType window_type, IntRect const& window_rect, Gfx::Palette const& palette, int menu_row_count) const
{
auto window_titlebar_height = titlebar_height(window_type, palette);
auto border_thickness = palette.window_border_thickness();
@ -224,7 +224,7 @@ IntRect ClassicWindowTheme::frame_rect_for_window(WindowType window_type, const
}
}
Vector<IntRect> ClassicWindowTheme::layout_buttons(WindowType window_type, const IntRect& window_rect, const Palette& palette, size_t buttons) const
Vector<IntRect> ClassicWindowTheme::layout_buttons(WindowType window_type, IntRect const& window_rect, Palette const& palette, size_t buttons) const
{
int window_button_width = palette.window_title_button_width();
int window_button_height = palette.window_title_button_height();
@ -252,7 +252,7 @@ Vector<IntRect> ClassicWindowTheme::layout_buttons(WindowType window_type, const
return button_rects;
}
int ClassicWindowTheme::titlebar_height(WindowType window_type, const Palette& palette) const
int ClassicWindowTheme::titlebar_height(WindowType window_type, Palette const& palette) const
{
auto& title_font = FontDatabase::default_font().bold_variant();
switch (window_type) {

24
Userland/Libraries/LibGfx/ClassicWindowTheme.h
View file

@ -16,22 +16,22 @@ public:
ClassicWindowTheme() = default;
virtual ~ClassicWindowTheme() override = default;
virtual void paint_normal_frame(Painter& painter, WindowState window_state, const IntRect& window_rect, StringView window_title, const Bitmap& icon, const Palette& palette, const IntRect& leftmost_button_rect, int menu_row_count, bool window_modified) const override;
virtual void paint_tool_window_frame(Painter&, WindowState, const IntRect& window_rect, StringView title, const Palette&, const IntRect& leftmost_button_rect) const override;
virtual void paint_notification_frame(Painter&, const IntRect& window_rect, const Palette&, const IntRect& close_button_rect) const override;
virtual void paint_normal_frame(Painter& painter, WindowState window_state, IntRect const& window_rect, StringView window_title, Bitmap const& icon, Palette const& palette, IntRect const& leftmost_button_rect, int menu_row_count, bool window_modified) const override;
virtual void paint_tool_window_frame(Painter&, WindowState, IntRect const& window_rect, StringView title, Palette const&, IntRect const& leftmost_button_rect) const override;
virtual void paint_notification_frame(Painter&, IntRect const& window_rect, Palette const&, IntRect const& close_button_rect) const override;
virtual int titlebar_height(WindowType, const Palette&) const override;
virtual IntRect titlebar_rect(WindowType, const IntRect& window_rect, const Palette&) const override;
virtual IntRect titlebar_icon_rect(WindowType, const IntRect& window_rect, const Palette&) const override;
virtual IntRect titlebar_text_rect(WindowType, const IntRect& window_rect, const Palette&) const override;
virtual int titlebar_height(WindowType, Palette const&) const override;
virtual IntRect titlebar_rect(WindowType, IntRect const& window_rect, Palette const&) const override;
virtual IntRect titlebar_icon_rect(WindowType, IntRect const& window_rect, Palette const&) const override;
virtual IntRect titlebar_text_rect(WindowType, IntRect const& window_rect, Palette const&) const override;
virtual IntRect menubar_rect(WindowType, const IntRect& window_rect, const Palette&, int menu_row_count) const override;
virtual IntRect menubar_rect(WindowType, IntRect const& window_rect, Palette const&, int menu_row_count) const override;
virtual IntRect frame_rect_for_window(WindowType, const IntRect& window_rect, const Palette&, int menu_row_count) const override;
virtual IntRect frame_rect_for_window(WindowType, IntRect const& window_rect, Palette const&, int menu_row_count) const override;
virtual Vector<IntRect> layout_buttons(WindowType, const IntRect& window_rect, const Palette&, size_t buttons) const override;
virtual Vector<IntRect> layout_buttons(WindowType, IntRect const& window_rect, Palette const&, size_t buttons) const override;
virtual bool is_simple_rect_frame() const override { return true; }
virtual bool frame_uses_alpha(WindowState state, const Palette& palette) const override
virtual bool frame_uses_alpha(WindowState state, Palette const& palette) const override
{
return compute_frame_colors(state, palette).uses_alpha();
}
@ -54,7 +54,7 @@ private:
}
};
FrameColors compute_frame_colors(WindowState, const Palette&) const;
FrameColors compute_frame_colors(WindowState, Palette const&) const;
};
}

2
Userland/Libraries/LibGfx/Color.h
View file

@ -185,7 +185,7 @@ public:
source.blue()
};
const int d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
int const d = 255 * (alpha() + source.alpha()) - alpha() * source.alpha();
const i32x4 out = (color * alpha() * (255 - source.alpha()) + 255 * source.alpha() * source_color) / d;
return Color(out[0], out[1], out[2], d / 255);
#else

4
Userland/Libraries/LibGfx/DDSLoader.cpp
View file

@ -34,7 +34,7 @@ struct DDSLoadingContext {
State state { State::NotDecoded };
const u8* data { nullptr };
u8 const* data { nullptr };
size_t data_size { 0 };
DDSHeader header;
@ -937,7 +937,7 @@ void DDSLoadingContext::dump_debug()
dbgln("{}", builder.to_string());
}
DDSImageDecoderPlugin::DDSImageDecoderPlugin(const u8* data, size_t size)
DDSImageDecoderPlugin::DDSImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<DDSLoadingContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/DDSLoader.h
View file

@ -236,7 +236,7 @@ struct DDSLoadingContext;
class DDSImageDecoderPlugin final : public ImageDecoderPlugin {
public:
virtual ~DDSImageDecoderPlugin() override;
DDSImageDecoderPlugin(const u8*, size_t);
DDSImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;

16
Userland/Libraries/LibGfx/DisjointRectSet.cpp
View file

@ -8,7 +8,7 @@
namespace Gfx {
bool DisjointRectSet::add_no_shatter(const IntRect& new_rect)
bool DisjointRectSet::add_no_shatter(IntRect const& new_rect)
{
if (new_rect.is_empty())
return false;
@ -59,7 +59,7 @@ void DisjointRectSet::move_by(int dx, int dy)
r.translate_by(dx, dy);
}
bool DisjointRectSet::contains(const IntRect& rect) const
bool DisjointRectSet::contains(IntRect const& rect) const
{
if (is_empty() || rect.is_empty())
return false;
@ -75,7 +75,7 @@ bool DisjointRectSet::contains(const IntRect& rect) const
return false;
}
bool DisjointRectSet::intersects(const IntRect& rect) const
bool DisjointRectSet::intersects(IntRect const& rect) const
{
for (auto& r : m_rects) {
if (r.intersects(rect))
@ -84,7 +84,7 @@ bool DisjointRectSet::intersects(const IntRect& rect) const
return false;
}
bool DisjointRectSet::intersects(const DisjointRectSet& rects) const
bool DisjointRectSet::intersects(DisjointRectSet const& rects) const
{
if (this == &rects)
return true;
@ -98,7 +98,7 @@ bool DisjointRectSet::intersects(const DisjointRectSet& rects) const
return false;
}
DisjointRectSet DisjointRectSet::intersected(const IntRect& rect) const
DisjointRectSet DisjointRectSet::intersected(IntRect const& rect) const
{
DisjointRectSet intersected_rects;
intersected_rects.m_rects.ensure_capacity(m_rects.capacity());
@ -111,7 +111,7 @@ DisjointRectSet DisjointRectSet::intersected(const IntRect& rect) const
return intersected_rects;
}
DisjointRectSet DisjointRectSet::intersected(const DisjointRectSet& rects) const
DisjointRectSet DisjointRectSet::intersected(DisjointRectSet const& rects) const
{
if (&rects == this)
return clone();
@ -131,7 +131,7 @@ DisjointRectSet DisjointRectSet::intersected(const DisjointRectSet& rects) const
return intersected_rects;
}
DisjointRectSet DisjointRectSet::shatter(const IntRect& hammer) const
DisjointRectSet DisjointRectSet::shatter(IntRect const& hammer) const
{
if (hammer.is_empty())
return clone();
@ -145,7 +145,7 @@ DisjointRectSet DisjointRectSet::shatter(const IntRect& hammer) const
return shards;
}
DisjointRectSet DisjointRectSet::shatter(const DisjointRectSet& hammer) const
DisjointRectSet DisjointRectSet::shatter(DisjointRectSet const& hammer) const
{
if (this == &hammer)
return {};

38
Userland/Libraries/LibGfx/DisjointRectSet.h
View file

@ -14,13 +14,13 @@ namespace Gfx {
class DisjointRectSet {
public:
DisjointRectSet(const DisjointRectSet&) = delete;
DisjointRectSet& operator=(const DisjointRectSet&) = delete;
DisjointRectSet(DisjointRectSet const&) = delete;
DisjointRectSet& operator=(DisjointRectSet const&) = delete;
DisjointRectSet() = default;
~DisjointRectSet() = default;
DisjointRectSet(const IntRect& rect)
DisjointRectSet(IntRect const& rect)
{
m_rects.append(rect);
}
@ -36,22 +36,22 @@ public:
}
void move_by(int dx, int dy);
void move_by(const IntPoint& delta)
void move_by(IntPoint const& delta)
{
move_by(delta.x(), delta.y());
}
void add(const IntRect& rect)
void add(IntRect const& rect)
{
if (add_no_shatter(rect) && m_rects.size() > 1)
shatter();
}
template<typename Container>
void add_many(const Container& rects)
void add_many(Container const& rects)
{
bool added = false;
for (const auto& rect : rects) {
for (auto const& rect : rects) {
if (add_no_shatter(rect))
added = true;
}
@ -59,7 +59,7 @@ public:
shatter();
}
void add(const DisjointRectSet& rect_set)
void add(DisjointRectSet const& rect_set)
{
if (this == &rect_set)
return;
@ -70,17 +70,17 @@ public:
}
}
DisjointRectSet shatter(const IntRect&) const;
DisjointRectSet shatter(const DisjointRectSet& hammer) const;
DisjointRectSet shatter(IntRect const&) const;
DisjointRectSet shatter(DisjointRectSet const& hammer) const;
bool contains(const IntRect&) const;
bool intersects(const IntRect&) const;
bool intersects(const DisjointRectSet&) const;
DisjointRectSet intersected(const IntRect&) const;
DisjointRectSet intersected(const DisjointRectSet&) const;
bool contains(IntRect const&) const;
bool intersects(IntRect const&) const;
bool intersects(DisjointRectSet const&) const;
DisjointRectSet intersected(IntRect const&) const;
DisjointRectSet intersected(DisjointRectSet const&) const;
template<typename Function>
IterationDecision for_each_intersected(const IntRect& rect, Function f) const
IterationDecision for_each_intersected(IntRect const& rect, Function f) const
{
if (is_empty() || rect.is_empty())
return IterationDecision::Continue;
@ -96,7 +96,7 @@ public:
}
template<typename Function>
IterationDecision for_each_intersected(const DisjointRectSet& rects, Function f) const
IterationDecision for_each_intersected(DisjointRectSet const& rects, Function f) const
{
if (is_empty() || rects.is_empty())
return IterationDecision::Continue;
@ -126,7 +126,7 @@ public:
void clear() { m_rects.clear(); }
void clear_with_capacity() { m_rects.clear_with_capacity(); }
const Vector<IntRect, 32>& rects() const { return m_rects; }
Vector<IntRect, 32> const& rects() const { return m_rects; }
Vector<IntRect, 32> take_rects() { return move(m_rects); }
void translate_by(int dx, int dy)
@ -141,7 +141,7 @@ public:
}
private:
bool add_no_shatter(const IntRect&);
bool add_no_shatter(IntRect const&);
void shatter();
Vector<IntRect, 32> m_rects;

10
Userland/Libraries/LibGfx/Filters/GenericConvolutionFilter.h
View file

@ -34,14 +34,14 @@ class GenericConvolutionFilter : public Filter {
public:
class Parameters : public Filter::Parameters {
public:
Parameters(const Gfx::Matrix<N, float>& kernel, bool should_wrap = false)
Parameters(Gfx::Matrix<N, float> const& kernel, bool should_wrap = false)
: m_kernel(kernel)
, m_should_wrap(should_wrap)
{
}
const Gfx::Matrix<N, float>& kernel() const { return m_kernel; }
Gfx::Matrix<N, float> const& kernel() const { return m_kernel; }
Gfx::Matrix<N, float>& kernel() { return m_kernel; }
bool should_wrap() const { return m_should_wrap; }
@ -64,16 +64,16 @@ public:
virtual StringView class_name() const override { return "GenericConvolutionFilter"sv; }
virtual void apply(Bitmap& target_bitmap, const IntRect& target_rect, const Bitmap& source_bitmap, const IntRect& source_rect, const Filter::Parameters& parameters) override
virtual void apply(Bitmap& target_bitmap, IntRect const& target_rect, Bitmap const& source_bitmap, IntRect const& source_rect, Filter::Parameters const& parameters) override
{
VERIFY(parameters.is_generic_convolution_filter());
auto& gcf_params = static_cast<const GenericConvolutionFilter::Parameters&>(parameters);
auto& gcf_params = static_cast<GenericConvolutionFilter::Parameters const&>(parameters);
ApplyCache apply_cache;
apply_with_cache(target_bitmap, target_rect, source_bitmap, source_rect, gcf_params, apply_cache);
}
void apply_with_cache(Bitmap& target, IntRect target_rect, const Bitmap& source, const IntRect& source_rect, const GenericConvolutionFilter::Parameters& parameters, ApplyCache& apply_cache)
void apply_with_cache(Bitmap& target, IntRect target_rect, Bitmap const& source, IntRect const& source_rect, GenericConvolutionFilter::Parameters const& parameters, ApplyCache& apply_cache)
{
// The target area (where the filter is applied) must be entirely
// contained by the source area. source_rect should be describing

10
Userland/Libraries/LibGfx/Font.h
View file

@ -22,7 +22,7 @@ namespace Gfx {
class GlyphBitmap {
public:
GlyphBitmap() = default;
GlyphBitmap(const u8* rows, size_t start_index, IntSize size)
GlyphBitmap(u8 const* rows, size_t start_index, IntSize size)
: m_rows(rows)
, m_start_index(start_index)
, m_size(size)
@ -48,14 +48,14 @@ private:
return { const_cast<u8*>(m_rows) + bytes_per_row() * (m_start_index + y), bytes_per_row() * 8 };
}
const u8* m_rows { nullptr };
u8 const* m_rows { nullptr };
size_t m_start_index { 0 };
IntSize m_size { 0, 0 };
};
class Glyph {
public:
Glyph(const GlyphBitmap& glyph_bitmap, int left_bearing, int advance, int ascent)
Glyph(GlyphBitmap const& glyph_bitmap, int left_bearing, int advance, int ascent)
: m_glyph_bitmap(glyph_bitmap)
, m_left_bearing(left_bearing)
, m_advance(advance)
@ -140,8 +140,8 @@ public:
virtual u8 mean_line() const = 0;
virtual int width(StringView) const = 0;
virtual int width(const Utf8View&) const = 0;
virtual int width(const Utf32View&) const = 0;
virtual int width(Utf8View const&) const = 0;
virtual int width(Utf32View const&) const = 0;
virtual String name() const = 0;

8
Userland/Libraries/LibGfx/FontDatabase.cpp
View file

@ -119,7 +119,7 @@ FontDatabase::FontDatabase()
}
}
void FontDatabase::for_each_font(Function<void(const Gfx::Font&)> callback)
void FontDatabase::for_each_font(Function<void(Gfx::Font const&)> callback)
{
Vector<RefPtr<Gfx::Font>> fonts;
fonts.ensure_capacity(m_private->full_name_to_font_map.size());
@ -130,7 +130,7 @@ void FontDatabase::for_each_font(Function<void(const Gfx::Font&)> callback)
callback(*font);
}
void FontDatabase::for_each_fixed_width_font(Function<void(const Gfx::Font&)> callback)
void FontDatabase::for_each_fixed_width_font(Function<void(Gfx::Font const&)> callback)
{
Vector<RefPtr<Gfx::Font>> fonts;
fonts.ensure_capacity(m_private->full_name_to_font_map.size());
@ -179,7 +179,7 @@ RefPtr<Gfx::Font> FontDatabase::get(FlyString const& family, FlyString const& va
return nullptr;
}
RefPtr<Typeface> FontDatabase::get_or_create_typeface(const String& family, const String& variant)
RefPtr<Typeface> FontDatabase::get_or_create_typeface(String const& family, String const& variant)
{
for (auto typeface : m_private->typefaces) {
if (typeface->family() == family && typeface->variant() == variant)
@ -190,7 +190,7 @@ RefPtr<Typeface> FontDatabase::get_or_create_typeface(const String& family, cons
return typeface;
}
void FontDatabase::for_each_typeface(Function<void(const Typeface&)> callback)
void FontDatabase::for_each_typeface(Function<void(Typeface const&)> callback)
{
for (auto typeface : m_private->typefaces) {
callback(*typeface);

8
Userland/Libraries/LibGfx/FontDatabase.h
View file

@ -47,16 +47,16 @@ public:
RefPtr<Gfx::Font> get(FlyString const& family, float point_size, unsigned weight, unsigned slope, Font::AllowInexactSizeMatch = Font::AllowInexactSizeMatch::No);
RefPtr<Gfx::Font> get(FlyString const& family, FlyString const& variant, float point_size, Font::AllowInexactSizeMatch = Font::AllowInexactSizeMatch::No);
RefPtr<Gfx::Font> get_by_name(StringView);
void for_each_font(Function<void(const Gfx::Font&)>);
void for_each_fixed_width_font(Function<void(const Gfx::Font&)>);
void for_each_font(Function<void(Gfx::Font const&)>);
void for_each_fixed_width_font(Function<void(Gfx::Font const&)>);
void for_each_typeface(Function<void(const Typeface&)>);
void for_each_typeface(Function<void(Typeface const&)>);
private:
FontDatabase();
~FontDatabase() = default;
RefPtr<Typeface> get_or_create_typeface(const String& family, const String& variant);
RefPtr<Typeface> get_or_create_typeface(String const& family, String const& variant);
struct Private;
OwnPtr<Private> m_private;

2
Userland/Libraries/LibGfx/FontStyleMapping.h
View file

@ -12,7 +12,7 @@
namespace Gfx {
struct FontStyleMapping {
constexpr FontStyleMapping(int s, const char* n)
constexpr FontStyleMapping(int s, char const* n)
: style(s)
, name(n)
{

26
Userland/Libraries/LibGfx/GIFLoader.cpp
View file

@ -70,7 +70,7 @@ struct GIFLoadingContext {
FailedToLoadFrameDescriptors,
};
ErrorState error_state { NoError };
const u8* data { nullptr };
u8 const* data { nullptr };
size_t data_size { 0 };
LogicalScreen logical_screen {};
u8 background_color_index { 0 };
@ -110,7 +110,7 @@ private:
static constexpr int max_code_size = 12;
public:
explicit LZWDecoder(const Vector<u8>& lzw_bytes, u8 min_code_size)
explicit LZWDecoder(Vector<u8> const& lzw_bytes, u8 min_code_size)
: m_lzw_bytes(lzw_bytes)
, m_code_size(min_code_size)
, m_original_code_size(min_code_size)
@ -160,7 +160,7 @@ public:
for (int i = 0; current_byte_index + i < m_lzw_bytes.size(); ++i) {
padded_last_bytes[i] = m_lzw_bytes[current_byte_index + i];
}
const u32* addr = (const u32*)&padded_last_bytes;
u32 const* addr = (u32 const*)&padded_last_bytes;
m_current_code = (*addr & mask) >> current_bit_offset;
} else {
u32 tmp_word;
@ -213,7 +213,7 @@ private:
m_original_code_table = m_code_table;
}
void extend_code_table(const Vector<u8>& entry)
void extend_code_table(Vector<u8> const& entry)
{
if (entry.size() > 1 && m_code_table.size() < 4096) {
m_code_table.append(entry);
@ -224,7 +224,7 @@ private:
}
}
const Vector<u8>& m_lzw_bytes;
Vector<u8> const& m_lzw_bytes;
int m_current_bit_index { 0 };
@ -240,13 +240,13 @@ private:
Vector<u8> m_output {};
};
static void copy_frame_buffer(Bitmap& dest, const Bitmap& src)
static void copy_frame_buffer(Bitmap& dest, Bitmap const& src)
{
VERIFY(dest.size_in_bytes() == src.size_in_bytes());
memcpy(dest.scanline(0), src.scanline(0), dest.size_in_bytes());
}
static void clear_rect(Bitmap& bitmap, const IntRect& rect, Color color)
static void clear_rect(Bitmap& bitmap, IntRect const& rect, Color color)
{
auto intersection_rect = rect.intersected(bitmap.rect());
if (intersection_rect.is_empty())
@ -293,7 +293,7 @@ static bool decode_frame(GIFLoadingContext& context, size_t frame_index)
for (size_t i = start_frame; i <= frame_index; ++i) {
auto& image = context.images.at(i);
const auto previous_image_disposal_method = i > 0 ? context.images.at(i - 1).disposal_method : GIFImageDescriptor::DisposalMethod::None;
auto const previous_image_disposal_method = i > 0 ? context.images.at(i - 1).disposal_method : GIFImageDescriptor::DisposalMethod::None;
if (i == 0) {
context.frame_buffer->fill(Color::Transparent);
@ -324,10 +324,10 @@ static bool decode_frame(GIFLoadingContext& context, size_t frame_index)
LZWDecoder decoder(image.lzw_encoded_bytes, image.lzw_min_code_size);
// Add GIF-specific control codes
const int clear_code = decoder.add_control_code();
const int end_of_information_code = decoder.add_control_code();
int const clear_code = decoder.add_control_code();
int const end_of_information_code = decoder.add_control_code();
const auto& color_map = image.use_global_color_map ? context.logical_screen.color_map : image.color_map;
auto const& color_map = image.use_global_color_map ? context.logical_screen.color_map : image.color_map;
int pixel_index = 0;
int row = 0;
@ -349,7 +349,7 @@ static bool decode_frame(GIFLoadingContext& context, size_t frame_index)
continue;
auto colors = decoder.get_output();
for (const auto& color : colors) {
for (auto const& color : colors) {
auto c = color_map[color];
int x = pixel_index % image.width + image.x;
@ -599,7 +599,7 @@ static bool load_gif_frame_descriptors(GIFLoadingContext& context)
return true;
}
GIFImageDecoderPlugin::GIFImageDecoderPlugin(const u8* data, size_t size)
GIFImageDecoderPlugin::GIFImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<GIFLoadingContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/GIFLoader.h
View file

@ -16,7 +16,7 @@ struct GIFLoadingContext;
class GIFImageDecoderPlugin final : public ImageDecoderPlugin {
public:
virtual ~GIFImageDecoderPlugin() override;
GIFImageDecoderPlugin(const u8*, size_t);
GIFImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;

14
Userland/Libraries/LibGfx/ICOLoader.cpp
View file

@ -83,7 +83,7 @@ struct ICOLoadingContext {
BitmapDecoded
};
State state { NotDecoded };
const u8* data { nullptr };
u8 const* data { nullptr };
size_t data_size { 0 };
Vector<ICOImageDescriptor> images;
size_t largest_index;
@ -117,12 +117,12 @@ static Optional<ICOImageDescriptor> decode_ico_direntry(InputMemoryStream& strea
return { desc };
}
static size_t find_largest_image(const ICOLoadingContext& context)
static size_t find_largest_image(ICOLoadingContext const& context)
{
size_t max_area = 0;
size_t index = 0;
size_t largest_index = 0;
for (const auto& desc : context.images) {
for (auto const& desc : context.images) {
if (desc.width * desc.height > max_area) {
max_area = desc.width * desc.height;
largest_index = index;
@ -227,11 +227,11 @@ static bool load_ico_bmp(ICOLoadingContext& context, ICOImageDescriptor& desc)
return false;
desc.bitmap = bitmap_or_error.release_value_but_fixme_should_propagate_errors();
Bitmap& bitmap = *desc.bitmap;
const u8* image_base = context.data + desc.offset + sizeof(info);
u8 const* image_base = context.data + desc.offset + sizeof(info);
const BMP_ARGB* data_base = (const BMP_ARGB*)image_base;
const u8* mask_base = image_base + desc.width * desc.height * sizeof(BMP_ARGB);
u8 const* mask_base = image_base + desc.width * desc.height * sizeof(BMP_ARGB);
for (int y = 0; y < desc.height; y++) {
const u8* row_mask = mask_base + mask_row_len * y;
u8 const* row_mask = mask_base + mask_row_len * y;
const BMP_ARGB* row_data = data_base + desc.width * y;
for (int x = 0; x < desc.width; x++) {
u8 mask = !!(row_mask[x / 8] & (0x80 >> (x % 8)));
@ -279,7 +279,7 @@ static bool load_ico_bitmap(ICOLoadingContext& context, Optional<size_t> index)
}
}
ICOImageDecoderPlugin::ICOImageDecoderPlugin(const u8* data, size_t size)
ICOImageDecoderPlugin::ICOImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<ICOLoadingContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/ICOLoader.h
View file

@ -15,7 +15,7 @@ struct ICOLoadingContext;
class ICOImageDecoderPlugin final : public ImageDecoderPlugin {
public:
virtual ~ICOImageDecoderPlugin() override;
ICOImageDecoderPlugin(const u8*, size_t);
ICOImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;

250
Userland/Libraries/LibGfx/JPGLoader.cpp
View file

@ -172,7 +172,7 @@ struct JPGLoadingContext {
};
State state { State::NotDecoded };
const u8* data { nullptr };
u8 const* data { nullptr };
size_t data_size { 0 };
u32 luma_table[64] = { 0 };
u32 chroma_table[64] = { 0 };
@ -224,7 +224,7 @@ static Optional<size_t> read_huffman_bits(HuffmanStreamState& hstream, size_t co
return value;
}
static Optional<u8> get_next_symbol(HuffmanStreamState& hstream, const HuffmanTableSpec& table)
static Optional<u8> get_next_symbol(HuffmanStreamState& hstream, HuffmanTableSpec const& table)
{
unsigned code = 0;
size_t code_cursor = 0;
@ -649,7 +649,7 @@ static bool read_huffman_table(InputMemoryStream& stream, JPGLoadingContext& con
return true;
}
static inline bool validate_luma_and_modify_context(const ComponentSpec& luma, JPGLoadingContext& context)
static inline bool validate_luma_and_modify_context(ComponentSpec const& luma, JPGLoadingContext& context)
{
if ((luma.hsample_factor == 1 || luma.hsample_factor == 2) && (luma.vsample_factor == 1 || luma.vsample_factor == 2)) {
context.mblock_meta.hpadded_count += luma.hsample_factor == 1 ? 0 : context.mblock_meta.hcount % 2;
@ -847,7 +847,7 @@ static void dequantize(JPGLoadingContext& context, Vector<Macroblock>& macrobloc
for (u32 hcursor = 0; hcursor < context.mblock_meta.hcount; hcursor += context.hsample_factor) {
for (u32 i = 0; i < context.component_count; i++) {
auto& component = context.components[i];
const u32* table = component.qtable_id == 0 ? context.luma_table : context.chroma_table;
u32 const* table = component.qtable_id == 0 ? context.luma_table : context.chroma_table;
for (u32 vfactor_i = 0; vfactor_i < component.vsample_factor; vfactor_i++) {
for (u32 hfactor_i = 0; hfactor_i < component.hsample_factor; hfactor_i++) {
u32 mb_index = (vcursor + vfactor_i) * context.mblock_meta.hpadded_count + (hfactor_i + hcursor);
@ -862,22 +862,22 @@ static void dequantize(JPGLoadingContext& context, Vector<Macroblock>& macrobloc
}
}
static void inverse_dct(const JPGLoadingContext& context, Vector<Macroblock>& macroblocks)
static void inverse_dct(JPGLoadingContext const& context, Vector<Macroblock>& macroblocks)
{
static const float m0 = 2.0 * AK::cos(1.0 / 16.0 * 2.0 * AK::Pi<double>);
static const float m1 = 2.0 * AK::cos(2.0 / 16.0 * 2.0 * AK::Pi<double>);
static const float m3 = 2.0 * AK::cos(2.0 / 16.0 * 2.0 * AK::Pi<double>);
static const float m5 = 2.0 * AK::cos(3.0 / 16.0 * 2.0 * AK::Pi<double>);
static const float m2 = m0 - m5;
static const float m4 = m0 + m5;
static const float s0 = AK::cos(0.0 / 16.0 * AK::Pi<double>) / sqrt(8);
static const float s1 = AK::cos(1.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s2 = AK::cos(2.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s3 = AK::cos(3.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s4 = AK::cos(4.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s5 = AK::cos(5.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s6 = AK::cos(6.0 / 16.0 * AK::Pi<double>) / 2.0;
static const float s7 = AK::cos(7.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const m0 = 2.0 * AK::cos(1.0 / 16.0 * 2.0 * AK::Pi<double>);
static float const m1 = 2.0 * AK::cos(2.0 / 16.0 * 2.0 * AK::Pi<double>);
static float const m3 = 2.0 * AK::cos(2.0 / 16.0 * 2.0 * AK::Pi<double>);
static float const m5 = 2.0 * AK::cos(3.0 / 16.0 * 2.0 * AK::Pi<double>);
static float const m2 = m0 - m5;
static float const m4 = m0 + m5;
static float const s0 = AK::cos(0.0 / 16.0 * AK::Pi<double>) / sqrt(8);
static float const s1 = AK::cos(1.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s2 = AK::cos(2.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s3 = AK::cos(3.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s4 = AK::cos(4.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s5 = AK::cos(5.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s6 = AK::cos(6.0 / 16.0 * AK::Pi<double>) / 2.0;
static float const s7 = AK::cos(7.0 / 16.0 * AK::Pi<double>) / 2.0;
for (u32 vcursor = 0; vcursor < context.mblock_meta.vcount; vcursor += context.vsample_factor) {
for (u32 hcursor = 0; hcursor < context.mblock_meta.hcount; hcursor += context.hsample_factor) {
@ -889,62 +889,62 @@ static void inverse_dct(const JPGLoadingContext& context, Vector<Macroblock>& ma
Macroblock& block = macroblocks[mb_index];
i32* block_component = get_component(block, component_i);
for (u32 k = 0; k < 8; ++k) {
const float g0 = block_component[0 * 8 + k] * s0;
const float g1 = block_component[4 * 8 + k] * s4;
const float g2 = block_component[2 * 8 + k] * s2;
const float g3 = block_component[6 * 8 + k] * s6;
const float g4 = block_component[5 * 8 + k] * s5;
const float g5 = block_component[1 * 8 + k] * s1;
const float g6 = block_component[7 * 8 + k] * s7;
const float g7 = block_component[3 * 8 + k] * s3;
float const g0 = block_component[0 * 8 + k] * s0;
float const g1 = block_component[4 * 8 + k] * s4;
float const g2 = block_component[2 * 8 + k] * s2;
float const g3 = block_component[6 * 8 + k] * s6;
float const g4 = block_component[5 * 8 + k] * s5;
float const g5 = block_component[1 * 8 + k] * s1;
float const g6 = block_component[7 * 8 + k] * s7;
float const g7 = block_component[3 * 8 + k] * s3;
const float f0 = g0;
const float f1 = g1;
const float f2 = g2;
const float f3 = g3;
const float f4 = g4 - g7;
const float f5 = g5 + g6;
const float f6 = g5 - g6;
const float f7 = g4 + g7;
float const f0 = g0;
float const f1 = g1;
float const f2 = g2;
float const f3 = g3;
float const f4 = g4 - g7;
float const f5 = g5 + g6;
float const f6 = g5 - g6;
float const f7 = g4 + g7;
const float e0 = f0;
const float e1 = f1;
const float e2 = f2 - f3;
const float e3 = f2 + f3;
const float e4 = f4;
const float e5 = f5 - f7;
const float e6 = f6;
const float e7 = f5 + f7;
const float e8 = f4 + f6;
float const e0 = f0;
float const e1 = f1;
float const e2 = f2 - f3;
float const e3 = f2 + f3;
float const e4 = f4;
float const e5 = f5 - f7;
float const e6 = f6;
float const e7 = f5 + f7;
float const e8 = f4 + f6;
const float d0 = e0;
const float d1 = e1;
const float d2 = e2 * m1;
const float d3 = e3;
const float d4 = e4 * m2;
const float d5 = e5 * m3;
const float d6 = e6 * m4;
const float d7 = e7;
const float d8 = e8 * m5;
float const d0 = e0;
float const d1 = e1;
float const d2 = e2 * m1;
float const d3 = e3;
float const d4 = e4 * m2;
float const d5 = e5 * m3;
float const d6 = e6 * m4;
float const d7 = e7;
float const d8 = e8 * m5;
const float c0 = d0 + d1;
const float c1 = d0 - d1;
const float c2 = d2 - d3;
const float c3 = d3;
const float c4 = d4 + d8;
const float c5 = d5 + d7;
const float c6 = d6 - d8;
const float c7 = d7;
const float c8 = c5 - c6;
float const c0 = d0 + d1;
float const c1 = d0 - d1;
float const c2 = d2 - d3;
float const c3 = d3;
float const c4 = d4 + d8;
float const c5 = d5 + d7;
float const c6 = d6 - d8;
float const c7 = d7;
float const c8 = c5 - c6;
const float b0 = c0 + c3;
const float b1 = c1 + c2;
const float b2 = c1 - c2;
const float b3 = c0 - c3;
const float b4 = c4 - c8;
const float b5 = c8;
const float b6 = c6 - c7;
const float b7 = c7;
float const b0 = c0 + c3;
float const b1 = c1 + c2;
float const b2 = c1 - c2;
float const b3 = c0 - c3;
float const b4 = c4 - c8;
float const b5 = c8;
float const b6 = c6 - c7;
float const b7 = c7;
block_component[0 * 8 + k] = b0 + b7;
block_component[1 * 8 + k] = b1 + b6;
@ -956,62 +956,62 @@ static void inverse_dct(const JPGLoadingContext& context, Vector<Macroblock>& ma
block_component[7 * 8 + k] = b0 - b7;
}
for (u32 l = 0; l < 8; ++l) {
const float g0 = block_component[l * 8 + 0] * s0;
const float g1 = block_component[l * 8 + 4] * s4;
const float g2 = block_component[l * 8 + 2] * s2;
const float g3 = block_component[l * 8 + 6] * s6;
const float g4 = block_component[l * 8 + 5] * s5;
const float g5 = block_component[l * 8 + 1] * s1;
const float g6 = block_component[l * 8 + 7] * s7;
const float g7 = block_component[l * 8 + 3] * s3;
float const g0 = block_component[l * 8 + 0] * s0;
float const g1 = block_component[l * 8 + 4] * s4;
float const g2 = block_component[l * 8 + 2] * s2;
float const g3 = block_component[l * 8 + 6] * s6;
float const g4 = block_component[l * 8 + 5] * s5;
float const g5 = block_component[l * 8 + 1] * s1;
float const g6 = block_component[l * 8 + 7] * s7;
float const g7 = block_component[l * 8 + 3] * s3;
const float f0 = g0;
const float f1 = g1;
const float f2 = g2;
const float f3 = g3;
const float f4 = g4 - g7;
const float f5 = g5 + g6;
const float f6 = g5 - g6;
const float f7 = g4 + g7;
float const f0 = g0;
float const f1 = g1;
float const f2 = g2;
float const f3 = g3;
float const f4 = g4 - g7;
float const f5 = g5 + g6;
float const f6 = g5 - g6;
float const f7 = g4 + g7;
const float e0 = f0;
const float e1 = f1;
const float e2 = f2 - f3;
const float e3 = f2 + f3;
const float e4 = f4;
const float e5 = f5 - f7;
const float e6 = f6;
const float e7 = f5 + f7;
const float e8 = f4 + f6;
float const e0 = f0;
float const e1 = f1;
float const e2 = f2 - f3;
float const e3 = f2 + f3;
float const e4 = f4;
float const e5 = f5 - f7;
float const e6 = f6;
float const e7 = f5 + f7;
float const e8 = f4 + f6;
const float d0 = e0;
const float d1 = e1;
const float d2 = e2 * m1;
const float d3 = e3;
const float d4 = e4 * m2;
const float d5 = e5 * m3;
const float d6 = e6 * m4;
const float d7 = e7;
const float d8 = e8 * m5;
float const d0 = e0;
float const d1 = e1;
float const d2 = e2 * m1;
float const d3 = e3;
float const d4 = e4 * m2;
float const d5 = e5 * m3;
float const d6 = e6 * m4;
float const d7 = e7;
float const d8 = e8 * m5;
const float c0 = d0 + d1;
const float c1 = d0 - d1;
const float c2 = d2 - d3;
const float c3 = d3;
const float c4 = d4 + d8;
const float c5 = d5 + d7;
const float c6 = d6 - d8;
const float c7 = d7;
const float c8 = c5 - c6;
float const c0 = d0 + d1;
float const c1 = d0 - d1;
float const c2 = d2 - d3;
float const c3 = d3;
float const c4 = d4 + d8;
float const c5 = d5 + d7;
float const c6 = d6 - d8;
float const c7 = d7;
float const c8 = c5 - c6;
const float b0 = c0 + c3;
const float b1 = c1 + c2;
const float b2 = c1 - c2;
const float b3 = c0 - c3;
const float b4 = c4 - c8;
const float b5 = c8;
const float b6 = c6 - c7;
const float b7 = c7;
float const b0 = c0 + c3;
float const b1 = c1 + c2;
float const b2 = c1 - c2;
float const b3 = c0 - c3;
float const b4 = c4 - c8;
float const b5 = c8;
float const b6 = c6 - c7;
float const b7 = c7;
block_component[l * 8 + 0] = b0 + b7;
block_component[l * 8 + 1] = b1 + b6;
@ -1029,12 +1029,12 @@ static void inverse_dct(const JPGLoadingContext& context, Vector<Macroblock>& ma
}
}
static void ycbcr_to_rgb(const JPGLoadingContext& context, Vector<Macroblock>& macroblocks)
static void ycbcr_to_rgb(JPGLoadingContext const& context, Vector<Macroblock>& macroblocks)
{
for (u32 vcursor = 0; vcursor < context.mblock_meta.vcount; vcursor += context.vsample_factor) {
for (u32 hcursor = 0; hcursor < context.mblock_meta.hcount; hcursor += context.hsample_factor) {
const u32 chroma_block_index = vcursor * context.mblock_meta.hpadded_count + hcursor;
const Macroblock& chroma = macroblocks[chroma_block_index];
Macroblock const& chroma = macroblocks[chroma_block_index];
// Overflows are intentional.
for (u8 vfactor_i = context.vsample_factor - 1; vfactor_i < context.vsample_factor; --vfactor_i) {
for (u8 hfactor_i = context.hsample_factor - 1; hfactor_i < context.hsample_factor; --hfactor_i) {
@ -1062,7 +1062,7 @@ static void ycbcr_to_rgb(const JPGLoadingContext& context, Vector<Macroblock>& m
}
}
static bool compose_bitmap(JPGLoadingContext& context, const Vector<Macroblock>& macroblocks)
static bool compose_bitmap(JPGLoadingContext& context, Vector<Macroblock> const& macroblocks)
{
auto bitmap_or_error = Bitmap::try_create(BitmapFormat::BGRx8888, { context.frame.width, context.frame.height });
if (bitmap_or_error.is_error())
@ -1224,7 +1224,7 @@ static bool decode_jpg(JPGLoadingContext& context)
return true;
}
JPGImageDecoderPlugin::JPGImageDecoderPlugin(const u8* data, size_t size)
JPGImageDecoderPlugin::JPGImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<JPGLoadingContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/JPGLoader.h
View file

@ -15,7 +15,7 @@ struct JPGLoadingContext;
class JPGImageDecoderPlugin : public ImageDecoderPlugin {
public:
virtual ~JPGImageDecoderPlugin() override;
JPGImageDecoderPlugin(const u8*, size_t);
JPGImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;
[[nodiscard]] virtual bool set_nonvolatile(bool& was_purged) override;

6
Userland/Libraries/LibGfx/Matrix.h
View file

@ -36,12 +36,12 @@ public:
{
}
Matrix(const Matrix& other)
Matrix(Matrix const& other)
{
__builtin_memcpy(m_elements, other.elements(), sizeof(T) * N * N);
}
Matrix& operator=(const Matrix& other)
Matrix& operator=(Matrix const& other)
{
__builtin_memcpy(m_elements, other.elements(), sizeof(T) * N * N);
return *this;
@ -50,7 +50,7 @@ public:
constexpr auto elements() const { return m_elements; }
constexpr auto elements() { return m_elements; }
constexpr Matrix operator*(const Matrix& other) const
constexpr Matrix operator*(Matrix const& other) const
{
Matrix product;
for (size_t i = 0; i < N; ++i) {

10
Userland/Libraries/LibGfx/Matrix4x4.h
View file

@ -17,7 +17,7 @@ template<typename T>
using Matrix4x4 = Matrix<4, T>;
template<typename T>
constexpr static Vector4<T> operator*(const Matrix4x4<T>& m, const Vector4<T>& v)
constexpr static Vector4<T> operator*(Matrix4x4<T> const& m, Vector4<T> const& v)
{
auto const& elements = m.elements();
return Vector4<T>(
@ -30,7 +30,7 @@ constexpr static Vector4<T> operator*(const Matrix4x4<T>& m, const Vector4<T>& v
// FIXME: this is a specific Matrix4x4 * Vector3 interaction that implies W=1; maybe move this out of LibGfx
// or replace a Matrix4x4 * Vector4 operation?
template<typename T>
constexpr static Vector3<T> transform_point(const Matrix4x4<T>& m, const Vector3<T>& p)
constexpr static Vector3<T> transform_point(Matrix4x4<T> const& m, Vector3<T> const& p)
{
auto const& elements = m.elements();
return Vector3<T>(
@ -40,7 +40,7 @@ constexpr static Vector3<T> transform_point(const Matrix4x4<T>& m, const Vector3
}
template<typename T>
constexpr static Matrix4x4<T> translation_matrix(const Vector3<T>& p)
constexpr static Matrix4x4<T> translation_matrix(Vector3<T> const& p)
{
return Matrix4x4<T>(
1, 0, 0, p.x(),
@ -50,7 +50,7 @@ constexpr static Matrix4x4<T> translation_matrix(const Vector3<T>& p)
}
template<typename T>
constexpr static Matrix4x4<T> scale_matrix(const Vector3<T>& s)
constexpr static Matrix4x4<T> scale_matrix(Vector3<T> const& s)
{
return Matrix4x4<T>(
s.x(), 0, 0, 0,
@ -60,7 +60,7 @@ constexpr static Matrix4x4<T> scale_matrix(const Vector3<T>& s)
}
template<typename T>
constexpr static Matrix4x4<T> rotation_matrix(const Vector3<T>& axis, T angle)
constexpr static Matrix4x4<T> rotation_matrix(Vector3<T> const& axis, T angle)
{
T c, s;
AK::sincos(angle, s, c);

2
Userland/Libraries/LibGfx/PGMLoader.cpp
View file

@ -13,7 +13,7 @@
namespace Gfx {
static void set_adjusted_pixels(PGMLoadingContext& context, const Vector<Gfx::Color>& color_data)
static void set_adjusted_pixels(PGMLoadingContext& context, Vector<Gfx::Color> const& color_data)
{
size_t index = 0;
for (size_t y = 0; y < context.height; ++y) {

48
Userland/Libraries/LibGfx/PNGLoader.cpp
View file

@ -83,7 +83,7 @@ struct PNGLoadingContext {
BitmapDecoded,
};
State state { State::NotDecoded };
const u8* data { nullptr };
u8 const* data { nullptr };
size_t data_size { 0 };
int width { -1 };
int height { -1 };
@ -119,7 +119,7 @@ struct PNGLoadingContext {
class Streamer {
public:
Streamer(const u8* data, size_t size)
Streamer(u8 const* data, size_t size)
: m_data_ptr(data)
, m_size_remaining(size)
{
@ -130,7 +130,7 @@ public:
{
if (m_size_remaining < sizeof(T))
return false;
value = *((const NetworkOrdered<T>*)m_data_ptr);
value = *((NetworkOrdered<T> const*)m_data_ptr);
m_data_ptr += sizeof(T);
m_size_remaining -= sizeof(T);
return true;
@ -159,7 +159,7 @@ public:
bool at_end() const { return !m_size_remaining; }
private:
const u8* m_data_ptr { nullptr };
u8 const* m_data_ptr { nullptr };
size_t m_size_remaining { 0 };
};
@ -191,9 +191,9 @@ union [[gnu::packed]] Pixel {
static_assert(AssertSize<Pixel, 4>());
template<bool has_alpha, u8 filter_type>
ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void* dummy_scanline_data)
ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, void const* dummy_scanline_data)
{
auto* dummy_scanline = (const Pixel*)dummy_scanline_data;
auto* dummy_scanline = (Pixel const*)dummy_scanline_data;
if constexpr (filter_type == 0) {
auto* pixels = (Pixel*)bitmap.scanline(y);
for (int i = 0; i < bitmap.width(); ++i) {
@ -208,7 +208,7 @@ ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void*
for (int i = 1; i < bitmap.width(); ++i) {
auto& x = pixels[i];
swap(x.r, x.b);
auto& a = (const Pixel&)pixels[i - 1];
auto& a = (Pixel const&)pixels[i - 1];
x.v[0] += a.v[0];
x.v[1] += a.v[1];
x.v[2] += a.v[2];
@ -219,11 +219,11 @@ ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void*
}
if constexpr (filter_type == 2) {
auto* pixels = (Pixel*)bitmap.scanline(y);
auto* pixels_y_minus_1 = y == 0 ? dummy_scanline : (const Pixel*)bitmap.scanline(y - 1);
auto* pixels_y_minus_1 = y == 0 ? dummy_scanline : (Pixel const*)bitmap.scanline(y - 1);
for (int i = 0; i < bitmap.width(); ++i) {
auto& x = pixels[i];
swap(x.r, x.b);
const Pixel& b = pixels_y_minus_1[i];
Pixel const& b = pixels_y_minus_1[i];
x.v[0] += b.v[0];
x.v[1] += b.v[1];
x.v[2] += b.v[2];
@ -234,14 +234,14 @@ ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void*
}
if constexpr (filter_type == 3) {
auto* pixels = (Pixel*)bitmap.scanline(y);
auto* pixels_y_minus_1 = y == 0 ? dummy_scanline : (const Pixel*)bitmap.scanline(y - 1);
auto* pixels_y_minus_1 = y == 0 ? dummy_scanline : (Pixel const*)bitmap.scanline(y - 1);
for (int i = 0; i < bitmap.width(); ++i) {
auto& x = pixels[i];
swap(x.r, x.b);
Pixel a;
if (i != 0)
a = pixels[i - 1];
const Pixel& b = pixels_y_minus_1[i];
Pixel const& b = pixels_y_minus_1[i];
x.v[0] = x.v[0] + ((a.v[0] + b.v[0]) / 2);
x.v[1] = x.v[1] + ((a.v[1] + b.v[1]) / 2);
x.v[2] = x.v[2] + ((a.v[2] + b.v[2]) / 2);
@ -257,7 +257,7 @@ ALWAYS_INLINE static void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void*
auto& x = pixels[i];
swap(x.r, x.b);
Pixel a;
const Pixel& b = pixels_y_minus_1[i];
Pixel const& b = pixels_y_minus_1[i];
Pixel c;
if (i != 0) {
a = pixels[i - 1];
@ -291,7 +291,7 @@ template<typename T>
ALWAYS_INLINE static void unpack_grayscale_with_alpha(PNGLoadingContext& context)
{
for (int y = 0; y < context.height; ++y) {
auto* tuples = reinterpret_cast<const Tuple<T>*>(context.scanlines[y].data.data());
auto* tuples = reinterpret_cast<Tuple<T> const*>(context.scanlines[y].data.data());
for (int i = 0; i < context.width; ++i) {
auto& pixel = (Pixel&)context.bitmap->scanline(y)[i];
pixel.r = tuples[i].gray;
@ -306,7 +306,7 @@ template<typename T>
ALWAYS_INLINE static void unpack_triplets_without_alpha(PNGLoadingContext& context)
{
for (int y = 0; y < context.height; ++y) {
auto* triplets = reinterpret_cast<const Triplet<T>*>(context.scanlines[y].data.data());
auto* triplets = reinterpret_cast<Triplet<T> const*>(context.scanlines[y].data.data());
for (int i = 0; i < context.width; ++i) {
auto& pixel = (Pixel&)context.bitmap->scanline(y)[i];
pixel.r = triplets[i].r;
@ -321,7 +321,7 @@ template<typename T>
ALWAYS_INLINE static void unpack_triplets_with_transparency_value(PNGLoadingContext& context, Triplet<T> transparency_value)
{
for (int y = 0; y < context.height; ++y) {
auto* triplets = reinterpret_cast<const Triplet<T>*>(context.scanlines[y].data.data());
auto* triplets = reinterpret_cast<Triplet<T> const*>(context.scanlines[y].data.data());
for (int i = 0; i < context.width; ++i) {
auto& pixel = (Pixel&)context.bitmap->scanline(y)[i];
pixel.r = triplets[i].r;
@ -401,7 +401,7 @@ NEVER_INLINE FLATTEN static ErrorOr<void> unfilter(PNGLoadingContext& context)
}
} else if (context.bit_depth == 16) {
for (int y = 0; y < context.height; ++y) {
auto* triplets = reinterpret_cast<const Quad<u16>*>(context.scanlines[y].data.data());
auto* triplets = reinterpret_cast<Quad<u16> const*>(context.scanlines[y].data.data());
for (int i = 0; i < context.width; ++i) {
auto& pixel = (Pixel&)context.bitmap->scanline(y)[i];
pixel.r = triplets[i].r & 0xFF;
@ -538,7 +538,7 @@ static bool decode_png_size(PNGLoadingContext& context)
return false;
}
const u8* data_ptr = context.data + sizeof(png_header);
u8 const* data_ptr = context.data + sizeof(png_header);
size_t data_remaining = context.data_size - sizeof(png_header);
Streamer streamer(data_ptr, data_remaining);
@ -566,7 +566,7 @@ static bool decode_png_chunks(PNGLoadingContext& context)
return false;
}
const u8* data_ptr = context.data + sizeof(png_header);
u8 const* data_ptr = context.data + sizeof(png_header);
int data_remaining = context.data_size - sizeof(png_header);
context.compressed_data.ensure_capacity(context.data_size);
@ -861,7 +861,7 @@ static bool process_IDAT(ReadonlyBytes data, PNGLoadingContext& context)
static bool process_PLTE(ReadonlyBytes data, PNGLoadingContext& context)
{
context.palette_data.append((const PaletteEntry*)data.data(), data.size() / 3);
context.palette_data.append((PaletteEntry const*)data.data(), data.size() / 3);
return true;
}
@ -902,18 +902,18 @@ static bool process_chunk(Streamer& streamer, PNGLoadingContext& context)
}
dbgln_if(PNG_DEBUG, "Chunk type: '{}', size: {}, crc: {:x}", chunk_type, chunk_size, chunk_crc);
if (!strcmp((const char*)chunk_type, "IHDR"))
if (!strcmp((char const*)chunk_type, "IHDR"))
return process_IHDR(chunk_data, context);
if (!strcmp((const char*)chunk_type, "IDAT"))
if (!strcmp((char const*)chunk_type, "IDAT"))
return process_IDAT(chunk_data, context);
if (!strcmp((const char*)chunk_type, "PLTE"))
if (!strcmp((char const*)chunk_type, "PLTE"))
return process_PLTE(chunk_data, context);
if (!strcmp((const char*)chunk_type, "tRNS"))
if (!strcmp((char const*)chunk_type, "tRNS"))
return process_tRNS(chunk_data, context);
return true;
}
PNGImageDecoderPlugin::PNGImageDecoderPlugin(const u8* data, size_t size)
PNGImageDecoderPlugin::PNGImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<PNGLoadingContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/PNGLoader.h
View file

@ -15,7 +15,7 @@ struct PNGLoadingContext;
class PNGImageDecoderPlugin final : public ImageDecoderPlugin {
public:
virtual ~PNGImageDecoderPlugin() override;
PNGImageDecoderPlugin(const u8*, size_t);
PNGImageDecoderPlugin(u8 const*, size_t);
virtual IntSize size() override;
virtual void set_volatile() override;

2
Userland/Libraries/LibGfx/Palette.cpp
View file

@ -22,7 +22,7 @@ PaletteImpl::PaletteImpl(Core::AnonymousBuffer buffer)
{
}
Palette::Palette(const PaletteImpl& impl)
Palette::Palette(PaletteImpl const& impl)
: m_impl(impl)
{
}

8
Userland/Libraries/LibGfx/Palette.h
View file

@ -46,7 +46,7 @@ public:
int metric(MetricRole) const;
String path(PathRole) const;
const SystemTheme& theme() const { return *m_theme_buffer.data<SystemTheme>(); }
SystemTheme const& theme() const { return *m_theme_buffer.data<SystemTheme>(); }
void replace_internal_buffer(Badge<GUI::Application>, Core::AnonymousBuffer buffer);
@ -59,7 +59,7 @@ private:
class Palette {
public:
explicit Palette(const PaletteImpl&);
explicit Palette(PaletteImpl const&);
~Palette() = default;
Color accent() const { return color(ColorRole::Accent); }
@ -169,10 +169,10 @@ public:
void set_metric(MetricRole, int);
void set_path(PathRole, String);
const SystemTheme& theme() const { return m_impl->theme(); }
SystemTheme const& theme() const { return m_impl->theme(); }
PaletteImpl& impl() { return *m_impl; }
const PaletteImpl& impl() const { return *m_impl; }
PaletteImpl const& impl() const { return *m_impl; }
private:
NonnullRefPtr<PaletteImpl> m_impl;

22
Userland/Libraries/LibGfx/Path.cpp
View file

@ -14,7 +14,7 @@
namespace Gfx {
void Path::elliptical_arc_to(const FloatPoint& point, const FloatPoint& radii, double x_axis_rotation, bool large_arc, bool sweep)
void Path::elliptical_arc_to(FloatPoint const& point, FloatPoint const& radii, double x_axis_rotation, bool large_arc, bool sweep)
{
auto next_point = point;
@ -207,16 +207,16 @@ String Path::to_string() const
switch (segment.type()) {
case Segment::Type::QuadraticBezierCurveTo:
builder.append(", ");
builder.append(static_cast<const QuadraticBezierCurveSegment&>(segment).through().to_string());
builder.append(static_cast<QuadraticBezierCurveSegment const&>(segment).through().to_string());
break;
case Segment::Type::CubicBezierCurveTo:
builder.append(", ");
builder.append(static_cast<const CubicBezierCurveSegment&>(segment).through_0().to_string());
builder.append(static_cast<CubicBezierCurveSegment const&>(segment).through_0().to_string());
builder.append(", ");
builder.append(static_cast<const CubicBezierCurveSegment&>(segment).through_1().to_string());
builder.append(static_cast<CubicBezierCurveSegment const&>(segment).through_1().to_string());
break;
case Segment::Type::EllipticalArcTo: {
auto& arc = static_cast<const EllipticalArcSegment&>(segment);
auto& arc = static_cast<EllipticalArcSegment const&>(segment);
builder.appendff(", {}, {}, {}, {}, {}",
arc.radii().to_string().characters(),
arc.center().to_string().characters(),
@ -243,7 +243,7 @@ void Path::segmentize_path()
float max_x = 0;
float max_y = 0;
auto add_point_to_bbox = [&](const Gfx::FloatPoint& point) {
auto add_point_to_bbox = [&](Gfx::FloatPoint const& point) {
float x = point.x();
float y = point.y();
min_x = min(min_x, x);
@ -252,7 +252,7 @@ void Path::segmentize_path()
max_y = max(max_y, y);
};
auto add_line = [&](const auto& p0, const auto& p1) {
auto add_line = [&](auto const& p0, auto const& p1) {
float ymax = p0.y(), ymin = p1.y(), x_of_ymin = p1.x(), x_of_ymax = p0.x();
auto slope = p0.x() == p1.x() ? 0 : ((float)(p0.y() - p1.y())) / ((float)(p0.x() - p1.x()));
if (p0.y() < p1.y()) {
@ -292,7 +292,7 @@ void Path::segmentize_path()
}
case Segment::Type::QuadraticBezierCurveTo: {
auto& control = static_cast<QuadraticBezierCurveSegment&>(segment).through();
Painter::for_each_line_segment_on_bezier_curve(control, cursor, segment.point(), [&](const FloatPoint& p0, const FloatPoint& p1) {
Painter::for_each_line_segment_on_bezier_curve(control, cursor, segment.point(), [&](FloatPoint const& p0, FloatPoint const& p1) {
add_line(p0, p1);
});
cursor = segment.point();
@ -302,7 +302,7 @@ void Path::segmentize_path()
auto& curve = static_cast<CubicBezierCurveSegment const&>(segment);
auto& control_0 = curve.through_0();
auto& control_1 = curve.through_1();
Painter::for_each_line_segment_on_cubic_bezier_curve(control_0, control_1, cursor, segment.point(), [&](const FloatPoint& p0, const FloatPoint& p1) {
Painter::for_each_line_segment_on_cubic_bezier_curve(control_0, control_1, cursor, segment.point(), [&](FloatPoint const& p0, FloatPoint const& p1) {
add_line(p0, p1);
});
cursor = segment.point();
@ -310,7 +310,7 @@ void Path::segmentize_path()
}
case Segment::Type::EllipticalArcTo: {
auto& arc = static_cast<EllipticalArcSegment&>(segment);
Painter::for_each_line_segment_on_elliptical_arc(cursor, arc.point(), arc.center(), arc.radii(), arc.x_axis_rotation(), arc.theta_1(), arc.theta_delta(), [&](const FloatPoint& p0, const FloatPoint& p1) {
Painter::for_each_line_segment_on_elliptical_arc(cursor, arc.point(), arc.center(), arc.radii(), arc.x_axis_rotation(), arc.theta_1(), arc.theta_delta(), [&](FloatPoint const& p0, FloatPoint const& p1) {
add_line(p0, p1);
});
cursor = segment.point();
@ -324,7 +324,7 @@ void Path::segmentize_path()
}
// sort segments by ymax
quick_sort(segments, [](const auto& line0, const auto& line1) {
quick_sort(segments, [](auto const& line0, auto const& line1) {
return line1.maximum_y < line0.maximum_y;
});

38
Userland/Libraries/LibGfx/Path.h
View file

@ -28,14 +28,14 @@ public:
EllipticalArcTo,
};
Segment(const FloatPoint& point)
Segment(FloatPoint const& point)
: m_point(point)
{
}
virtual ~Segment() = default;
const FloatPoint& point() const { return m_point; }
FloatPoint const& point() const { return m_point; }
virtual Type type() const = 0;
protected:
@ -44,7 +44,7 @@ protected:
class MoveSegment final : public Segment {
public:
MoveSegment(const FloatPoint& point)
MoveSegment(FloatPoint const& point)
: Segment(point)
{
}
@ -55,7 +55,7 @@ private:
class LineSegment final : public Segment {
public:
LineSegment(const FloatPoint& point)
LineSegment(FloatPoint const& point)
: Segment(point)
{
}
@ -68,7 +68,7 @@ private:
class QuadraticBezierCurveSegment final : public Segment {
public:
QuadraticBezierCurveSegment(const FloatPoint& point, const FloatPoint& through)
QuadraticBezierCurveSegment(FloatPoint const& point, FloatPoint const& through)
: Segment(point)
, m_through(through)
{
@ -76,7 +76,7 @@ public:
virtual ~QuadraticBezierCurveSegment() override = default;
const FloatPoint& through() const { return m_through; }
FloatPoint const& through() const { return m_through; }
private:
virtual Type type() const override { return Segment::Type::QuadraticBezierCurveTo; }
@ -86,7 +86,7 @@ private:
class CubicBezierCurveSegment final : public Segment {
public:
CubicBezierCurveSegment(const FloatPoint& point, const FloatPoint& through_0, const FloatPoint& through_1)
CubicBezierCurveSegment(FloatPoint const& point, FloatPoint const& through_0, FloatPoint const& through_1)
: Segment(point)
, m_through_0(through_0)
, m_through_1(through_1)
@ -95,8 +95,8 @@ public:
virtual ~CubicBezierCurveSegment() override = default;
const FloatPoint& through_0() const { return m_through_0; }
const FloatPoint& through_1() const { return m_through_1; }
FloatPoint const& through_0() const { return m_through_0; }
FloatPoint const& through_1() const { return m_through_1; }
private:
virtual Type type() const override { return Segment::Type::CubicBezierCurveTo; }
@ -107,7 +107,7 @@ private:
class EllipticalArcSegment final : public Segment {
public:
EllipticalArcSegment(const FloatPoint& point, const FloatPoint& center, const FloatPoint radii, float x_axis_rotation, float theta_1, float theta_delta, bool large_arc, bool sweep)
EllipticalArcSegment(FloatPoint const& point, FloatPoint const& center, const FloatPoint radii, float x_axis_rotation, float theta_1, float theta_delta, bool large_arc, bool sweep)
: Segment(point)
, m_center(center)
, m_radii(radii)
@ -121,8 +121,8 @@ public:
virtual ~EllipticalArcSegment() override = default;
const FloatPoint& center() const { return m_center; }
const FloatPoint& radii() const { return m_radii; }
FloatPoint const& center() const { return m_center; }
FloatPoint const& radii() const { return m_radii; }
float x_axis_rotation() const { return m_x_axis_rotation; }
float theta_1() const { return m_theta_1; }
float theta_delta() const { return m_theta_delta; }
@ -145,12 +145,12 @@ class Path {
public:
Path() = default;
void move_to(const FloatPoint& point)
void move_to(FloatPoint const& point)
{
append_segment<MoveSegment>(point);
}
void line_to(const FloatPoint& point)
void line_to(FloatPoint const& point)
{
append_segment<LineSegment>(point);
invalidate_split_lines();
@ -172,7 +172,7 @@ public:
line_to({ previous_x, y });
}
void quadratic_bezier_curve_to(const FloatPoint& through, const FloatPoint& point)
void quadratic_bezier_curve_to(FloatPoint const& through, FloatPoint const& point)
{
append_segment<QuadraticBezierCurveSegment>(point, through);
invalidate_split_lines();
@ -184,14 +184,14 @@ public:
invalidate_split_lines();
}
void elliptical_arc_to(const FloatPoint& point, const FloatPoint& radii, double x_axis_rotation, bool large_arc, bool sweep);
void arc_to(const FloatPoint& point, float radius, bool large_arc, bool sweep)
void elliptical_arc_to(FloatPoint const& point, FloatPoint const& radii, double x_axis_rotation, bool large_arc, bool sweep);
void arc_to(FloatPoint const& point, float radius, bool large_arc, bool sweep)
{
elliptical_arc_to(point, { radius, radius }, 0, large_arc, sweep);
}
// Note: This does not do any sanity checks!
void elliptical_arc_to(const FloatPoint& endpoint, const FloatPoint& center, const FloatPoint& radii, double x_axis_rotation, double theta, double theta_delta, bool large_arc, bool sweep)
void elliptical_arc_to(FloatPoint const& endpoint, FloatPoint const& center, FloatPoint const& radii, double x_axis_rotation, double theta, double theta_delta, bool large_arc, bool sweep)
{
append_segment<EllipticalArcSegment>(
endpoint,
@ -218,7 +218,7 @@ public:
float x;
};
const NonnullRefPtrVector<Segment>& segments() const { return m_segments; }
NonnullRefPtrVector<Segment> const& segments() const { return m_segments; }
auto& split_lines() const
{
if (!m_split_lines.has_value()) {

12
Userland/Libraries/LibGfx/PortableImageLoaderCommon.h
View file

@ -45,7 +45,7 @@ static bool read_number(Streamer& streamer, TValue* value)
sb.append(byte);
}
const auto opt_value = sb.to_string().to_uint();
auto const opt_value = sb.to_string().to_uint();
if (!opt_value.has_value()) {
*value = 0;
return false;
@ -133,7 +133,7 @@ static bool read_whitespace(TContext& context, Streamer& streamer)
template<typename TContext>
static bool read_width(TContext& context, Streamer& streamer)
{
if (const bool result = read_number(streamer, &context.width);
if (bool const result = read_number(streamer, &context.width);
!result || context.width == 0) {
return false;
}
@ -145,7 +145,7 @@ static bool read_width(TContext& context, Streamer& streamer)
template<typename TContext>
static bool read_height(TContext& context, Streamer& streamer)
{
if (const bool result = read_number(streamer, &context.height);
if (bool const result = read_number(streamer, &context.height);
!result || context.height == 0) {
return false;
}
@ -157,7 +157,7 @@ static bool read_height(TContext& context, Streamer& streamer)
template<typename TContext>
static bool read_max_val(TContext& context, Streamer& streamer)
{
if (const bool result = read_number(streamer, &context.format_details.max_val);
if (bool const result = read_number(streamer, &context.format_details.max_val);
!result || context.format_details.max_val == 0) {
return false;
}
@ -185,7 +185,7 @@ static bool create_bitmap(TContext& context)
}
template<typename TContext>
static void set_pixels(TContext& context, const Vector<Gfx::Color>& color_data)
static void set_pixels(TContext& context, Vector<Gfx::Color> const& color_data)
{
size_t index = 0;
for (size_t y = 0; y < context.height; ++y) {
@ -248,7 +248,7 @@ static bool decode(TContext& context)
}
template<typename TContext>
static RefPtr<Gfx::Bitmap> load_impl(const u8* data, size_t data_size)
static RefPtr<Gfx::Bitmap> load_impl(u8 const* data, size_t data_size)
{
TContext context {};
context.data = data;

4
Userland/Libraries/LibGfx/PortableImageMapLoader.h
View file

@ -49,7 +49,7 @@ struct PortableImageMapLoadingContext {
template<typename TContext>
class PortableImageDecoderPlugin final : public ImageDecoderPlugin {
public:
PortableImageDecoderPlugin(const u8*, size_t);
PortableImageDecoderPlugin(u8 const*, size_t);
virtual ~PortableImageDecoderPlugin() override = default;
virtual IntSize size() override;
@ -69,7 +69,7 @@ private:
};
template<typename TContext>
PortableImageDecoderPlugin<TContext>::PortableImageDecoderPlugin(const u8* data, size_t size)
PortableImageDecoderPlugin<TContext>::PortableImageDecoderPlugin(u8 const* data, size_t size)
{
m_context = make<TContext>();
m_context->data = data;

2
Userland/Libraries/LibGfx/Rect.cpp
View file

@ -170,7 +170,7 @@ Point<T> Rect<T>::closest_to(Point<T> const& point) const
return {};
Optional<Point<T>> closest_point;
float closest_distance = 0.0;
auto check_distance = [&](const Line<T>& line) {
auto check_distance = [&](Line<T> const& line) {
auto point_on_line = line.closest_to(point);
auto distance = Line { point_on_line, point }.length();
if (!closest_point.has_value() || distance < closest_distance) {

2
Userland/Libraries/LibGfx/Rect.h
View file

@ -752,7 +752,7 @@ struct Formatter<Gfx::Rect<T>> : Formatter<StringView> {
namespace IPC {
bool encode(Encoder&, const Gfx::IntRect&);
bool encode(Encoder&, Gfx::IntRect const&);
ErrorOr<void> decode(Decoder&, Gfx::IntRect&);
}

2
Userland/Libraries/LibGfx/ShareableBitmap.cpp
View file

@ -22,7 +22,7 @@ ShareableBitmap::ShareableBitmap(NonnullRefPtr<Bitmap> bitmap, Tag)
namespace IPC {
bool encode(Encoder& encoder, const Gfx::ShareableBitmap& shareable_bitmap)
bool encode(Encoder& encoder, Gfx::ShareableBitmap const& shareable_bitmap)
{
encoder << shareable_bitmap.is_valid();
if (!shareable_bitmap.is_valid())

4
Userland/Libraries/LibGfx/ShareableBitmap.h
View file

@ -21,7 +21,7 @@ public:
bool is_valid() const { return m_bitmap; }
const Bitmap* bitmap() const { return m_bitmap; }
Bitmap const* bitmap() const { return m_bitmap; }
Bitmap* bitmap() { return m_bitmap; }
private:
@ -34,7 +34,7 @@ private:
namespace IPC {
bool encode(Encoder&, const Gfx::ShareableBitmap&);
bool encode(Encoder&, Gfx::ShareableBitmap const&);
ErrorOr<void> decode(Decoder&, Gfx::ShareableBitmap&);
}

4
Userland/Libraries/LibGfx/Streamer.h
View file

@ -16,7 +16,7 @@ namespace Gfx {
class Streamer {
public:
constexpr Streamer(const u8* data, size_t size)
constexpr Streamer(u8 const* data, size_t size)
: m_data_ptr(data)
, m_size_remaining(size)
{
@ -52,7 +52,7 @@ public:
}
private:
const u8* m_data_ptr { nullptr };
u8 const* m_data_ptr { nullptr };
size_t m_size_remaining { 0 };
};

16
Userland/Libraries/LibGfx/StylePainter.cpp
View file

@ -18,42 +18,42 @@ BaseStylePainter& StylePainter::current()
return style;
}
void StylePainter::paint_tab_button(Painter& painter, const IntRect& rect, const Palette& palette, bool active, bool hovered, bool enabled, bool top, bool in_active_window)
void StylePainter::paint_tab_button(Painter& painter, IntRect const& rect, Palette const& palette, bool active, bool hovered, bool enabled, bool top, bool in_active_window)
{
current().paint_tab_button(painter, rect, palette, active, hovered, enabled, top, in_active_window);
}
void StylePainter::paint_button(Painter& painter, const IntRect& rect, const Palette& palette, ButtonStyle button_style, bool pressed, bool hovered, bool checked, bool enabled, bool focused, bool default_button)
void StylePainter::paint_button(Painter& painter, IntRect const& rect, Palette const& palette, ButtonStyle button_style, bool pressed, bool hovered, bool checked, bool enabled, bool focused, bool default_button)
{
current().paint_button(painter, rect, palette, button_style, pressed, hovered, checked, enabled, focused, default_button);
}
void StylePainter::paint_frame(Painter& painter, const IntRect& rect, const Palette& palette, FrameShape shape, FrameShadow shadow, int thickness, bool skip_vertical_lines)
void StylePainter::paint_frame(Painter& painter, IntRect const& rect, Palette const& palette, FrameShape shape, FrameShadow shadow, int thickness, bool skip_vertical_lines)
{
current().paint_frame(painter, rect, palette, shape, shadow, thickness, skip_vertical_lines);
}
void StylePainter::paint_window_frame(Painter& painter, const IntRect& rect, const Palette& palette)
void StylePainter::paint_window_frame(Painter& painter, IntRect const& rect, Palette const& palette)
{
current().paint_window_frame(painter, rect, palette);
}
void StylePainter::paint_progressbar(Painter& painter, const IntRect& rect, const Palette& palette, int min, int max, int value, StringView text, Orientation orientation)
void StylePainter::paint_progressbar(Painter& painter, IntRect const& rect, Palette const& palette, int min, int max, int value, StringView text, Orientation orientation)
{
current().paint_progressbar(painter, rect, palette, min, max, value, text, orientation);
}
void StylePainter::paint_radio_button(Painter& painter, const IntRect& rect, const Palette& palette, bool is_checked, bool is_being_pressed)
void StylePainter::paint_radio_button(Painter& painter, IntRect const& rect, Palette const& palette, bool is_checked, bool is_being_pressed)
{
current().paint_radio_button(painter, rect, palette, is_checked, is_being_pressed);
}
void StylePainter::paint_check_box(Painter& painter, const IntRect& rect, const Palette& palette, bool is_enabled, bool is_checked, bool is_being_pressed)
void StylePainter::paint_check_box(Painter& painter, IntRect const& rect, Palette const& palette, bool is_enabled, bool is_checked, bool is_being_pressed)
{
current().paint_check_box(painter, rect, palette, is_enabled, is_checked, is_being_pressed);
}
void StylePainter::paint_transparency_grid(Painter& painter, const IntRect& rect, const Palette& palette)
void StylePainter::paint_transparency_grid(Painter& painter, IntRect const& rect, Palette const& palette)
{
current().paint_transparency_grid(painter, rect, palette);
}

2
Userland/Libraries/LibGfx/SystemTheme.cpp
View file

@ -13,7 +13,7 @@
namespace Gfx {
static SystemTheme dummy_theme;
static const SystemTheme* theme_page = &dummy_theme;
static SystemTheme const* theme_page = &dummy_theme;
static Core::AnonymousBuffer theme_buffer;
Core::AnonymousBuffer& current_system_theme_buffer()

10
Userland/Libraries/LibGfx/SystemTheme.h
View file

@ -135,7 +135,7 @@ enum class ColorRole {
DisabledText = ThreedShadow1,
};
inline const char* to_string(ColorRole role)
inline char const* to_string(ColorRole role)
{
switch (role) {
case ColorRole::NoRole:
@ -162,7 +162,7 @@ enum class AlignmentRole {
__Count,
};
inline const char* to_string(AlignmentRole role)
inline char const* to_string(AlignmentRole role)
{
switch (role) {
case AlignmentRole::NoRole:
@ -189,7 +189,7 @@ enum class FlagRole {
__Count,
};
inline const char* to_string(FlagRole role)
inline char const* to_string(FlagRole role)
{
switch (role) {
case FlagRole::NoRole:
@ -216,7 +216,7 @@ enum class MetricRole {
__Count,
};
inline const char* to_string(MetricRole role)
inline char const* to_string(MetricRole role)
{
switch (role) {
case MetricRole::NoRole:
@ -243,7 +243,7 @@ enum class PathRole {
__Count,
};
inline const char* to_string(PathRole role)
inline char const* to_string(PathRole role)
{
switch (role) {
case PathRole::NoRole:

2
Userland/Libraries/LibGfx/TextAlignment.h
View file

@ -62,7 +62,7 @@ inline Optional<TextAlignment> text_alignment_from_string(StringView string)
return {};
}
inline const char* to_string(TextAlignment text_alignment)
inline char const* to_string(TextAlignment text_alignment)
{
#define __ENUMERATE(x) \
if (text_alignment == TextAlignment::x) \

2
Userland/Libraries/LibGfx/TextDirection.h
View file

@ -20,7 +20,7 @@ enum class BidirectionalClass {
NEUTRAL,
};
extern const Array<BidirectionalClass, 0x1F000> char_bidi_class_lookup_table;
extern Array<BidirectionalClass, 0x1F000> const char_bidi_class_lookup_table;
constexpr BidirectionalClass get_char_bidi_class(u32 ch)
{

2
Userland/Libraries/LibGfx/Typeface.cpp
View file

@ -77,7 +77,7 @@ RefPtr<Font> Typeface::get_font(float point_size, Font::AllowInexactSizeMatch al
return {};
}
void Typeface::for_each_fixed_size_font(Function<void(const Font&)> callback) const
void Typeface::for_each_fixed_size_font(Function<void(Font const&)> callback) const
{
for (auto font : m_bitmap_fonts) {
callback(*font);

4
Userland/Libraries/LibGfx/Typeface.h
View file

@ -18,7 +18,7 @@ namespace Gfx {
class Typeface : public RefCounted<Typeface> {
public:
Typeface(const String& family, const String& variant)
Typeface(String const& family, String const& variant)
: m_family(family)
, m_variant(variant)
{
@ -31,7 +31,7 @@ public:
bool is_fixed_width() const;
bool is_fixed_size() const { return !m_bitmap_fonts.is_empty(); }
void for_each_fixed_size_font(Function<void(const Font&)>) const;
void for_each_fixed_size_font(Function<void(Font const&)>) const;
void add_bitmap_font(RefPtr<BitmapFont>);
void set_ttf_font(RefPtr<TTF::Font>);

16
Userland/Libraries/LibGfx/VectorN.h
View file

@ -62,7 +62,7 @@ public:
return m_data[index];
}
constexpr VectorN& operator+=(const VectorN& other)
constexpr VectorN& operator+=(VectorN const& other)
{
UNROLL_LOOP
for (auto i = 0u; i < N; ++i)
@ -70,7 +70,7 @@ public:
return *this;
}
constexpr VectorN& operator-=(const VectorN& other)
constexpr VectorN& operator-=(VectorN const& other)
{
UNROLL_LOOP
for (auto i = 0u; i < N; ++i)
@ -86,7 +86,7 @@ public:
return *this;
}
[[nodiscard]] constexpr VectorN operator+(const VectorN& other) const
[[nodiscard]] constexpr VectorN operator+(VectorN const& other) const
{
VectorN result;
UNROLL_LOOP
@ -95,7 +95,7 @@ public:
return result;
}
[[nodiscard]] constexpr VectorN operator-(const VectorN& other) const
[[nodiscard]] constexpr VectorN operator-(VectorN const& other) const
{
VectorN result;
UNROLL_LOOP
@ -104,7 +104,7 @@ public:
return result;
}
[[nodiscard]] constexpr VectorN operator*(const VectorN& other) const
[[nodiscard]] constexpr VectorN operator*(VectorN const& other) const
{
VectorN result;
UNROLL_LOOP
@ -122,7 +122,7 @@ public:
return result;
}
[[nodiscard]] constexpr VectorN operator/(const VectorN& other) const
[[nodiscard]] constexpr VectorN operator/(VectorN const& other) const
{
VectorN result;
UNROLL_LOOP
@ -151,7 +151,7 @@ public:
return result;
}
[[nodiscard]] constexpr T dot(const VectorN& other) const
[[nodiscard]] constexpr T dot(VectorN const& other) const
{
T result {};
UNROLL_LOOP
@ -160,7 +160,7 @@ public:
return result;
}
[[nodiscard]] constexpr VectorN cross(const VectorN& other) const requires(N == 3)
[[nodiscard]] constexpr VectorN cross(VectorN const& other) const requires(N == 3)
{
return VectorN(
y() * other.z() - z() * other.y(),

22
Userland/Libraries/LibGfx/WindowTheme.h
View file

@ -31,22 +31,22 @@ public:
static WindowTheme& current();
virtual void paint_normal_frame(Painter&, WindowState, const IntRect& window_rect, StringView title, const Bitmap& icon, const Palette&, const IntRect& leftmost_button_rect, int menu_row_count, bool window_modified) const = 0;
virtual void paint_tool_window_frame(Painter&, WindowState, const IntRect& window_rect, StringView title, const Palette&, const IntRect& leftmost_button_rect) const = 0;
virtual void paint_notification_frame(Painter&, const IntRect& window_rect, const Palette&, const IntRect& close_button_rect) const = 0;
virtual void paint_normal_frame(Painter&, WindowState, IntRect const& window_rect, StringView title, Bitmap const& icon, Palette const&, IntRect const& leftmost_button_rect, int menu_row_count, bool window_modified) const = 0;
virtual void paint_tool_window_frame(Painter&, WindowState, IntRect const& window_rect, StringView title, Palette const&, IntRect const& leftmost_button_rect) const = 0;
virtual void paint_notification_frame(Painter&, IntRect const& window_rect, Palette const&, IntRect const& close_button_rect) const = 0;
virtual int titlebar_height(WindowType, const Palette&) const = 0;
virtual IntRect titlebar_rect(WindowType, const IntRect& window_rect, const Palette&) const = 0;
virtual IntRect titlebar_icon_rect(WindowType, const IntRect& window_rect, const Palette&) const = 0;
virtual IntRect titlebar_text_rect(WindowType, const IntRect& window_rect, const Palette&) const = 0;
virtual int titlebar_height(WindowType, Palette const&) const = 0;
virtual IntRect titlebar_rect(WindowType, IntRect const& window_rect, Palette const&) const = 0;
virtual IntRect titlebar_icon_rect(WindowType, IntRect const& window_rect, Palette const&) const = 0;
virtual IntRect titlebar_text_rect(WindowType, IntRect const& window_rect, Palette const&) const = 0;
virtual IntRect menubar_rect(WindowType, const IntRect& window_rect, const Palette&, int menu_row_count) const = 0;
virtual IntRect menubar_rect(WindowType, IntRect const& window_rect, Palette const&, int menu_row_count) const = 0;
virtual IntRect frame_rect_for_window(WindowType, const IntRect& window_rect, const Palette&, int menu_row_count) const = 0;
virtual IntRect frame_rect_for_window(WindowType, IntRect const& window_rect, Palette const&, int menu_row_count) const = 0;
virtual Vector<IntRect> layout_buttons(WindowType, const IntRect& window_rect, const Palette&, size_t buttons) const = 0;
virtual Vector<IntRect> layout_buttons(WindowType, IntRect const& window_rect, Palette const&, size_t buttons) const = 0;
virtual bool is_simple_rect_frame() const = 0;
virtual bool frame_uses_alpha(WindowState, const Palette&) const = 0;
virtual bool frame_uses_alpha(WindowState, Palette const&) const = 0;
virtual float frame_alpha_hit_threshold(WindowState) const = 0;
protected: