mirror of
https://github.com/RGBCube/serenity
synced 2025-07-28 02:07:35 +00:00
Everywhere: Run clang-format
This commit is contained in:
parent
0376c127f6
commit
086969277e
1665 changed files with 8479 additions and 8479 deletions
|
@ -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)));
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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; }
|
||||
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
};
|
||||
|
||||
}
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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 {};
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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
|
||||
|
|
|
@ -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;
|
||||
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -22,7 +22,7 @@ PaletteImpl::PaletteImpl(Core::AnonymousBuffer buffer)
|
|||
{
|
||||
}
|
||||
|
||||
Palette::Palette(const PaletteImpl& impl)
|
||||
Palette::Palette(PaletteImpl const& impl)
|
||||
: m_impl(impl)
|
||||
{
|
||||
}
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
});
|
||||
|
||||
|
|
|
@ -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()) {
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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;
|
||||
|
|
|
@ -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) {
|
||||
|
|
|
@ -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&);
|
||||
|
||||
}
|
||||
|
|
|
@ -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())
|
||||
|
|
|
@ -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&);
|
||||
|
||||
}
|
||||
|
|
|
@ -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 };
|
||||
};
|
||||
|
||||
|
|
|
@ -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);
|
||||
}
|
||||
|
|
|
@ -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()
|
||||
|
|
|
@ -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:
|
||||
|
|
|
@ -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) \
|
||||
|
|
|
@ -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)
|
||||
{
|
||||
|
|
|
@ -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);
|
||||
|
|
|
@ -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>);
|
||||
|
|
|
@ -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(),
|
||||
|
|
|
@ -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:
|
||||
|
|
Loading…
Add table
Add a link
Reference in a new issue