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

LibWeb: Make DecodedImageData an abstract class

Browse source 
The existing implementation moves down into a new subclass called
AnimatedBitmapDecodedImageData.

The purpose of this change is to create an extension point where we can
plug in an SVG renderer. :^)
This commit is contained in:
Andreas Kling 2023-05-20 16:11:36 +02:00
parent f7185dfa91
commit 4ee1e5b224
6 changed files with 108 additions and 61 deletions
Download patch file Download diff file Expand all files Collapse all files

1
Userland/Libraries/LibWeb/CMakeLists.txt
View file

@ -206,6 +206,7 @@ set(SOURCES
Geometry/DOMRect.cpp
Geometry/DOMRectList.cpp
Geometry/DOMRectReadOnly.cpp
HTML/AnimatedBitmapDecodedImageData.cpp
HTML/AttributeNames.cpp
HTML/BrowsingContext.cpp
HTML/BrowsingContextGroup.cpp

50
Userland/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.cpp Normal file
View file

@ -0,0 +1,50 @@
/*
* Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGfx/Bitmap.h>
#include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
namespace Web::HTML {
ErrorOr<NonnullRefPtr<AnimatedBitmapDecodedImageData>> AnimatedBitmapDecodedImageData::create(Vector<Frame>&& frames, size_t loop_count, bool animated)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) AnimatedBitmapDecodedImageData(move(frames), loop_count, animated));
}
AnimatedBitmapDecodedImageData::AnimatedBitmapDecodedImageData(Vector<Frame>&& frames, size_t loop_count, bool animated)
: m_frames(move(frames))
, m_loop_count(loop_count)
, m_animated(animated)
{
}
AnimatedBitmapDecodedImageData::~AnimatedBitmapDecodedImageData() = default;
RefPtr<Gfx::Bitmap const> AnimatedBitmapDecodedImageData::bitmap(size_t frame_index) const
{
if (frame_index >= m_frames.size())
return nullptr;
return m_frames[frame_index].bitmap;
}
int AnimatedBitmapDecodedImageData::frame_duration(size_t frame_index) const
{
if (frame_index >= m_frames.size())
return 0;
return m_frames[frame_index].duration;
}
Optional<int> AnimatedBitmapDecodedImageData::natural_width() const
{
return m_frames.first().bitmap->width();
}
Optional<int> AnimatedBitmapDecodedImageData::natural_height() const
{
return m_frames.first().bitmap->height();
}
}

41
Userland/Libraries/LibWeb/HTML/AnimatedBitmapDecodedImageData.h Normal file
View file

@ -0,0 +1,41 @@
/*
* Copyright (c) 2023, Andreas Kling <kling@serenityos.org>
*
* SPDX-License-Identifier: BSD-2-Clause
*/
#pragma once
#include <LibWeb/HTML/DecodedImageData.h>
namespace Web::HTML {
class AnimatedBitmapDecodedImageData final : public DecodedImageData {
public:
struct Frame {
RefPtr<Gfx::Bitmap const> bitmap;
int duration { 0 };
};
static ErrorOr<NonnullRefPtr<AnimatedBitmapDecodedImageData>> create(Vector<Frame>&&, size_t loop_count, bool animated);
virtual ~AnimatedBitmapDecodedImageData() override;
virtual RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const override;
virtual int frame_duration(size_t frame_index) const override;
virtual size_t frame_count() const override { return m_frames.size(); }
virtual size_t loop_count() const override { return m_loop_count; }
virtual bool is_animated() const override { return m_animated; }
virtual Optional<int> natural_width() const override;
virtual Optional<int> natural_height() const override;
private:
AnimatedBitmapDecodedImageData(Vector<Frame>&&, size_t loop_count, bool animated);
Vector<Frame> m_frames;
size_t m_loop_count { 0 };
bool m_animated { false };
};
}

37
Userland/Libraries/LibWeb/HTML/DecodedImageData.cpp
View file

@ -4,47 +4,12 @@
* SPDX-License-Identifier: BSD-2-Clause
*/
#include <LibGfx/Bitmap.h>
#include <LibWeb/HTML/DecodedImageData.h>
namespace Web::HTML {
ErrorOr<NonnullRefPtr<DecodedImageData>> DecodedImageData::create(Vector<Frame>&& frames, size_t loop_count, bool animated)
{
return adopt_nonnull_ref_or_enomem(new (nothrow) DecodedImageData(move(frames), loop_count, animated));
}
DecodedImageData::DecodedImageData(Vector<Frame>&& frames, size_t loop_count, bool animated)
: m_frames(move(frames))
, m_loop_count(loop_count)
, m_animated(animated)
{
}
DecodedImageData::DecodedImageData() = default;
DecodedImageData::~DecodedImageData() = default;
RefPtr<Gfx::Bitmap const> DecodedImageData::bitmap(size_t frame_index) const
{
if (frame_index >= m_frames.size())
return nullptr;
return m_frames[frame_index].bitmap;
}
int DecodedImageData::frame_duration(size_t frame_index) const
{
if (frame_index >= m_frames.size())
return 0;
return m_frames[frame_index].duration;
}
Optional<int> DecodedImageData::natural_width() const
{
return m_frames.first().bitmap->width();
}
Optional<int> DecodedImageData::natural_height() const
{
return m_frames.first().bitmap->height();
}
}

32
Userland/Libraries/LibWeb/HTML/DecodedImageData.h
View file

@ -13,32 +13,22 @@
namespace Web::HTML {
// https://html.spec.whatwg.org/multipage/images.html#img-req-data
class DecodedImageData final : public RefCounted<DecodedImageData> {
class DecodedImageData : public RefCounted<DecodedImageData> {
public:
struct Frame {
RefPtr<Gfx::Bitmap const> bitmap;
int duration { 0 };
};
virtual ~DecodedImageData();
static ErrorOr<NonnullRefPtr<DecodedImageData>> create(Vector<Frame>&&, size_t loop_count, bool animated);
~DecodedImageData();
virtual RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const = 0;
virtual int frame_duration(size_t frame_index) const = 0;
RefPtr<Gfx::Bitmap const> bitmap(size_t frame_index) const;
int frame_duration(size_t frame_index) const;
virtual size_t frame_count() const = 0;
virtual size_t loop_count() const = 0;
virtual bool is_animated() const = 0;
size_t frame_count() const { return m_frames.size(); }
size_t loop_count() const { return m_loop_count; }
bool is_animated() const { return m_animated; }
virtual Optional<int> natural_width() const = 0;
virtual Optional<int> natural_height() const = 0;
Optional<int> natural_width() const;
Optional<int> natural_height() const;
private:
DecodedImageData(Vector<Frame>&&, size_t loop_count, bool animated);
Vector<Frame> m_frames;
size_t m_loop_count { 0 };
bool m_animated { false };
protected:
DecodedImageData();
};
}

8
Userland/Libraries/LibWeb/HTML/HTMLImageElement.cpp
View file

@ -14,8 +14,8 @@
#include <LibWeb/Fetch/Fetching/Fetching.h>
#include <LibWeb/Fetch/Infrastructure/FetchController.h>
#include <LibWeb/Fetch/Response.h>
#include <LibWeb/HTML/AnimatedBitmapDecodedImageData.h>
#include <LibWeb/HTML/CORSSettingAttribute.h>
#include <LibWeb/HTML/DecodedImageData.h>
#include <LibWeb/HTML/EventNames.h>
#include <LibWeb/HTML/HTMLImageElement.h>
#include <LibWeb/HTML/HTMLLinkElement.h>
@ -530,15 +530,15 @@ void HTMLImageElement::handle_successful_fetch(AK::URL const& url_string, ImageR
return;
}
Vector<DecodedImageData::Frame> frames;
Vector<AnimatedBitmapDecodedImageData::Frame> frames;
for (auto& frame : result.value().frames) {
frames.append(DecodedImageData::Frame {
frames.append(AnimatedBitmapDecodedImageData::Frame {
.bitmap = frame.bitmap,
.duration = static_cast<int>(frame.duration),
});
}
auto image_data = DecodedImageData::create(move(frames), result.value().loop_count, result.value().is_animated).release_value_but_fixme_should_propagate_errors();
auto image_data = AnimatedBitmapDecodedImageData::create(move(frames), result.value().loop_count, result.value().is_animated).release_value_but_fixme_should_propagate_errors();
image_request.set_image_data(image_data);
ListOfAvailableImages::Key key;