RGBCube/serenity
1
Fork 0
mirror of https://github.com/RGBCube/serenity synced 2025-07-26 02:57:36 +00:00
Code Issues Activity Actions

LibDraw: Put all classes in the Gfx namespace

Browse source 
I started adding things to a Draw namespace, but it somehow felt really
wrong seeing Draw::Rect and Draw::Bitmap, etc. So instead, let's rename
the library to LibGfx. :^)
This commit is contained in:
Andreas Kling 2020-02-06 11:56:38 +01:00
parent 939a605334
commit 11580babbf
269 changed files with 1513 additions and 1315 deletions
Download patch file Download diff file Expand all files Collapse all files

4
Libraries/LibDraw/CharacterBitmap.cpp
View file

@ -26,6 +26,8 @@
#include "CharacterBitmap.h"
namespace Gfx {
CharacterBitmap::CharacterBitmap(const char* ascii_data, unsigned width, unsigned height)
: m_bits(ascii_data)
, m_size(width, height)
@ -40,3 +42,5 @@ NonnullRefPtr<CharacterBitmap> CharacterBitmap::create_from_ascii(const char* as
{
return adopt(*new CharacterBitmap(asciiData, width, height));
}
}

6
Libraries/LibDraw/CharacterBitmap.h
View file

@ -27,8 +27,10 @@
#pragma once
#include "Size.h"
#include <AK/RefPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
namespace Gfx {
class CharacterBitmap : public RefCounted<CharacterBitmap> {
public:
@ -48,3 +50,5 @@ private:
const char* m_bits { nullptr };
Size m_size;
};
}

6
Libraries/LibDraw/Color.h
View file

@ -30,6 +30,8 @@
#include <AK/String.h>
#include <AK/Types.h>
namespace Gfx {
enum class ColorRole;
typedef u32 RGBA32;
@ -177,3 +179,7 @@ inline const LogStream& operator<<(const LogStream& stream, Color value)
{
return stream << value.to_string();
}
}
using Gfx::Color;

4
Libraries/LibDraw/DisjointRectSet.cpp
View file

@ -26,6 +26,8 @@
#include <LibDraw/DisjointRectSet.h>
namespace Gfx {
void DisjointRectSet::add(const Rect& new_rect)
{
for (auto& rect : m_rects) {
@ -69,3 +71,5 @@ void DisjointRectSet::shatter()
swap(output, m_rects);
} while (pass_had_intersections);
}
}

4
Libraries/LibDraw/DisjointRectSet.h
View file

@ -29,6 +29,8 @@
#include <AK/Vector.h>
#include <LibDraw/Rect.h>
namespace Gfx {
class DisjointRectSet {
public:
DisjointRectSet() {}
@ -52,3 +54,5 @@ private:
Vector<Rect, 32> m_rects;
};
}

10
Libraries/LibDraw/Emoji.cpp
View file

@ -29,9 +29,11 @@
#include <LibDraw/Emoji.h>
#include <LibDraw/GraphicsBitmap.h>
static HashMap<u32, RefPtr<GraphicsBitmap>> s_emojis;
namespace Gfx {
const GraphicsBitmap* Emoji::emoji_for_codepoint(u32 codepoint)
static HashMap<u32, RefPtr<Gfx::Bitmap>> s_emojis;
const Bitmap* Emoji::emoji_for_codepoint(u32 codepoint)
{
auto it = s_emojis.find(codepoint);
if (it != s_emojis.end())
@ -39,7 +41,7 @@ const GraphicsBitmap* Emoji::emoji_for_codepoint(u32 codepoint)
String path = String::format("/res/emoji/U+%X.png", codepoint);
auto bitmap = GraphicsBitmap::load_from_file(path);
auto bitmap = Bitmap::load_from_file(path);
if (!bitmap) {
s_emojis.set(codepoint, nullptr);
return nullptr;
@ -48,3 +50,5 @@ const GraphicsBitmap* Emoji::emoji_for_codepoint(u32 codepoint)
s_emojis.set(codepoint, bitmap);
return bitmap.ptr();
}
}

8
Libraries/LibDraw/Emoji.h
View file

@ -28,9 +28,13 @@
#include <AK/Types.h>
class GraphicsBitmap;
namespace Gfx {
class Bitmap;
class Emoji {
public:
static const GraphicsBitmap* emoji_for_codepoint(u32 codepoint);
static const Gfx::Bitmap* emoji_for_codepoint(u32 codepoint);
};
}

8
Libraries/LibDraw/FloatPoint.h
View file

@ -26,10 +26,12 @@
#pragma once
#include <AK/String.h>
#include <AK/LogStream.h>
#include <AK/String.h>
#include <LibDraw/Orientation.h>
namespace Gfx {
class FloatRect;
class FloatPoint {
@ -141,3 +143,7 @@ inline const LogStream& operator<<(const LogStream& stream, const FloatPoint& va
{
return stream << value.to_string();
}
}
using Gfx::FloatPoint;

6
Libraries/LibDraw/FloatRect.h
View file

@ -35,6 +35,8 @@
#include <LibDraw/TextAlignment.h>
#include <math.h>
namespace Gfx {
class FloatRect {
public:
FloatRect() {}
@ -324,3 +326,7 @@ inline Rect enclosing_int_rect(const FloatRect& float_rect)
{
return { (int)float_rect.x(), (int)float_rect.y(), (int)ceilf(float_rect.width()), (int)ceilf(float_rect.height()) };
}
}
using Gfx::FloatRect;

8
Libraries/LibDraw/FloatSize.h
View file

@ -26,10 +26,12 @@
#pragma once
#include <AK/String.h>
#include <AK/LogStream.h>
#include <AK/String.h>
#include <LibDraw/Orientation.h>
namespace Gfx {
class FloatSize {
public:
FloatSize() {}
@ -111,3 +113,7 @@ inline const LogStream& operator<<(const LogStream& stream, const FloatSize& val
{
return stream << value.to_string();
}
}
using Gfx::FloatSize;

12
Libraries/LibDraw/Font.cpp
View file

@ -25,18 +25,20 @@
*/
#include "Font.h"
#include "Emoji.h"
#include "GraphicsBitmap.h"
#include <AK/BufferStream.h>
#include <AK/MappedFile.h>
#include <AK/StdLibExtras.h>
#include <AK/Utf8View.h>
#include <AK/kmalloc.h>
#include <errno.h>
#include <fcntl.h>
#include <sys/mman.h>
#include <stdio.h>
#include <sys/mman.h>
#include <unistd.h>
#include <AK/Utf8View.h>
#include "Emoji.h"
#include "GraphicsBitmap.h"
namespace Gfx {
struct [[gnu::packed]] FontFileHeader
{
@ -236,3 +238,5 @@ int Font::width(const Utf8View& utf8) const
return width;
}
}

10
Libraries/LibDraw/Font.h
View file

@ -26,13 +26,15 @@
#pragma once
#include <AK/String.h>
#include <AK/MappedFile.h>
#include <AK/RefPtr.h>
#include <AK/RefCounted.h>
#include <AK/RefPtr.h>
#include <AK/String.h>
#include <AK/Types.h>
#include <LibDraw/Rect.h>
#include <AK/Utf8View.h>
#include <LibDraw/Rect.h>
namespace Gfx {
// FIXME: Make a MutableGlyphBitmap buddy class for FontEditor instead?
class GlyphBitmap {
@ -126,3 +128,5 @@ private:
bool m_fixed_width { false };
};
}

12
Libraries/LibDraw/GIFLoader.cpp
View file

@ -31,9 +31,11 @@
#include <LibDraw/GIFLoader.h>
#include <stdio.h>
static RefPtr<GraphicsBitmap> load_gif_impl(const u8*, size_t);
namespace Gfx {
RefPtr<GraphicsBitmap> load_gif(const StringView& path)
static RefPtr<Gfx::Bitmap> load_gif_impl(const u8*, size_t);
RefPtr<Gfx::Bitmap> load_gif(const StringView& path)
{
MappedFile mapped_file(path);
if (!mapped_file.is_valid())
@ -44,7 +46,7 @@ RefPtr<GraphicsBitmap> load_gif(const StringView& path)
return bitmap;
}
RefPtr<GraphicsBitmap> load_gif_from_memory(const u8* data, size_t length)
RefPtr<Gfx::Bitmap> load_gif_from_memory(const u8* data, size_t length)
{
auto bitmap = load_gif_impl(data, length);
if (bitmap)
@ -80,7 +82,7 @@ struct ImageDescriptor {
Vector<u8> lzw_encoded_bytes;
};
RefPtr<GraphicsBitmap> load_gif_impl(const u8* data, size_t data_size)
RefPtr<Gfx::Bitmap> load_gif_impl(const u8* data, size_t data_size)
{
if (data_size < 32)
return nullptr;
@ -259,3 +261,5 @@ RefPtr<GraphicsBitmap> load_gif_impl(const u8* data, size_t data_size)
return nullptr;
}
}

10
Libraries/LibDraw/GIFLoader.h
View file

@ -29,8 +29,10 @@
#include <LibDraw/GraphicsBitmap.h>
#include <LibDraw/ImageDecoder.h>
RefPtr<GraphicsBitmap> load_gif(const StringView& path);
RefPtr<GraphicsBitmap> load_gif_from_memory(const u8*, size_t);
namespace Gfx {
RefPtr<Gfx::Bitmap> load_gif(const StringView& path);
RefPtr<Gfx::Bitmap> load_gif_from_memory(const u8*, size_t);
struct GIFLoadingContext;
@ -40,10 +42,12 @@ public:
GIFImageDecoderPlugin(const u8*, size_t);
virtual Size size() override;
virtual RefPtr<GraphicsBitmap> bitmap() override;
virtual RefPtr<Gfx::Bitmap> bitmap() override;
virtual void set_volatile() override;
[[nodiscard]] virtual bool set_nonvolatile() override;
private:
OwnPtr<GIFLoadingContext> m_context;
};
}

50
Libraries/LibDraw/GraphicsBitmap.cpp
View file

@ -33,17 +33,19 @@
#include <sys/mman.h>
#include <unistd.h>
NonnullRefPtr<GraphicsBitmap> GraphicsBitmap::create(Format format, const Size& size)
namespace Gfx {
NonnullRefPtr<Bitmap> Bitmap::create(Format format, const Size& size)
{
return adopt(*new GraphicsBitmap(format, size, Purgeable::No));
return adopt(*new Bitmap(format, size, Purgeable::No));
}
NonnullRefPtr<GraphicsBitmap> GraphicsBitmap::create_purgeable(Format format, const Size& size)
NonnullRefPtr<Bitmap> Bitmap::create_purgeable(Format format, const Size& size)
{
return adopt(*new GraphicsBitmap(format, size, Purgeable::Yes));
return adopt(*new Bitmap(format, size, Purgeable::Yes));
}
GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, Purgeable purgeable)
Bitmap::Bitmap(Format format, const Size& size, Purgeable purgeable)
: m_size(size)
, m_pitch(round_up_to_power_of_two(size.width() * sizeof(RGBA32), 16))
, m_format(format)
@ -57,25 +59,25 @@ GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, Purgeable purgea
m_needs_munmap = true;
}
NonnullRefPtr<GraphicsBitmap> GraphicsBitmap::create_wrapper(Format format, const Size& size, size_t pitch, RGBA32* data)
NonnullRefPtr<Bitmap> Bitmap::create_wrapper(Format format, const Size& size, size_t pitch, RGBA32* data)
{
return adopt(*new GraphicsBitmap(format, size, pitch, data));
return adopt(*new Bitmap(format, size, pitch, data));
}
RefPtr<GraphicsBitmap> GraphicsBitmap::load_from_file(const StringView& path)
RefPtr<Bitmap> Bitmap::load_from_file(const StringView& path)
{
return load_png(path);
}
RefPtr<GraphicsBitmap> GraphicsBitmap::load_from_file(Format format, const StringView& path, const Size& size)
RefPtr<Bitmap> Bitmap::load_from_file(Format format, const StringView& path, const Size& size)
{
MappedFile mapped_file(path);
if (!mapped_file.is_valid())
return nullptr;
return adopt(*new GraphicsBitmap(format, size, move(mapped_file)));
return adopt(*new Bitmap(format, size, move(mapped_file)));
}
GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, size_t pitch, RGBA32* data)
Bitmap::Bitmap(Format format, const Size& size, size_t pitch, RGBA32* data)
: m_size(size)
, m_data(data)
, m_pitch(pitch)
@ -85,7 +87,7 @@ GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, size_t pitch, RG
m_palette = new RGBA32[256];
}
GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, MappedFile&& mapped_file)
Bitmap::Bitmap(Format format, const Size& size, MappedFile&& mapped_file)
: m_size(size)
, m_data((RGBA32*)mapped_file.data())
, m_pitch(round_up_to_power_of_two(size.width() * sizeof(RGBA32), 16))
@ -95,12 +97,12 @@ GraphicsBitmap::GraphicsBitmap(Format format, const Size& size, MappedFile&& map
ASSERT(format != Format::Indexed8);
}
NonnullRefPtr<GraphicsBitmap> GraphicsBitmap::create_with_shared_buffer(Format format, NonnullRefPtr<SharedBuffer>&& shared_buffer, const Size& size)
NonnullRefPtr<Bitmap> Bitmap::create_with_shared_buffer(Format format, NonnullRefPtr<SharedBuffer>&& shared_buffer, const Size& size)
{
return adopt(*new GraphicsBitmap(format, move(shared_buffer), size));
return adopt(*new Bitmap(format, move(shared_buffer), size));
}
GraphicsBitmap::GraphicsBitmap(Format format, NonnullRefPtr<SharedBuffer>&& shared_buffer, const Size& size)
Bitmap::Bitmap(Format format, NonnullRefPtr<SharedBuffer>&& shared_buffer, const Size& size)
: m_size(size)
, m_data((RGBA32*)shared_buffer->data())
, m_pitch(round_up_to_power_of_two(size.width() * sizeof(RGBA32), 16))
@ -110,17 +112,17 @@ GraphicsBitmap::GraphicsBitmap(Format format, NonnullRefPtr<SharedBuffer>&& shar
ASSERT(format != Format::Indexed8);
}
NonnullRefPtr<GraphicsBitmap> GraphicsBitmap::to_shareable_bitmap() const
NonnullRefPtr<Bitmap> Bitmap::to_shareable_bitmap() const
{
if (m_shared_buffer)
return *this;
auto buffer = SharedBuffer::create_with_size(size_in_bytes());
auto bitmap = GraphicsBitmap::create_with_shared_buffer(m_format, *buffer, m_size);
auto bitmap = Bitmap::create_with_shared_buffer(m_format, *buffer, m_size);
memcpy(buffer->data(), scanline(0), size_in_bytes());
return bitmap;
}
GraphicsBitmap::~GraphicsBitmap()
Bitmap::~Bitmap()
{
if (m_needs_munmap) {
int rc = munmap(m_data, size_in_bytes());
@ -130,22 +132,22 @@ GraphicsBitmap::~GraphicsBitmap()
delete[] m_palette;
}
void GraphicsBitmap::set_mmap_name(const StringView& name)
void Bitmap::set_mmap_name(const StringView& name)
{
ASSERT(m_needs_munmap);
::set_mmap_name(m_data, size_in_bytes(), String(name).characters());
}
void GraphicsBitmap::fill(Color color)
void Bitmap::fill(Color color)
{
ASSERT(m_format == GraphicsBitmap::Format::RGB32 || m_format == GraphicsBitmap::Format::RGBA32);
ASSERT(m_format == Bitmap::Format::RGB32 || m_format == Bitmap::Format::RGBA32);
for (int y = 0; y < height(); ++y) {
auto* scanline = this->scanline(y);
fast_u32_fill(scanline, color.value(), width());
}
}
void GraphicsBitmap::set_volatile()
void Bitmap::set_volatile()
{
ASSERT(m_purgeable);
if (m_volatile)
@ -158,7 +160,7 @@ void GraphicsBitmap::set_volatile()
m_volatile = true;
}
[[nodiscard]] bool GraphicsBitmap::set_nonvolatile()
[[nodiscard]] bool Bitmap::set_nonvolatile()
{
ASSERT(m_purgeable);
if (!m_volatile)
@ -171,3 +173,5 @@ void GraphicsBitmap::set_volatile()
m_volatile = false;
return rc == 0;
}
}

52
Libraries/LibDraw/GraphicsBitmap.h
View file

@ -36,7 +36,9 @@
#include <AK/String.h>
#include <AK/StringView.h>
class GraphicsBitmap : public RefCounted<GraphicsBitmap> {
namespace Gfx {
class Bitmap : public RefCounted<Bitmap> {
public:
enum class Format {
Invalid,
@ -45,16 +47,16 @@ public:
Indexed8
};
static NonnullRefPtr<GraphicsBitmap> create(Format, const Size&);
static NonnullRefPtr<GraphicsBitmap> create_purgeable(Format, const Size&);
static NonnullRefPtr<GraphicsBitmap> create_wrapper(Format, const Size&, size_t pitch, RGBA32*);
static RefPtr<GraphicsBitmap> load_from_file(const StringView& path);
static RefPtr<GraphicsBitmap> load_from_file(Format, const StringView& path, const Size&);
static NonnullRefPtr<GraphicsBitmap> create_with_shared_buffer(Format, NonnullRefPtr<SharedBuffer>&&, const Size&);
static NonnullRefPtr<Bitmap> create(Format, const Size&);
static NonnullRefPtr<Bitmap> create_purgeable(Format, const Size&);
static NonnullRefPtr<Bitmap> create_wrapper(Format, const Size&, size_t pitch, RGBA32*);
static RefPtr<Bitmap> load_from_file(const StringView& path);
static RefPtr<Bitmap> load_from_file(Format, const StringView& path, const Size&);
static NonnullRefPtr<Bitmap> create_with_shared_buffer(Format, NonnullRefPtr<SharedBuffer>&&, const Size&);
NonnullRefPtr<GraphicsBitmap> to_shareable_bitmap() const;
NonnullRefPtr<Bitmap> to_shareable_bitmap() const;
~GraphicsBitmap();
~Bitmap();
RGBA32* scanline(int y);
const RGBA32* scanline(int y) const;
@ -137,10 +139,10 @@ public:
private:
enum class Purgeable { No,
Yes };
GraphicsBitmap(Format, const Size&, Purgeable);
GraphicsBitmap(Format, const Size&, size_t pitch, RGBA32*);
GraphicsBitmap(Format, const Size&, MappedFile&&);
GraphicsBitmap(Format, NonnullRefPtr<SharedBuffer>&&, const Size&);
Bitmap(Format, const Size&, Purgeable);
Bitmap(Format, const Size&, size_t pitch, RGBA32*);
Bitmap(Format, const Size&, MappedFile&&);
Bitmap(Format, NonnullRefPtr<SharedBuffer>&&, const Size&);
Size m_size;
RGBA32* m_data { nullptr };
@ -154,45 +156,45 @@ private:
RefPtr<SharedBuffer> m_shared_buffer;
};
inline RGBA32* GraphicsBitmap::scanline(int y)
inline RGBA32* Bitmap::scanline(int y)
{
return reinterpret_cast<RGBA32*>((((u8*)m_data) + (y * m_pitch)));
}
inline const RGBA32* GraphicsBitmap::scanline(int y) const
inline const RGBA32* Bitmap::scanline(int y) const
{
return reinterpret_cast<const RGBA32*>((((const u8*)m_data) + (y * m_pitch)));
}
inline const u8* GraphicsBitmap::bits(int y) const
inline const u8* Bitmap::bits(int y) const
{
return reinterpret_cast<const u8*>(scanline(y));
}
inline u8* GraphicsBitmap::bits(int y)
inline u8* Bitmap::bits(int y)
{
return reinterpret_cast<u8*>(scanline(y));
}
template<>
inline Color GraphicsBitmap::get_pixel<GraphicsBitmap::Format::RGB32>(int x, int y) const
inline Color Bitmap::get_pixel<Bitmap::Format::RGB32>(int x, int y) const
{
return Color::from_rgb(scanline(y)[x]);
}
template<>
inline Color GraphicsBitmap::get_pixel<GraphicsBitmap::Format::RGBA32>(int x, int y) const
inline Color Bitmap::get_pixel<Bitmap::Format::RGBA32>(int x, int y) const
{
return Color::from_rgba(scanline(y)[x]);
}
template<>
inline Color GraphicsBitmap::get_pixel<GraphicsBitmap::Format::Indexed8>(int x, int y) const
inline Color Bitmap::get_pixel<Bitmap::Format::Indexed8>(int x, int y) const
{
return Color::from_rgba(m_palette[bits(y)[x]]);
}
inline Color GraphicsBitmap::get_pixel(int x, int y) const
inline Color Bitmap::get_pixel(int x, int y) const
{
switch (m_format) {
case Format::RGB32:
@ -208,18 +210,18 @@ inline Color GraphicsBitmap::get_pixel(int x, int y) const
}
template<>
inline void GraphicsBitmap::set_pixel<GraphicsBitmap::Format::RGB32>(int x, int y, Color color)
inline void Bitmap::set_pixel<Bitmap::Format::RGB32>(int x, int y, Color color)
{
scanline(y)[x] = color.value();
}
template<>
inline void GraphicsBitmap::set_pixel<GraphicsBitmap::Format::RGBA32>(int x, int y, Color color)
inline void Bitmap::set_pixel<Bitmap::Format::RGBA32>(int x, int y, Color color)
{
scanline(y)[x] = color.value();
}
inline void GraphicsBitmap::set_pixel(int x, int y, Color color)
inline void Bitmap::set_pixel(int x, int y, Color color)
{
switch (m_format) {
case Format::RGB32:
@ -234,3 +236,5 @@ inline void GraphicsBitmap::set_pixel(int x, int y, Color color)
ASSERT_NOT_REACHED();
}
}
}

3
Libraries/LibDraw/ImageDecoder.cpp
View file

@ -27,6 +27,8 @@
#include <LibDraw/ImageDecoder.h>
#include <LibDraw/PNGLoader.h>
namespace Gfx {
ImageDecoder::ImageDecoder(const u8* data, size_t size)
{
m_plugin = make<PNGImageDecoderPlugin>(data, size);
@ -35,3 +37,4 @@ ImageDecoder::ImageDecoder(const u8* data, size_t size)
ImageDecoder::~ImageDecoder()
{
}
}

10
Libraries/LibDraw/ImageDecoder.h
View file

@ -31,14 +31,16 @@
#include <AK/RefCounted.h>
#include <LibDraw/Size.h>
class GraphicsBitmap;
namespace Gfx {
class Bitmap;
class ImageDecoderPlugin {
public:
virtual ~ImageDecoderPlugin() {}
virtual Size size() = 0;
virtual RefPtr<GraphicsBitmap> bitmap() = 0;
virtual RefPtr<Gfx::Bitmap> bitmap() = 0;
virtual void set_volatile() = 0;
[[nodiscard]] virtual bool set_nonvolatile() = 0;
@ -55,7 +57,7 @@ public:
Size size() const { return m_plugin->size(); }
int width() const { return size().width(); }
int height() const { return size().height(); }
RefPtr<GraphicsBitmap> bitmap() const { return m_plugin->bitmap(); }
RefPtr<Gfx::Bitmap> bitmap() const { return m_plugin->bitmap(); }
void set_volatile() { m_plugin->set_volatile(); }
[[nodiscard]] bool set_nonvolatile() { return m_plugin->set_nonvolatile(); }
@ -64,3 +66,5 @@ private:
mutable OwnPtr<ImageDecoderPlugin> m_plugin;
};
}

6
Libraries/LibDraw/Orientation.h
View file

@ -26,7 +26,13 @@
#pragma once
namespace Gfx {
enum class Orientation {
Horizontal,
Vertical
};
}
using Gfx::Orientation;

20
Libraries/LibDraw/PNGLoader.cpp
View file

@ -37,6 +37,8 @@
#include <sys/stat.h>
#include <unistd.h>
namespace Gfx {
static const u8 png_header[8] = { 0x89, 'P', 'N', 'G', 13, 10, 26, 10 };
struct PNG_IHDR {
@ -109,7 +111,7 @@ struct PNGLoadingContext {
bool has_seen_zlib_header { false };
bool has_alpha() const { return color_type & 4 || palette_transparency_data.size() > 0; }
Vector<Scanline> scanlines;
RefPtr<GraphicsBitmap> bitmap;
RefPtr<Gfx::Bitmap> bitmap;
u8* decompression_buffer { nullptr };
int decompression_buffer_size { 0 };
Vector<u8> compressed_data;
@ -167,10 +169,10 @@ private:
int m_size_remaining;
};
static RefPtr<GraphicsBitmap> load_png_impl(const u8*, int);
static RefPtr<Gfx::Bitmap> load_png_impl(const u8*, int);
static bool process_chunk(Streamer&, PNGLoadingContext& context, bool decode_size_only);
RefPtr<GraphicsBitmap> load_png(const StringView& path)
RefPtr<Gfx::Bitmap> load_png(const StringView& path)
{
MappedFile mapped_file(path);
if (!mapped_file.is_valid())
@ -181,7 +183,7 @@ RefPtr<GraphicsBitmap> load_png(const StringView& path)
return bitmap;
}
RefPtr<GraphicsBitmap> load_png_from_memory(const u8* data, size_t length)
RefPtr<Gfx::Bitmap> load_png_from_memory(const u8* data, size_t length)
{
auto bitmap = load_png_impl(data, length);
if (bitmap)
@ -216,7 +218,7 @@ union [[gnu::packed]] Pixel
static_assert(sizeof(Pixel) == 4);
template<bool has_alpha, u8 filter_type>
[[gnu::always_inline]] static inline void unfilter_impl(GraphicsBitmap& bitmap, int y, const void* dummy_scanline_data)
[[gnu::always_inline]] static inline void unfilter_impl(Gfx::Bitmap& bitmap, int y, const void* dummy_scanline_data)
{
auto* dummy_scanline = (const Pixel*)dummy_scanline_data;
if constexpr (filter_type == 0) {
@ -517,7 +519,7 @@ static bool decode_png_bitmap(PNGLoadingContext& context)
}
}
context.bitmap = GraphicsBitmap::create_purgeable(context.has_alpha() ? GraphicsBitmap::Format::RGBA32 : GraphicsBitmap::Format::RGB32, { context.width, context.height });
context.bitmap = Bitmap::create_purgeable(context.has_alpha() ? Bitmap::Format::RGBA32 : Bitmap::Format::RGB32, { context.width, context.height });
unfilter(context);
@ -529,7 +531,7 @@ static bool decode_png_bitmap(PNGLoadingContext& context)
return true;
}
static RefPtr<GraphicsBitmap> load_png_impl(const u8* data, int data_size)
static RefPtr<Gfx::Bitmap> load_png_impl(const u8* data, int data_size)
{
PNGLoadingContext context;
context.data = data;
@ -687,7 +689,7 @@ Size PNGImageDecoderPlugin::size()
return { m_context->width, m_context->height };
}
RefPtr<GraphicsBitmap> PNGImageDecoderPlugin::bitmap()
RefPtr<Gfx::Bitmap> PNGImageDecoderPlugin::bitmap()
{
if (m_context->state == PNGLoadingContext::State::Error)
return nullptr;
@ -715,3 +717,5 @@ bool PNGImageDecoderPlugin::set_nonvolatile()
return false;
return m_context->bitmap->set_nonvolatile();
}
}

10
Libraries/LibDraw/PNGLoader.h
View file

@ -29,8 +29,10 @@
#include <LibDraw/GraphicsBitmap.h>
#include <LibDraw/ImageDecoder.h>
RefPtr<GraphicsBitmap> load_png(const StringView& path);
RefPtr<GraphicsBitmap> load_png_from_memory(const u8*, size_t);
namespace Gfx {
RefPtr<Gfx::Bitmap> load_png(const StringView& path);
RefPtr<Gfx::Bitmap> load_png_from_memory(const u8*, size_t);
struct PNGLoadingContext;
@ -40,10 +42,12 @@ public:
PNGImageDecoderPlugin(const u8*, size_t);
virtual Size size() override;
virtual RefPtr<GraphicsBitmap> bitmap() override;
virtual RefPtr<Gfx::Bitmap> bitmap() override;
virtual void set_volatile() override;
[[nodiscard]] virtual bool set_nonvolatile() override;
private:
OwnPtr<PNGLoadingContext> m_context;
};
}

74
Libraries/LibDraw/Painter.cpp
View file

@ -49,19 +49,21 @@
#endif
#endif
template<GraphicsBitmap::Format format = GraphicsBitmap::Format::Invalid>
static ALWAYS_INLINE Color get_pixel(const GraphicsBitmap& bitmap, int x, int y)
namespace Gfx {
template<Bitmap::Format format = Bitmap::Format::Invalid>
static ALWAYS_INLINE Color get_pixel(const Gfx::Bitmap& bitmap, int x, int y)
{
if constexpr (format == GraphicsBitmap::Format::Indexed8)
if constexpr (format == Bitmap::Format::Indexed8)
return bitmap.palette_color(bitmap.bits(y)[x]);
if constexpr (format == GraphicsBitmap::Format::RGB32)
if constexpr (format == Bitmap::Format::RGB32)
return Color::from_rgb(bitmap.scanline(y)[x]);
if constexpr (format == GraphicsBitmap::Format::RGBA32)
if constexpr (format == Bitmap::Format::RGBA32)
return Color::from_rgba(bitmap.scanline(y)[x]);
return bitmap.get_pixel(x, y);
}
Painter::Painter(GraphicsBitmap& bitmap)
Painter::Painter(Gfx::Bitmap& bitmap)
: m_target(bitmap)
{
m_state_stack.append(State());
@ -286,7 +288,7 @@ void Painter::draw_bitmap(const Point& p, const GlyphBitmap& bitmap, Color color
}
}
void Painter::blit_scaled(const Rect& dst_rect_raw, const GraphicsBitmap& source, const Rect& src_rect, float hscale, float vscale)
void Painter::blit_scaled(const Rect& dst_rect_raw, const Gfx::Bitmap& source, const Rect& src_rect, float hscale, float vscale)
{
auto dst_rect = Rect(dst_rect_raw.location(), dst_rect_raw.size()).translated(translation());
auto clipped_rect = dst_rect.intersected(clip_rect());
@ -316,7 +318,7 @@ void Painter::blit_scaled(const Rect& dst_rect_raw, const GraphicsBitmap& source
return;
}
void Painter::blit_with_opacity(const Point& position, const GraphicsBitmap& source, const Rect& src_rect, float opacity)
void Painter::blit_with_opacity(const Point& position, const Gfx::Bitmap& source, const Rect& src_rect, float opacity)
{
ASSERT(!m_target->has_alpha_channel());
@ -354,7 +356,7 @@ void Painter::blit_with_opacity(const Point& position, const GraphicsBitmap& sou
}
}
void Painter::blit_dimmed(const Point& position, const GraphicsBitmap& source, const Rect& src_rect)
void Painter::blit_dimmed(const Point& position, const Gfx::Bitmap& source, const Rect& src_rect)
{
Rect safe_src_rect = src_rect.intersected(source.rect());
auto dst_rect = Rect(position, safe_src_rect.size()).translated(translation());
@ -385,7 +387,7 @@ void Painter::blit_dimmed(const Point& position, const GraphicsBitmap& source, c
}
}
void Painter::draw_tiled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& source)
void Painter::draw_tiled_bitmap(const Rect& a_dst_rect, const Gfx::Bitmap& source)
{
auto dst_rect = a_dst_rect.translated(translation());
auto clipped_rect = dst_rect.intersected(clip_rect());
@ -397,7 +399,7 @@ void Painter::draw_tiled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& so
RGBA32* dst = m_target->scanline(clipped_rect.y()) + clipped_rect.x();
const size_t dst_skip = m_target->pitch() / sizeof(RGBA32);
if (source.format() == GraphicsBitmap::Format::RGB32 || source.format() == GraphicsBitmap::Format::RGBA32) {
if (source.format() == Bitmap::Format::RGB32 || source.format() == Bitmap::Format::RGBA32) {
int x_start = first_column + a_dst_rect.left();
for (int row = first_row; row <= last_row; ++row) {
const RGBA32* sl = source.scanline((row + a_dst_rect.top())
@ -414,7 +416,7 @@ void Painter::draw_tiled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& so
}
void Painter::blit_offset(const Point& position,
const GraphicsBitmap& source,
const Gfx::Bitmap& source,
const Rect& src_rect,
const Point& offset)
{
@ -428,7 +430,7 @@ void Painter::blit_offset(const Point& position,
RGBA32* dst = m_target->scanline(clipped_rect.y()) + clipped_rect.x();
const size_t dst_skip = m_target->pitch() / sizeof(RGBA32);
if (source.format() == GraphicsBitmap::Format::RGB32 || source.format() == GraphicsBitmap::Format::RGBA32) {
if (source.format() == Bitmap::Format::RGB32 || source.format() == Bitmap::Format::RGBA32) {
int x_start = first_column + src_rect.left();
for (int row = first_row; row <= last_row; ++row) {
int sr = row - offset.y() + src_rect.top();
@ -450,7 +452,7 @@ void Painter::blit_offset(const Point& position,
ASSERT_NOT_REACHED();
}
void Painter::blit_with_alpha(const Point& position, const GraphicsBitmap& source, const Rect& src_rect)
void Painter::blit_with_alpha(const Point& position, const Gfx::Bitmap& source, const Rect& src_rect)
{
ASSERT(source.has_alpha_channel());
Rect safe_src_rect = src_rect.intersected(source.rect());
@ -482,7 +484,7 @@ void Painter::blit_with_alpha(const Point& position, const GraphicsBitmap& sourc
}
}
void Painter::blit(const Point& position, const GraphicsBitmap& source, const Rect& src_rect, float opacity)
void Painter::blit(const Point& position, const Gfx::Bitmap& source, const Rect& src_rect, float opacity)
{
if (opacity < 1.0f)
return blit_with_opacity(position, source, src_rect, opacity);
@ -500,7 +502,7 @@ void Painter::blit(const Point& position, const GraphicsBitmap& source, const Re
RGBA32* dst = m_target->scanline(clipped_rect.y()) + clipped_rect.x();
const size_t dst_skip = m_target->pitch() / sizeof(RGBA32);
if (source.format() == GraphicsBitmap::Format::RGB32 || source.format() == GraphicsBitmap::Format::RGBA32) {
if (source.format() == Bitmap::Format::RGB32 || source.format() == Bitmap::Format::RGBA32) {
const RGBA32* src = source.scanline(src_rect.top() + first_row) + src_rect.left() + first_column;
const size_t src_skip = source.pitch() / sizeof(RGBA32);
for (int row = first_row; row <= last_row; ++row) {
@ -511,7 +513,7 @@ void Painter::blit(const Point& position, const GraphicsBitmap& source, const Re
return;
}
if (source.format() == GraphicsBitmap::Format::Indexed8) {
if (source.format() == Bitmap::Format::Indexed8) {
const u8* src = source.bits(src_rect.top() + first_row) + src_rect.left() + first_column;
const size_t src_skip = source.pitch();
for (int row = first_row; row <= last_row; ++row) {
@ -527,7 +529,7 @@ void Painter::blit(const Point& position, const GraphicsBitmap& source, const Re
}
template<bool has_alpha_channel, typename GetPixel>
ALWAYS_INLINE static void do_draw_integer_scaled_bitmap(GraphicsBitmap& target, const Rect& dst_rect, const GraphicsBitmap& source, int hfactor, int vfactor, GetPixel get_pixel)
ALWAYS_INLINE static void do_draw_integer_scaled_bitmap(Gfx::Bitmap& target, const Rect& dst_rect, const Gfx::Bitmap& source, int hfactor, int vfactor, GetPixel get_pixel)
{
for (int y = source.rect().top(); y <= source.rect().bottom(); ++y) {
int dst_y = dst_rect.y() + y * vfactor;
@ -548,7 +550,7 @@ ALWAYS_INLINE static void do_draw_integer_scaled_bitmap(GraphicsBitmap& target,
}
template<bool has_alpha_channel, typename GetPixel>
ALWAYS_INLINE static void do_draw_scaled_bitmap(GraphicsBitmap& target, const Rect& dst_rect, const Rect& clipped_rect, const GraphicsBitmap& source, const Rect& src_rect, int hscale, int vscale, GetPixel get_pixel)
ALWAYS_INLINE static void do_draw_scaled_bitmap(Gfx::Bitmap& target, const Rect& dst_rect, const Rect& clipped_rect, const Gfx::Bitmap& source, const Rect& src_rect, int hscale, int vscale, GetPixel get_pixel)
{
if (dst_rect == clipped_rect && !(dst_rect.width() % src_rect.width()) && !(dst_rect.height() % src_rect.height())) {
int hfactor = dst_rect.width() / src_rect.width();
@ -577,7 +579,7 @@ ALWAYS_INLINE static void do_draw_scaled_bitmap(GraphicsBitmap& target, const Re
}
}
void Painter::draw_scaled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& source, const Rect& src_rect)
void Painter::draw_scaled_bitmap(const Rect& a_dst_rect, const Gfx::Bitmap& source, const Rect& src_rect)
{
auto dst_rect = a_dst_rect;
if (dst_rect.size() == src_rect.size())
@ -595,32 +597,32 @@ void Painter::draw_scaled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& s
if (source.has_alpha_channel()) {
switch (source.format()) {
case GraphicsBitmap::Format::RGB32:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::RGB32>);
case Bitmap::Format::RGB32:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::RGB32>);
break;
case GraphicsBitmap::Format::RGBA32:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::RGBA32>);
case Bitmap::Format::RGBA32:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::RGBA32>);
break;
case GraphicsBitmap::Format::Indexed8:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::Indexed8>);
case Bitmap::Format::Indexed8:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::Indexed8>);
break;
default:
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::Invalid>);
do_draw_scaled_bitmap<true>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::Invalid>);
break;
}
} else {
switch (source.format()) {
case GraphicsBitmap::Format::RGB32:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::RGB32>);
case Bitmap::Format::RGB32:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::RGB32>);
break;
case GraphicsBitmap::Format::RGBA32:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::RGBA32>);
case Bitmap::Format::RGBA32:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::RGBA32>);
break;
case GraphicsBitmap::Format::Indexed8:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::Indexed8>);
case Bitmap::Format::Indexed8:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::Indexed8>);
break;
default:
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<GraphicsBitmap::Format::Invalid>);
do_draw_scaled_bitmap<false>(*m_target, dst_rect, clipped_rect, source, src_rect, hscale, vscale, get_pixel<Bitmap::Format::Invalid>);
break;
}
}
@ -636,7 +638,7 @@ void Painter::draw_scaled_bitmap(const Rect& a_dst_rect, const GraphicsBitmap& s
draw_bitmap(point, font.glyph_bitmap(ch), color);
}
void Painter::draw_emoji(const Point& point, const GraphicsBitmap& emoji, const Font& font)
void Painter::draw_emoji(const Point& point, const Gfx::Bitmap& emoji, const Font& font)
{
if (!font.is_fixed_width())
blit(point, emoji, emoji.rect());
@ -952,3 +954,5 @@ PainterStateSaver::~PainterStateSaver()
{
m_painter.restore();
}
}

30
Libraries/LibDraw/Painter.h
View file

@ -35,15 +35,17 @@
#include <LibDraw/TextAlignment.h>
#include <LibDraw/TextElision.h>
namespace Gfx {
class CharacterBitmap;
class GlyphBitmap;
class GraphicsBitmap;
class Bitmap;
class Font;
class Emoji;
class Painter {
public:
explicit Painter(GraphicsBitmap&);
explicit Painter(Gfx::Bitmap&);
~Painter();
void clear_rect(const Rect&, Color);
void fill_rect(const Rect&, Color);
@ -54,17 +56,17 @@ public:
void draw_ellipse_intersecting(const Rect&, Color, int thickness = 1);
void set_pixel(const Point&, Color);
void draw_line(const Point&, const Point&, Color, int thickness = 1, bool dotted = false);
void draw_scaled_bitmap(const Rect& dst_rect, const GraphicsBitmap&, const Rect& src_rect);
void blit(const Point&, const GraphicsBitmap&, const Rect& src_rect, float opacity = 1.0f);
void blit_dimmed(const Point&, const GraphicsBitmap&, const Rect& src_rect);
void draw_tiled_bitmap(const Rect& dst_rect, const GraphicsBitmap&);
void blit_offset(const Point&, const GraphicsBitmap&, const Rect& src_rect, const Point&);
void blit_scaled(const Rect&, const GraphicsBitmap&, const Rect&, float, float);
void draw_scaled_bitmap(const Rect& dst_rect, const Gfx::Bitmap&, const Rect& src_rect);
void blit(const Point&, const Gfx::Bitmap&, const Rect& src_rect, float opacity = 1.0f);
void blit_dimmed(const Point&, const Gfx::Bitmap&, const Rect& src_rect);
void draw_tiled_bitmap(const Rect& dst_rect, const Gfx::Bitmap&);
void blit_offset(const Point&, const Gfx::Bitmap&, const Rect& src_rect, const Point&);
void blit_scaled(const Rect&, const Gfx::Bitmap&, const Rect&, float, float);
void draw_text(const Rect&, const StringView&, const Font&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
void draw_text(const Rect&, const StringView&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
void draw_glyph(const Point&, char, Color);
void draw_glyph(const Point&, char, const Font&, Color);
void draw_emoji(const Point&, const GraphicsBitmap&, const Font&);
void draw_emoji(const Point&, const Gfx::Bitmap&, const Font&);
void draw_glyph_or_emoji(const Point&, u32 codepoint, const Font&, Color);
const Font& font() const { return *state().font; }
@ -86,7 +88,7 @@ public:
Point translation() const { return state().translation; }
GraphicsBitmap* target() { return m_target.ptr(); }
Gfx::Bitmap* target() { return m_target.ptr(); }
void save() { m_state_stack.append(m_state_stack.last()); }
void restore()
@ -98,8 +100,8 @@ public:
protected:
void set_pixel_with_draw_op(u32& pixel, const Color&);
void fill_rect_with_draw_op(const Rect&, Color);
void blit_with_alpha(const Point&, const GraphicsBitmap&, const Rect& src_rect);
void blit_with_opacity(const Point&, const GraphicsBitmap&, const Rect& src_rect, float opacity);
void blit_with_alpha(const Point&, const Gfx::Bitmap&, const Rect& src_rect);
void blit_with_opacity(const Point&, const Gfx::Bitmap&, const Rect& src_rect, float opacity);
void draw_pixel(const Point&, Color, int thickness = 1);
void draw_text_line(const Rect&, const Utf8View&, const Font&, TextAlignment, Color, TextElision);
@ -115,7 +117,7 @@ protected:
const State& state() const { return m_state_stack.last(); }
Rect m_clip_origin;
NonnullRefPtr<GraphicsBitmap> m_target;
NonnullRefPtr<Gfx::Bitmap> m_target;
Vector<State, 4> m_state_stack;
};
@ -127,3 +129,5 @@ public:
private:
Painter& m_painter;
};
}

4
Libraries/LibDraw/Palette.cpp
View file

@ -26,6 +26,8 @@
#include <LibDraw/Palette.h>
namespace Gfx {
NonnullRefPtr<PaletteImpl> PaletteImpl::create_with_shared_buffer(SharedBuffer& buffer)
{
return adopt(*new PaletteImpl(buffer));
@ -70,3 +72,5 @@ void Palette::set_color(ColorRole role, Color color)
auto& theme = const_cast<SystemTheme&>(impl().theme());
theme.color[(int)role] = color;
}
}

6
Libraries/LibDraw/Palette.h
View file

@ -34,6 +34,8 @@ namespace GUI {
class Application;
}
namespace Gfx {
class PaletteImpl : public RefCounted<PaletteImpl> {
AK_MAKE_NONCOPYABLE(PaletteImpl)
AK_MAKE_NONMOVABLE(PaletteImpl)
@ -107,3 +109,7 @@ public:
private:
NonnullRefPtr<PaletteImpl> m_impl;
};
}
using Gfx::Palette;

6
Libraries/LibDraw/Point.h
View file

@ -30,6 +30,8 @@
#include <AK/String.h>
#include <LibDraw/Orientation.h>
namespace Gfx {
class Rect;
class Point {
@ -158,3 +160,7 @@ inline const LogStream& operator<<(const LogStream& stream, const Point& value)
{
return stream << value.to_string();
}
}
using Gfx::Point;

6
Libraries/LibDraw/Rect.h
View file

@ -33,6 +33,8 @@
#include <LibDraw/Size.h>
#include <LibDraw/TextAlignment.h>
namespace Gfx {
class Rect {
public:
Rect() {}
@ -329,3 +331,7 @@ inline const LogStream& operator<<(const LogStream& stream, const Rect& value)
{
return stream << value.to_string();
}
}
using Gfx::Rect;

9
Libraries/LibDraw/Size.h
View file

@ -26,10 +26,12 @@
#pragma once
#include <AK/String.h>
#include <AK/LogStream.h>
#include <AK/String.h>
#include <LibDraw/Orientation.h>
namespace Gfx {
class Size {
public:
Size() {}
@ -100,7 +102,6 @@ public:
set_height(value);
}
String to_string() const { return String::format("[%dx%d]", m_width, m_height); }
private:
@ -112,3 +113,7 @@ inline const LogStream& operator<<(const LogStream& stream, const Size& value)
{
return stream << value.to_string();
}
}
using Gfx::Size;

22
Libraries/LibDraw/StylePainter.cpp
View file

@ -29,6 +29,8 @@
#include <LibDraw/Palette.h>
#include <LibDraw/StylePainter.h>
namespace Gfx {
void StylePainter::paint_tab_button(Painter& painter, const Rect& rect, const Palette& palette, bool active, bool hovered, bool enabled)
{
Color base_color = palette.button();
@ -285,12 +287,12 @@ void StylePainter::paint_progress_bar(Painter& painter, const Rect& rect, const
painter.draw_text(rect.translated(0, 0), text, TextAlignment::Center, palette.base_text());
}
static RefPtr<GraphicsBitmap> s_unfilled_circle_bitmap;
static RefPtr<GraphicsBitmap> s_filled_circle_bitmap;
static RefPtr<GraphicsBitmap> s_changing_filled_circle_bitmap;
static RefPtr<GraphicsBitmap> s_changing_unfilled_circle_bitmap;
static RefPtr<Gfx::Bitmap> s_unfilled_circle_bitmap;
static RefPtr<Gfx::Bitmap> s_filled_circle_bitmap;
static RefPtr<Gfx::Bitmap> s_changing_filled_circle_bitmap;
static RefPtr<Gfx::Bitmap> s_changing_unfilled_circle_bitmap;
static const GraphicsBitmap& circle_bitmap(bool checked, bool changing)
static const Gfx::Bitmap& circle_bitmap(bool checked, bool changing)
{
if (changing)
return checked ? *s_changing_filled_circle_bitmap : *s_changing_unfilled_circle_bitmap;
@ -300,12 +302,14 @@ static const GraphicsBitmap& circle_bitmap(bool checked, bool changing)
void StylePainter::paint_radio_button(Painter& painter, const Rect& rect, const Palette&, bool is_checked, bool is_being_pressed)
{
if (!s_unfilled_circle_bitmap) {
s_unfilled_circle_bitmap = GraphicsBitmap::load_from_file("/res/icons/unfilled-radio-circle.png");
s_filled_circle_bitmap = GraphicsBitmap::load_from_file("/res/icons/filled-radio-circle.png");
s_changing_filled_circle_bitmap = GraphicsBitmap::load_from_file("/res/icons/changing-filled-radio-circle.png");
s_changing_unfilled_circle_bitmap = GraphicsBitmap::load_from_file("/res/icons/changing-unfilled-radio-circle.png");
s_unfilled_circle_bitmap = Bitmap::load_from_file("/res/icons/unfilled-radio-circle.png");
s_filled_circle_bitmap = Bitmap::load_from_file("/res/icons/filled-radio-circle.png");
s_changing_filled_circle_bitmap = Bitmap::load_from_file("/res/icons/changing-filled-radio-circle.png");
s_changing_unfilled_circle_bitmap = Bitmap::load_from_file("/res/icons/changing-unfilled-radio-circle.png");
}
auto& bitmap = circle_bitmap(is_checked, is_being_pressed);
painter.blit(rect.location(), bitmap, bitmap.rect());
}
}

4
Libraries/LibDraw/StylePainter.h
View file

@ -28,6 +28,8 @@
#include <LibDraw/Color.h>
namespace Gfx {
class Painter;
class Palette;
class Rect;
@ -60,3 +62,5 @@ public:
static void paint_progress_bar(Painter&, const Rect&, const Palette&, int min, int max, int value, const StringView& text = {});
static void paint_radio_button(Painter&, const Rect&, const Palette&, bool is_checked, bool is_being_pressed);
};
}

4
Libraries/LibDraw/SystemTheme.cpp
View file

@ -27,6 +27,8 @@
#include <LibCore/CConfigFile.h>
#include <LibDraw/SystemTheme.h>
namespace Gfx {
static SystemTheme dummy_theme;
static const SystemTheme* theme_page = &dummy_theme;
static RefPtr<SharedBuffer> theme_buffer;
@ -109,3 +111,5 @@ RefPtr<SharedBuffer> load_system_theme(const String& path)
return buffer;
}
}

6
Libraries/LibDraw/SystemTheme.h
View file

@ -30,6 +30,8 @@
#include <AK/Types.h>
#include <LibDraw/Color.h>
namespace Gfx {
enum class ColorRole {
NoRole,
DesktopBackground,
@ -82,3 +84,7 @@ const SystemTheme& current_system_theme();
int current_system_theme_buffer_id();
void set_system_theme(SharedBuffer&);
RefPtr<SharedBuffer> load_system_theme(const String& path);
}
using Gfx::ColorRole;

4
Libraries/LibDraw/TextAlignment.h
View file

@ -26,6 +26,8 @@
#pragma once
namespace Gfx {
enum class TextAlignment {
TopLeft,
CenterLeft,
@ -44,3 +46,5 @@ inline bool is_right_text_alignment(TextAlignment alignment)
return false;
}
}
}

4
Libraries/LibDraw/TextElision.h
View file

@ -26,7 +26,11 @@
#pragma once
namespace Gfx {
enum class TextElision {
None,
Right,
};
}

4
Libraries/LibDraw/Triangle.h
View file

@ -26,6 +26,8 @@
#include <LibDraw/Point.h>
namespace Gfx {
class Triangle {
public:
Triangle(Point a, Point b, Point c)
@ -75,3 +77,5 @@ inline const LogStream& operator<<(const LogStream& stream, const Triangle& valu
{
return stream << value.to_string();
}
}

6
Libraries/LibGUI/GAboutDialog.cpp
View file

@ -32,7 +32,7 @@
namespace GUI {
AboutDialog::AboutDialog(const StringView& name, const GraphicsBitmap* icon, Core::Object* parent)
AboutDialog::AboutDialog(const StringView& name, const Gfx::Bitmap* icon, Core::Object* parent)
: Dialog(parent)
, m_name(name)
, m_icon(icon)
@ -62,11 +62,11 @@ AboutDialog::AboutDialog(const StringView& name, const GraphicsBitmap* icon, Cor
auto make_label = [&](const StringView& text, bool bold = false) {
auto label = Label::construct(text, right_container);
label->set_text_alignment(TextAlignment::CenterLeft);
label->set_text_alignment(Gfx::TextAlignment::CenterLeft);
label->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
label->set_preferred_size(0, 14);
if (bold)
label->set_font(Font::default_bold_font());
label->set_font(Gfx::Font::default_bold_font());
};
make_label(m_name, true);
make_label("SerenityOS");

6
Libraries/LibGUI/GAboutDialog.h
View file

@ -35,16 +35,16 @@ class AboutDialog final : public Dialog {
public:
virtual ~AboutDialog() override;
static void show(const StringView& name, const GraphicsBitmap* icon = nullptr, Core::Object* parent = nullptr)
static void show(const StringView& name, const Gfx::Bitmap* icon = nullptr, Core::Object* parent = nullptr)
{
auto dialog = AboutDialog::construct(name, icon, parent);
dialog->exec();
}
private:
AboutDialog(const StringView& name, const GraphicsBitmap* icon = nullptr, Core::Object* parent = nullptr);
AboutDialog(const StringView& name, const Gfx::Bitmap* icon = nullptr, Core::Object* parent = nullptr);
String m_name;
RefPtr<GraphicsBitmap> m_icon;
RefPtr<Gfx::Bitmap> m_icon;
};
}

8
Libraries/LibGUI/GAbstractButton.cpp
View file

@ -171,19 +171,19 @@ void AbstractButton::keydown_event(KeyEvent& event)
Widget::keydown_event(event);
}
void AbstractButton::paint_text(Painter& painter, const Rect& rect, const Font& font, TextAlignment text_alignment)
void AbstractButton::paint_text(Painter& painter, const Gfx::Rect& rect, const Gfx::Font& font, Gfx::TextAlignment text_alignment)
{
auto clipped_rect = rect.intersected(this->rect());
if (!is_enabled()) {
painter.draw_text(clipped_rect.translated(1, 1), text(), font, text_alignment, Color::White, TextElision::Right);
painter.draw_text(clipped_rect, text(), font, text_alignment, Color::from_rgb(0x808080), TextElision::Right);
painter.draw_text(clipped_rect.translated(1, 1), text(), font, text_alignment, Color::White, Gfx::TextElision::Right);
painter.draw_text(clipped_rect, text(), font, text_alignment, Color::from_rgb(0x808080), Gfx::TextElision::Right);
return;
}
if (text().is_empty())
return;
painter.draw_text(clipped_rect, text(), font, text_alignment, palette().button_text(), TextElision::Right);
painter.draw_text(clipped_rect, text(), font, text_alignment, palette().button_text(), Gfx::TextElision::Right);
if (is_focused())
painter.draw_rect(clipped_rect.inflated(6, 4), Color(140, 140, 140));
}

2
Libraries/LibGUI/GAbstractButton.h
View file

@ -75,7 +75,7 @@ protected:
virtual void leave_event(Core::Event&) override;
virtual void change_event(Event&) override;
void paint_text(Painter&, const Rect&, const Font&, TextAlignment);
void paint_text(Painter&, const Gfx::Rect&, const Gfx::Font&, Gfx::TextAlignment);
private:
virtual bool is_abstract_button() const final { return true; }

18
Libraries/LibGUI/GAbstractTableView.cpp
View file

@ -39,8 +39,8 @@ static const int minimum_column_width = 2;
AbstractTableView::AbstractTableView(Widget* parent)
: AbstractView(parent)
{
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
set_should_hide_unnecessary_scrollbars(true);
@ -144,7 +144,7 @@ void AbstractTableView::paint_headers(Painter& painter)
Rect cell_rect(x_offset, 0, column_width + horizontal_padding() * 2, header_height());
bool pressed = column_index == m_pressed_column_header_index && m_pressed_column_header_is_pressed;
bool hovered = column_index == m_hovered_column_header_index && model()->column_metadata(column_index).sortable == Model::ColumnMetadata::Sortable::True;
StylePainter::paint_button(painter, cell_rect, palette(), ButtonStyle::Normal, pressed, hovered);
Gfx::StylePainter::paint_button(painter, cell_rect, palette(), Gfx::ButtonStyle::Normal, pressed, hovered);
String text;
if (is_key_column) {
StringBuilder builder;
@ -161,7 +161,7 @@ void AbstractTableView::paint_headers(Painter& painter)
auto text_rect = cell_rect.translated(horizontal_padding(), 0);
if (pressed)
text_rect.move_by(1, 1);
painter.draw_text(text_rect, text, header_font(), TextAlignment::CenterLeft, palette().button_text());
painter.draw_text(text_rect, text, header_font(), Gfx::TextAlignment::CenterLeft, palette().button_text());
x_offset += column_width + horizontal_padding() * 2;
}
}
@ -205,9 +205,9 @@ Menu& AbstractTableView::ensure_header_context_menu()
return *m_header_context_menu;
}
const Font& AbstractTableView::header_font()
const Gfx::Font& AbstractTableView::header_font()
{
return Font::default_bold_font();
return Gfx::Font::default_bold_font();
}
void AbstractTableView::set_cell_painting_delegate(int column, OwnPtr<TableCellPaintingDelegate>&& delegate)
@ -378,7 +378,7 @@ void AbstractTableView::mousedown_event(MouseEvent& event)
AbstractView::mousedown_event(event);
}
ModelIndex AbstractTableView::index_at_event_position(const Point& position, bool& is_toggle) const
ModelIndex AbstractTableView::index_at_event_position(const Gfx::Point& position, bool& is_toggle) const
{
is_toggle = false;
if (!model())
@ -398,7 +398,7 @@ ModelIndex AbstractTableView::index_at_event_position(const Point& position, boo
return {};
}
ModelIndex AbstractTableView::index_at_event_position(const Point& position) const
ModelIndex AbstractTableView::index_at_event_position(const Gfx::Point& position) const
{
bool is_toggle;
auto index = index_at_event_position(position, is_toggle);
@ -545,7 +545,7 @@ Rect AbstractTableView::row_rect(int item_index) const
return { 0, header_height() + (item_index * item_height()), max(content_size().width(), width()), item_height() };
}
Point AbstractTableView::adjusted_position(const Point& position) const
Point AbstractTableView::adjusted_position(const Gfx::Point& position) const
{
return position.translated(horizontal_scrollbar().value() - frame_thickness(), vertical_scrollbar().value() - frame_thickness());
}

12
Libraries/LibGUI/GAbstractTableView.h
View file

@ -37,7 +37,7 @@ class TableCellPaintingDelegate {
public:
virtual ~TableCellPaintingDelegate() {}
virtual void paint(Painter&, const Rect&, const Palette&, const Model&, const ModelIndex&) = 0;
virtual void paint(Painter&, const Gfx::Rect&, const Palette&, const Model&, const ModelIndex&) = 0;
};
class AbstractTableView : public AbstractView {
@ -62,7 +62,7 @@ public:
int horizontal_padding() const { return m_horizontal_padding; }
Point adjusted_position(const Point&) const;
Point adjusted_position(const Gfx::Point&) const;
virtual Rect content_rect(const ModelIndex&) const override;
Rect content_rect(int row, int column) const;
@ -70,8 +70,8 @@ public:
void scroll_into_view(const ModelIndex&, Orientation);
virtual ModelIndex index_at_event_position(const Point&, bool& is_toggle) const;
virtual ModelIndex index_at_event_position(const Point&) const override;
virtual ModelIndex index_at_event_position(const Gfx::Point&, bool& is_toggle) const;
virtual ModelIndex index_at_event_position(const Gfx::Point&) const override;
protected:
virtual ~AbstractTableView() override;
@ -91,7 +91,7 @@ protected:
void paint_headers(Painter&);
Rect header_rect(int column) const;
static const Font& header_font();
static const Gfx::Font& header_font();
void update_headers();
void set_hovered_header_index(int);
@ -121,7 +121,7 @@ private:
bool m_in_column_resize { false };
bool m_alternating_row_colors { true };
int m_horizontal_padding { 5 };
Point m_column_resize_origin;
Gfx::Point m_column_resize_origin;
int m_column_resize_original_width { 0 };
int m_resizing_column { -1 };
int m_pressed_column_header_index { -1 };

4
Libraries/LibGUI/GAbstractView.cpp
View file

@ -161,7 +161,7 @@ void AbstractView::notify_selection_changed(Badge<ModelSelection>)
update();
}
NonnullRefPtr<Font> AbstractView::font_for_index(const ModelIndex& index) const
NonnullRefPtr<Gfx::Font> AbstractView::font_for_index(const ModelIndex& index) const
{
if (!model())
return font();
@ -226,7 +226,7 @@ void AbstractView::mousemove_event(MouseEvent& event)
dbg() << "Initiate drag!";
auto drag_operation = DragOperation::construct();
RefPtr<GraphicsBitmap> bitmap;
RefPtr<Gfx::Bitmap> bitmap;
StringBuilder text_builder;
StringBuilder data_builder;

8
Libraries/LibGUI/GAbstractView.h
View file

@ -56,7 +56,7 @@ public:
virtual void did_update_selection();
virtual Rect content_rect(const ModelIndex&) const { return {}; }
virtual ModelIndex index_at_event_position(const Point&) const = 0;
virtual ModelIndex index_at_event_position(const Gfx::Point&) const = 0;
void begin_editing(const ModelIndex&);
void stop_editing();
@ -72,7 +72,7 @@ public:
void notify_selection_changed(Badge<ModelSelection>);
NonnullRefPtr<Font> font_for_index(const ModelIndex&) const;
NonnullRefPtr<Gfx::Font> font_for_index(const ModelIndex&) const;
protected:
explicit AbstractView(Widget* parent);
@ -92,9 +92,9 @@ protected:
bool m_editable { false };
ModelIndex m_edit_index;
RefPtr<Widget> m_edit_widget;
Rect m_edit_widget_content_rect;
Gfx::Rect m_edit_widget_content_rect;
Point m_left_mousedown_position;
Gfx::Point m_left_mousedown_position;
bool m_might_drag { false };
private:

30
Libraries/LibGUI/GAction.cpp
View file

@ -36,47 +36,47 @@ namespace CommonActions {
NonnullRefPtr<Action> make_open_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Open...", { Mod_Ctrl, Key_O }, GraphicsBitmap::load_from_file("/res/icons/16x16/open.png"), move(callback), parent);
return Action::create("Open...", { Mod_Ctrl, Key_O }, Gfx::Bitmap::load_from_file("/res/icons/16x16/open.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_move_to_front_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Move to front", { Mod_Ctrl | Mod_Shift, Key_Up }, GraphicsBitmap::load_from_file("/res/icons/16x16/move-to-front.png"), move(callback), parent);
return Action::create("Move to front", { Mod_Ctrl | Mod_Shift, Key_Up }, Gfx::Bitmap::load_from_file("/res/icons/16x16/move-to-front.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_move_to_back_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Move to back", { Mod_Ctrl | Mod_Shift, Key_Down }, GraphicsBitmap::load_from_file("/res/icons/16x16/move-to-back.png"), move(callback), parent);
return Action::create("Move to back", { Mod_Ctrl | Mod_Shift, Key_Down }, Gfx::Bitmap::load_from_file("/res/icons/16x16/move-to-back.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_undo_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Undo", { Mod_Ctrl, Key_Z }, GraphicsBitmap::load_from_file("/res/icons/16x16/undo.png"), move(callback), parent);
return Action::create("Undo", { Mod_Ctrl, Key_Z }, Gfx::Bitmap::load_from_file("/res/icons/16x16/undo.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_redo_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Redo", { Mod_Ctrl, Key_Y }, GraphicsBitmap::load_from_file("/res/icons/16x16/redo.png"), move(callback), parent);
return Action::create("Redo", { Mod_Ctrl, Key_Y }, Gfx::Bitmap::load_from_file("/res/icons/16x16/redo.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_delete_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Delete", { Mod_None, Key_Delete }, GraphicsBitmap::load_from_file("/res/icons/16x16/delete.png"), move(callback), parent);
return Action::create("Delete", { Mod_None, Key_Delete }, Gfx::Bitmap::load_from_file("/res/icons/16x16/delete.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_cut_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Cut", { Mod_Ctrl, Key_X }, GraphicsBitmap::load_from_file("/res/icons/cut16.png"), move(callback), parent);
return Action::create("Cut", { Mod_Ctrl, Key_X }, Gfx::Bitmap::load_from_file("/res/icons/cut16.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_copy_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Copy", { Mod_Ctrl, Key_C }, GraphicsBitmap::load_from_file("/res/icons/16x16/edit-copy.png"), move(callback), parent);
return Action::create("Copy", { Mod_Ctrl, Key_C }, Gfx::Bitmap::load_from_file("/res/icons/16x16/edit-copy.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_paste_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Paste", { Mod_Ctrl, Key_V }, GraphicsBitmap::load_from_file("/res/icons/paste16.png"), move(callback), parent);
return Action::create("Paste", { Mod_Ctrl, Key_V }, Gfx::Bitmap::load_from_file("/res/icons/paste16.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_fullscreen_action(Function<void(Action&)> callback, Core::Object* parent)
@ -91,22 +91,22 @@ NonnullRefPtr<Action> make_quit_action(Function<void(Action&)> callback)
NonnullRefPtr<Action> make_go_back_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Go back", { Mod_Alt, Key_Left }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-back.png"), move(callback), parent);
return Action::create("Go back", { Mod_Alt, Key_Left }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-back.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_go_forward_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Go forward", { Mod_Alt, Key_Right }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-forward.png"), move(callback), parent);
return Action::create("Go forward", { Mod_Alt, Key_Right }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-forward.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_go_home_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Go home", { Mod_Alt, Key_Home }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-home.png"), move(callback), parent);
return Action::create("Go home", { Mod_Alt, Key_Home }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-home.png"), move(callback), parent);
}
NonnullRefPtr<Action> make_reload_action(Function<void(Action&)> callback, Core::Object* parent)
{
return Action::create("Reload", { Mod_Ctrl, Key_R }, GraphicsBitmap::load_from_file("/res/icons/16x16/reload.png"), move(callback), parent);
return Action::create("Reload", { Mod_Ctrl, Key_R }, Gfx::Bitmap::load_from_file("/res/icons/16x16/reload.png"), move(callback), parent);
}
}
@ -118,7 +118,7 @@ Action::Action(const StringView& text, Function<void(Action&)> on_activation_cal
{
}
Action::Action(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> on_activation_callback, Core::Object* parent)
Action::Action(const StringView& text, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> on_activation_callback, Core::Object* parent)
: Core::Object(parent)
, on_activation(move(on_activation_callback))
, m_text(text)
@ -131,7 +131,7 @@ Action::Action(const StringView& text, const Shortcut& shortcut, Function<void(A
{
}
Action::Action(const StringView& text, const Shortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> on_activation_callback, Core::Object* parent)
Action::Action(const StringView& text, const Shortcut& shortcut, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> on_activation_callback, Core::Object* parent)
: Core::Object(parent)
, on_activation(move(on_activation_callback))
, m_text(text)

14
Libraries/LibGUI/GAction.h
View file

@ -76,7 +76,7 @@ public:
{
return adopt(*new Action(text, move(callback), parent));
}
static NonnullRefPtr<Action> create(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> callback, Core::Object* parent = nullptr)
static NonnullRefPtr<Action> create(const StringView& text, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> callback, Core::Object* parent = nullptr)
{
return adopt(*new Action(text, move(icon), move(callback), parent));
}
@ -84,7 +84,7 @@ public:
{
return adopt(*new Action(text, shortcut, move(callback), parent));
}
static NonnullRefPtr<Action> create(const StringView& text, const Shortcut& shortcut, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> callback, Core::Object* parent = nullptr)
static NonnullRefPtr<Action> create(const StringView& text, const Shortcut& shortcut, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> callback, Core::Object* parent = nullptr)
{
return adopt(*new Action(text, shortcut, move(icon), move(callback), parent));
}
@ -92,8 +92,8 @@ public:
String text() const { return m_text; }
Shortcut shortcut() const { return m_shortcut; }
const GraphicsBitmap* icon() const { return m_icon.ptr(); }
void set_icon(const GraphicsBitmap* icon) { m_icon = icon; }
const Gfx::Bitmap* icon() const { return m_icon.ptr(); }
void set_icon(const Gfx::Bitmap* icon) { m_icon = icon; }
const Core::Object* activator() const { return m_activator.ptr(); }
Core::Object* activator() { return m_activator.ptr(); }
@ -128,8 +128,8 @@ private:
Action(const StringView& text, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
Action(const StringView& text, const Shortcut&, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
Action(const StringView& text, const Shortcut&, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
Action(const StringView& text, RefPtr<GraphicsBitmap>&& icon, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
Action(const StringView& text, const Shortcut&, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
Action(const StringView& text, RefPtr<Gfx::Bitmap>&& icon, Function<void(Action&)> = nullptr, Core::Object* = nullptr);
template<typename Callback>
void for_each_toolbar_button(Callback);
@ -137,7 +137,7 @@ private:
void for_each_menu_item(Callback);
String m_text;
RefPtr<GraphicsBitmap> m_icon;
RefPtr<Gfx::Bitmap> m_icon;
Shortcut m_shortcut;
bool m_enabled { true };
bool m_checkable { false };

8
Libraries/LibGUI/GApplication.cpp
View file

@ -113,8 +113,8 @@ public:
m_label->set_background_color(Color::from_rgb(0xdac7b5));
m_label->set_fill_with_background_color(true);
m_label->set_frame_thickness(1);
m_label->set_frame_shape(FrameShape::Container);
m_label->set_frame_shadow(FrameShadow::Plain);
m_label->set_frame_shape(Gfx::FrameShape::Container);
m_label->set_frame_shadow(Gfx::FrameShadow::Plain);
set_main_widget(m_label);
}
@ -129,7 +129,7 @@ public:
RefPtr<Label> m_label;
};
void Application::show_tooltip(const StringView& tooltip, const Point& screen_location)
void Application::show_tooltip(const StringView& tooltip, const Gfx::Point& screen_location)
{
if (!m_tooltip_window) {
m_tooltip_window = new TooltipWindow;
@ -175,7 +175,7 @@ void Application::did_delete_last_window(Badge<Window>)
void Application::set_system_palette(SharedBuffer& buffer)
{
if (!m_system_palette)
m_system_palette = PaletteImpl::create_with_shared_buffer(buffer);
m_system_palette = Gfx::PaletteImpl::create_with_shared_buffer(buffer);
else
m_system_palette->replace_internal_buffer({}, buffer);

8
Libraries/LibGUI/GApplication.h
View file

@ -38,8 +38,10 @@ class SharedBuffer;
namespace Core {
class EventLoop;
}
namespace Gfx {
class Palette;
class Point;
}
namespace GUI {
class Action;
@ -63,7 +65,7 @@ public:
void register_global_shortcut_action(Badge<Action>, Action&);
void unregister_global_shortcut_action(Badge<Action>, Action&);
void show_tooltip(const StringView&, const Point& screen_location);
void show_tooltip(const StringView&, const Gfx::Point& screen_location);
void hide_tooltip();
bool quit_when_last_window_deleted() const { return m_quit_when_last_window_deleted; }
@ -83,8 +85,8 @@ public:
private:
OwnPtr<Core::EventLoop> m_event_loop;
OwnPtr<MenuBar> m_menubar;
RefPtr<PaletteImpl> m_palette;
RefPtr<PaletteImpl> m_system_palette;
RefPtr<Gfx::PaletteImpl> m_palette;
RefPtr<Gfx::PaletteImpl> m_system_palette;
HashMap<Shortcut, Action*> m_global_shortcut_actions;
class TooltipWindow;
TooltipWindow* m_tooltip_window { nullptr };

6
Libraries/LibGUI/GButton.cpp
View file

@ -55,7 +55,7 @@ void Button::paint_event(PaintEvent& event)
Painter painter(*this);
painter.add_clip_rect(event.rect());
StylePainter::paint_button(painter, rect(), palette(), m_button_style, is_being_pressed(), is_hovered(), is_checked(), is_enabled());
Gfx::StylePainter::paint_button(painter, rect(), palette(), m_button_style, is_being_pressed(), is_hovered(), is_checked(), is_enabled());
if (text().is_empty() && !m_icon)
return;
@ -72,7 +72,7 @@ void Button::paint_event(PaintEvent& event)
else
painter.blit_dimmed(icon_location, *m_icon, m_icon->rect());
}
auto& font = is_checked() ? Font::default_bold_font() : this->font();
auto& font = is_checked() ? Gfx::Font::default_bold_font() : this->font();
if (m_icon && !text().is_empty()) {
content_rect.move_by(m_icon->width() + 4, 0);
content_rect.set_width(content_rect.width() - m_icon->width() - 4);
@ -110,7 +110,7 @@ void Button::set_action(Action& action)
set_checked(action.is_checked());
}
void Button::set_icon(RefPtr<GraphicsBitmap>&& icon)
void Button::set_icon(RefPtr<Gfx::Bitmap>&& icon)
{
if (m_icon == icon)
return;

20
Libraries/LibGUI/GButton.h
View file

@ -42,17 +42,17 @@ class Button : public AbstractButton {
public:
virtual ~Button() override;
void set_icon(RefPtr<GraphicsBitmap>&&);
const GraphicsBitmap* icon() const { return m_icon.ptr(); }
GraphicsBitmap* icon() { return m_icon.ptr(); }
void set_icon(RefPtr<Gfx::Bitmap>&&);
const Gfx::Bitmap* icon() const { return m_icon.ptr(); }
Gfx::Bitmap* icon() { return m_icon.ptr(); }
void set_text_alignment(TextAlignment text_alignment) { m_text_alignment = text_alignment; }
TextAlignment text_alignment() const { return m_text_alignment; }
void set_text_alignment(Gfx::TextAlignment text_alignment) { m_text_alignment = text_alignment; }
Gfx::TextAlignment text_alignment() const { return m_text_alignment; }
Function<void(Button&)> on_click;
void set_button_style(ButtonStyle style) { m_button_style = style; }
ButtonStyle button_style() const { return m_button_style; }
void set_button_style(Gfx::ButtonStyle style) { m_button_style = style; }
Gfx::ButtonStyle button_style() const { return m_button_style; }
virtual void click() override;
@ -69,9 +69,9 @@ protected:
virtual void paint_event(PaintEvent&) override;
private:
RefPtr<GraphicsBitmap> m_icon;
ButtonStyle m_button_style { ButtonStyle::Normal };
TextAlignment m_text_alignment { TextAlignment::Center };
RefPtr<Gfx::Bitmap> m_icon;
Gfx::ButtonStyle m_button_style { Gfx::ButtonStyle::Normal };
Gfx::TextAlignment m_text_alignment { Gfx::TextAlignment::Center };
WeakPtr<Action> m_action;
bool m_focusable { true };
};

8
Libraries/LibGUI/GCheckBox.cpp
View file

@ -45,7 +45,7 @@ static const char* s_checked_bitmap_data = {
" "
};
static CharacterBitmap* s_checked_bitmap;
static Gfx::CharacterBitmap* s_checked_bitmap;
static const int s_checked_bitmap_width = 9;
static const int s_checked_bitmap_height = 9;
static const int s_box_width = 13;
@ -84,18 +84,18 @@ void CheckBox::paint_event(PaintEvent& event)
s_box_width, s_box_height
};
painter.fill_rect(box_rect, palette().base());
StylePainter::paint_frame(painter, box_rect, palette(), FrameShape::Container, FrameShadow::Sunken, 2);
Gfx::StylePainter::paint_frame(painter, box_rect, palette(), Gfx::FrameShape::Container, Gfx::FrameShadow::Sunken, 2);
if (is_being_pressed())
painter.draw_rect(box_rect.shrunken(4, 4), Color::MidGray);
if (is_checked()) {
if (!s_checked_bitmap)
s_checked_bitmap = &CharacterBitmap::create_from_ascii(s_checked_bitmap_data, s_checked_bitmap_width, s_checked_bitmap_height).leak_ref();
s_checked_bitmap = &Gfx::CharacterBitmap::create_from_ascii(s_checked_bitmap_data, s_checked_bitmap_width, s_checked_bitmap_height).leak_ref();
painter.draw_bitmap(box_rect.shrunken(4, 4).location(), *s_checked_bitmap, palette().base_text());
}
paint_text(painter, text_rect, font(), TextAlignment::TopLeft);
paint_text(painter, text_rect, font(), Gfx::TextAlignment::TopLeft);
}
void CheckBox::click()

10
Libraries/LibGUI/GColumnsView.cpp
View file

@ -51,8 +51,8 @@ ColumnsView::ColumnsView(Widget* parent)
set_fill_with_background_color(true);
set_background_role(ColorRole::Base);
set_foreground_role(ColorRole::BaseText);
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
m_columns.append({ {}, 0 });
@ -116,7 +116,7 @@ void ColumnsView::paint_event(PaintEvent& event)
column.width - icon_spacing() - icon_size() - icon_spacing() - icon_spacing() - s_arrow_bitmap_width - icon_spacing(), item_height()
};
auto text = model()->data(index).to_string();
painter.draw_text(text_rect, text, TextAlignment::CenterLeft, text_color);
painter.draw_text(text_rect, text, Gfx::TextAlignment::CenterLeft, text_color);
bool expandable = model()->row_count(index) > 0;
if (expandable) {
@ -125,7 +125,7 @@ void ColumnsView::paint_event(PaintEvent& event)
s_arrow_bitmap_width, s_arrow_bitmap_height
};
arrow_rect.center_vertically_within(row_rect);
static auto& arrow_bitmap = CharacterBitmap::create_from_ascii(s_arrow_bitmap_data, s_arrow_bitmap_width, s_arrow_bitmap_height).leak_ref();
static auto& arrow_bitmap = Gfx::CharacterBitmap::create_from_ascii(s_arrow_bitmap_data, s_arrow_bitmap_width, s_arrow_bitmap_height).leak_ref();
painter.draw_bitmap(arrow_rect.location(), arrow_bitmap, text_color);
}
}
@ -188,7 +188,7 @@ void ColumnsView::update_column_sizes()
set_content_size({ total_width, total_height });
}
ModelIndex ColumnsView::index_at_event_position(const Point& a_position) const
ModelIndex ColumnsView::index_at_event_position(const Gfx::Point& a_position) const
{
if (!model())
return {};

2
Libraries/LibGUI/GColumnsView.h
View file

@ -37,7 +37,7 @@ public:
int model_column() const { return m_model_column; }
void set_model_column(int column) { m_model_column = column; }
virtual ModelIndex index_at_event_position(const Point&) const override;
virtual ModelIndex index_at_event_position(const Gfx::Point&) const override;
private:
ColumnsView(Widget* parent = nullptr);

2
Libraries/LibGUI/GDesktop.cpp
View file

@ -44,7 +44,7 @@ Desktop::Desktop()
{
}
void Desktop::did_receive_screen_rect(Badge<WindowServerConnection>, const Rect& rect)
void Desktop::did_receive_screen_rect(Badge<WindowServerConnection>, const Gfx::Rect& rect)
{
if (m_rect == rect)
return;

6
Libraries/LibGUI/GDesktop.h
View file

@ -44,12 +44,12 @@ public:
bool set_wallpaper(const StringView& path);
Rect rect() const { return m_rect; }
void did_receive_screen_rect(Badge<WindowServerConnection>, const Rect&);
void did_receive_screen_rect(Badge<WindowServerConnection>, const Gfx::Rect&);
Function<void(const Rect&)> on_rect_change;
Function<void(const Gfx::Rect&)> on_rect_change;
private:
Rect m_rect;
Gfx::Rect m_rect;
};
}

2
Libraries/LibGUI/GDragOperation.cpp
View file

@ -48,7 +48,7 @@ DragOperation::Outcome DragOperation::exec()
int bitmap_id = -1;
Size bitmap_size;
RefPtr<GraphicsBitmap> shared_bitmap;
RefPtr<Gfx::Bitmap> shared_bitmap;
if (m_bitmap) {
shared_bitmap = m_bitmap->to_shareable_bitmap();
shared_bitmap->shared_buffer()->share_with(WindowServerConnection::the().server_pid());

8
Libraries/LibGUI/GDragOperation.h
View file

@ -29,7 +29,9 @@
#include <LibCore/CEventLoop.h>
#include <LibCore/CObject.h>
class GraphicsBitmap;
namespace Gfx {
class Bitmap;
}
namespace GUI {
@ -47,7 +49,7 @@ public:
virtual ~DragOperation() override;
void set_text(const String& text) { m_text = text; }
void set_bitmap(const GraphicsBitmap* bitmap) { m_bitmap = bitmap; }
void set_bitmap(const Gfx::Bitmap* bitmap) { m_bitmap = bitmap; }
void set_data(const String& data_type, const String& data)
{
m_data_type = data_type;
@ -71,7 +73,7 @@ private:
String m_text;
String m_data_type;
String m_data;
RefPtr<GraphicsBitmap> m_bitmap;
RefPtr<Gfx::Bitmap> m_bitmap;
};
}

54
Libraries/LibGUI/GEvent.h
View file

@ -108,7 +108,7 @@ public:
class WMWindowStateChangedEvent : public WMEvent {
public:
WMWindowStateChangedEvent(int client_id, int window_id, const StringView& title, const Rect& rect, bool is_active, WindowType window_type, bool is_minimized)
WMWindowStateChangedEvent(int client_id, int window_id, const StringView& title, const Gfx::Rect& rect, bool is_active, WindowType window_type, bool is_minimized)
: WMEvent(Event::Type::WM_WindowStateChanged, client_id, window_id)
, m_title(title)
, m_rect(rect)
@ -126,7 +126,7 @@ public:
private:
String m_title;
Rect m_rect;
Gfx::Rect m_rect;
WindowType m_window_type;
bool m_active;
bool m_minimized;
@ -134,7 +134,7 @@ private:
class WMWindowRectChangedEvent : public WMEvent {
public:
WMWindowRectChangedEvent(int client_id, int window_id, const Rect& rect)
WMWindowRectChangedEvent(int client_id, int window_id, const Gfx::Rect& rect)
: WMEvent(Event::Type::WM_WindowRectChanged, client_id, window_id)
, m_rect(rect)
{
@ -143,12 +143,12 @@ public:
Rect rect() const { return m_rect; }
private:
Rect m_rect;
Gfx::Rect m_rect;
};
class WMWindowIconBitmapChangedEvent : public WMEvent {
public:
WMWindowIconBitmapChangedEvent(int client_id, int window_id, int icon_buffer_id, const Size& icon_size)
WMWindowIconBitmapChangedEvent(int client_id, int window_id, int icon_buffer_id, const Gfx::Size& icon_size)
: WMEvent(Event::Type::WM_WindowIconBitmapChanged, client_id, window_id)
, m_icon_buffer_id(icon_buffer_id)
, m_icon_size(icon_size)
@ -156,16 +156,16 @@ public:
}
int icon_buffer_id() const { return m_icon_buffer_id; }
const Size& icon_size() const { return m_icon_size; }
const Gfx::Size& icon_size() const { return m_icon_size; }
private:
int m_icon_buffer_id;
Size m_icon_size;
Gfx::Size m_icon_size;
};
class MultiPaintEvent final : public Event {
public:
explicit MultiPaintEvent(const Vector<Rect, 32>& rects, const Size& window_size)
explicit MultiPaintEvent(const Vector<Rect, 32>& rects, const Gfx::Size& window_size)
: Event(Event::MultiPaint)
, m_rects(rects)
, m_window_size(window_size)
@ -177,12 +177,12 @@ public:
private:
Vector<Rect, 32> m_rects;
Size m_window_size;
Gfx::Size m_window_size;
};
class PaintEvent final : public Event {
public:
explicit PaintEvent(const Rect& rect, const Size& window_size = Size())
explicit PaintEvent(const Gfx::Rect& rect, const Gfx::Size& window_size = Size())
: Event(Event::Paint)
, m_rect(rect)
, m_window_size(window_size)
@ -193,42 +193,42 @@ public:
Size window_size() const { return m_window_size; }
private:
Rect m_rect;
Size m_window_size;
Gfx::Rect m_rect;
Gfx::Size m_window_size;
};
class ResizeEvent final : public Event {
public:
explicit ResizeEvent(const Size& old_size, const Size& size)
explicit ResizeEvent(const Gfx::Size& old_size, const Gfx::Size& size)
: Event(Event::Resize)
, m_old_size(old_size)
, m_size(size)
{
}
const Size& old_size() const { return m_old_size; }
const Size& size() const { return m_size; }
const Gfx::Size& old_size() const { return m_old_size; }
const Gfx::Size& size() const { return m_size; }
private:
Size m_old_size;
Size m_size;
Gfx::Size m_old_size;
Gfx::Size m_size;
};
class ContextMenuEvent final : public Event {
public:
explicit ContextMenuEvent(const Point& position, const Point& screen_position)
explicit ContextMenuEvent(const Gfx::Point& position, const Gfx::Point& screen_position)
: Event(Event::ContextMenu)
, m_position(position)
, m_screen_position(screen_position)
{
}
const Point& position() const { return m_position; }
const Point& screen_position() const { return m_screen_position; }
const Gfx::Point& position() const { return m_position; }
const Gfx::Point& screen_position() const { return m_screen_position; }
private:
Point m_position;
Point m_screen_position;
Gfx::Point m_position;
Gfx::Point m_screen_position;
};
class ShowEvent final : public Event {
@ -280,7 +280,7 @@ private:
class MouseEvent final : public Event {
public:
MouseEvent(Type type, const Point& position, unsigned buttons, MouseButton button, unsigned modifiers, int wheel_delta)
MouseEvent(Type type, const Gfx::Point& position, unsigned buttons, MouseButton button, unsigned modifiers, int wheel_delta)
: Event(type)
, m_position(position)
, m_buttons(buttons)
@ -299,7 +299,7 @@ public:
int wheel_delta() const { return m_wheel_delta; }
private:
Point m_position;
Gfx::Point m_position;
unsigned m_buttons { 0 };
MouseButton m_button { MouseButton::None };
unsigned m_modifiers { 0 };
@ -308,7 +308,7 @@ private:
class DropEvent final : public Event {
public:
DropEvent(const Point& position, const String& text, const String& data_type, const String& data)
DropEvent(const Gfx::Point& position, const String& text, const String& data_type, const String& data)
: Event(Event::Drop)
, m_position(position)
, m_text(text)
@ -317,13 +317,13 @@ public:
{
}
const Point& position() const { return m_position; }
const Gfx::Point& position() const { return m_position; }
const String& text() const { return m_text; }
const String& data_type() const { return m_data_type; }
const String& data() const { return m_data; }
private:
Point m_position;
Gfx::Point m_position;
String m_text;
String m_data_type;
String m_data;

14
Libraries/LibGUI/GFilePicker.cpp
View file

@ -120,7 +120,7 @@ FilePicker::FilePicker(Mode mode, const StringView& file_name, const StringView&
clear_preview();
};
auto open_parent_directory_action = Action::create("Open parent directory", { Mod_Alt, Key_Up }, GraphicsBitmap::load_from_file("/res/icons/16x16/open-parent-directory.png"), [this](const Action&) {
auto open_parent_directory_action = Action::create("Open parent directory", { Mod_Alt, Key_Up }, Gfx::Bitmap::load_from_file("/res/icons/16x16/open-parent-directory.png"), [this](const Action&) {
m_model->set_root_path(String::format("%s/..", m_model->root_path().characters()));
clear_preview();
});
@ -132,7 +132,7 @@ FilePicker::FilePicker(Mode mode, const StringView& file_name, const StringView&
toolbar->add_action(go_home_action);
toolbar->add_separator();
auto mkdir_action = Action::create("New directory...", GraphicsBitmap::load_from_file("/res/icons/16x16/mkdir.png"), [this](const Action&) {
auto mkdir_action = Action::create("New directory...", Gfx::Bitmap::load_from_file("/res/icons/16x16/mkdir.png"), [this](const Action&) {
auto input_box = InputBox::construct("Enter name:", "New directory", this);
if (input_box->exec() == InputBox::ExecOK && !input_box->text_value().is_empty()) {
auto new_dir_path = FileSystemPath(String::format("%s/%s",
@ -160,7 +160,7 @@ FilePicker::FilePicker(Mode mode, const StringView& file_name, const StringView&
filename_container->set_preferred_size(0, 20);
filename_container->set_layout(make<HBoxLayout>());
auto filename_label = Label::construct("File name:", filename_container);
filename_label->set_text_alignment(TextAlignment::CenterLeft);
filename_label->set_text_alignment(Gfx::TextAlignment::CenterLeft);
filename_label->set_size_policy(SizePolicy::Fixed, SizePolicy::Fill);
filename_label->set_preferred_size(60, 0);
m_filename_textbox = TextBox::construct(filename_container.ptr());
@ -226,8 +226,8 @@ FilePicker::FilePicker(Mode mode, const StringView& file_name, const StringView&
auto preview_container = Frame::construct(horizontal_container);
preview_container->set_size_policy(SizePolicy::Fixed, SizePolicy::Fill);
preview_container->set_preferred_size(180, 0);
preview_container->set_frame_shape(FrameShape::Container);
preview_container->set_frame_shadow(FrameShadow::Sunken);
preview_container->set_frame_shape(Gfx::FrameShape::Container);
preview_container->set_frame_shadow(Gfx::FrameShadow::Sunken);
preview_container->set_frame_thickness(2);
preview_container->set_layout(make<VBoxLayout>());
preview_container->layout()->set_margins({ 8, 8, 8, 8 });
@ -238,7 +238,7 @@ FilePicker::FilePicker(Mode mode, const StringView& file_name, const StringView&
m_preview_image_label->set_preferred_size(160, 160);
m_preview_name_label = Label::construct(preview_container);
m_preview_name_label->set_font(Font::default_bold_font());
m_preview_name_label->set_font(Gfx::Font::default_bold_font());
m_preview_name_label->set_size_policy(SizePolicy::Fill, SizePolicy::Fixed);
m_preview_name_label->set_preferred_size(0, m_preview_name_label->font().glyph_height());
@ -254,7 +254,7 @@ FilePicker::~FilePicker()
void FilePicker::set_preview(const FileSystemPath& path)
{
if (path.has_extension(".png")) {
auto bitmap = load_png(path.string());
auto bitmap = Gfx::load_png(path.string());
if (!bitmap) {
clear_preview();
return;

28
Libraries/LibGUI/GFileSystemModel.cpp
View file

@ -441,14 +441,14 @@ GIcon FileSystemModel::icon_for(const Node& node) const
return icon_for_file(node.mode, node.name);
}
static HashMap<String, RefPtr<GraphicsBitmap>> s_thumbnail_cache;
static HashMap<String, RefPtr<Gfx::Bitmap>> s_thumbnail_cache;
static RefPtr<GraphicsBitmap> render_thumbnail(const StringView& path)
static RefPtr<Gfx::Bitmap> render_thumbnail(const StringView& path)
{
auto png_bitmap = GraphicsBitmap::load_from_file(path);
auto png_bitmap = Gfx::Bitmap::load_from_file(path);
if (!png_bitmap)
return nullptr;
auto thumbnail = GraphicsBitmap::create(png_bitmap->format(), { 32, 32 });
auto thumbnail = Gfx::Bitmap::create(png_bitmap->format(), { 32, 32 });
Painter painter(*thumbnail);
painter.draw_scaled_bitmap(thumbnail->rect(), *png_bitmap, png_bitmap->rect());
return thumbnail;
@ -475,7 +475,7 @@ bool FileSystemModel::fetch_thumbnail_for(const Node& node)
auto weak_this = make_weak_ptr();
LibThread::BackgroundAction<RefPtr<GraphicsBitmap>>::create(
LibThread::BackgroundAction<RefPtr<Gfx::Bitmap>>::create(
[path] {
return render_thumbnail(path);
},
@ -536,23 +536,23 @@ Model::ColumnMetadata FileSystemModel::column_metadata(int column) const
{
switch (column) {
case Column::Icon:
return { 16, TextAlignment::Center, nullptr, Model::ColumnMetadata::Sortable::False };
return { 16, Gfx::TextAlignment::Center, nullptr, Model::ColumnMetadata::Sortable::False };
case Column::Name:
return { 120, TextAlignment::CenterLeft };
return { 120, Gfx::TextAlignment::CenterLeft };
case Column::Size:
return { 80, TextAlignment::CenterRight };
return { 80, Gfx::TextAlignment::CenterRight };
case Column::Owner:
return { 50, TextAlignment::CenterLeft };
return { 50, Gfx::TextAlignment::CenterLeft };
case Column::Group:
return { 50, TextAlignment::CenterLeft };
return { 50, Gfx::TextAlignment::CenterLeft };
case Column::ModificationTime:
return { 110, TextAlignment::CenterLeft };
return { 110, Gfx::TextAlignment::CenterLeft };
case Column::Permissions:
return { 65, TextAlignment::CenterLeft };
return { 65, Gfx::TextAlignment::CenterLeft };
case Column::Inode:
return { 60, TextAlignment::CenterRight };
return { 60, Gfx::TextAlignment::CenterRight };
case Column::SymlinkTarget:
return { 120, TextAlignment::CenterLeft };
return { 120, Gfx::TextAlignment::CenterLeft };
}
ASSERT_NOT_REACHED();
}

2
Libraries/LibGUI/GFileSystemModel.h
View file

@ -74,7 +74,7 @@ public:
size_t total_size { 0 };
mutable RefPtr<GraphicsBitmap> thumbnail;
mutable RefPtr<Gfx::Bitmap> thumbnail;
bool is_directory() const { return S_ISDIR(mode); }
bool is_executable() const { return mode & (S_IXUSR | S_IXGRP | S_IXOTH); }

6
Libraries/LibGUI/GFontDatabase.cpp
View file

@ -51,7 +51,7 @@ GFontDatabase::GFontDatabase()
while (di.has_next()) {
String name = di.next_path();
auto path = String::format("/res/fonts/%s", name.characters());
if (auto font = Font::load_from_file(path)) {
if (auto font = Gfx::Font::load_from_file(path)) {
Metadata metadata;
metadata.path = path;
metadata.glyph_height = font->glyph_height();
@ -89,10 +89,10 @@ void GFontDatabase::for_each_fixed_width_font(Function<void(const StringView&)>
callback(name);
}
RefPtr<Font> GFontDatabase::get_by_name(const StringView& name)
RefPtr<Gfx::Font> GFontDatabase::get_by_name(const StringView& name)
{
auto it = m_name_to_metadata.find(name);
if (it == m_name_to_metadata.end())
return nullptr;
return Font::load_from_file((*it).value.path);
return Gfx::Font::load_from_file((*it).value.path);
}

4
Libraries/LibGUI/GFontDatabase.h
View file

@ -30,7 +30,9 @@
#include <AK/HashMap.h>
#include <AK/String.h>
namespace Gfx {
class Font;
}
struct Metadata {
String path;
@ -42,7 +44,7 @@ class GFontDatabase {
public:
static GFontDatabase& the();
RefPtr<Font> get_by_name(const StringView&);
RefPtr<Gfx::Font> get_by_name(const StringView&);
void for_each_font(Function<void(const StringView&)>);
void for_each_fixed_width_font(Function<void(const StringView&)>);

4
Libraries/LibGUI/GFrame.cpp
View file

@ -41,11 +41,11 @@ Frame::~Frame()
void Frame::paint_event(PaintEvent& event)
{
if (m_shape == FrameShape::NoFrame)
if (m_shape == Gfx::FrameShape::NoFrame)
return;
Painter painter(*this);
painter.add_clip_rect(event.rect());
StylePainter::paint_frame(painter, rect(), palette(), m_shape, m_shadow, m_thickness, spans_entire_window_horizontally());
Gfx::StylePainter::paint_frame(painter, rect(), palette(), m_shape, m_shadow, m_thickness, spans_entire_window_horizontally());
}
}

14
Libraries/LibGUI/GFrame.h
View file

@ -39,13 +39,13 @@ public:
int frame_thickness() const { return m_thickness; }
void set_frame_thickness(int thickness) { m_thickness = thickness; }
FrameShadow frame_shadow() const { return m_shadow; }
void set_frame_shadow(FrameShadow shadow) { m_shadow = shadow; }
Gfx::FrameShadow frame_shadow() const { return m_shadow; }
void set_frame_shadow(Gfx::FrameShadow shadow) { m_shadow = shadow; }
FrameShape frame_shape() const { return m_shape; }
void set_frame_shape(FrameShape shape) { m_shape = shape; }
Gfx::FrameShape frame_shape() const { return m_shape; }
void set_frame_shape(Gfx::FrameShape shape) { m_shape = shape; }
Rect frame_inner_rect_for_size(const Size& size) const { return { m_thickness, m_thickness, size.width() - m_thickness * 2, size.height() - m_thickness * 2 }; }
Rect frame_inner_rect_for_size(const Gfx::Size& size) const { return { m_thickness, m_thickness, size.width() - m_thickness * 2, size.height() - m_thickness * 2 }; }
Rect frame_inner_rect() const { return frame_inner_rect_for_size(size()); }
protected:
@ -54,8 +54,8 @@ protected:
private:
int m_thickness { 0 };
FrameShadow m_shadow { FrameShadow::Plain };
FrameShape m_shape { FrameShape::NoFrame };
Gfx::FrameShadow m_shadow { Gfx::FrameShadow::Plain };
Gfx::FrameShape m_shape { Gfx::FrameShape::NoFrame };
};
}

4
Libraries/LibGUI/GGroupBox.cpp
View file

@ -55,11 +55,11 @@ void GroupBox::paint_event(PaintEvent& event)
0, font().glyph_height() / 2,
width(), height() - font().glyph_height() / 2
};
StylePainter::paint_frame(painter, frame_rect, palette(), FrameShape::Box, FrameShadow::Sunken, 2);
Gfx::StylePainter::paint_frame(painter, frame_rect, palette(), Gfx::FrameShape::Box, Gfx::FrameShadow::Sunken, 2);
Rect text_rect { 4, 0, font().width(m_title) + 6, font().glyph_height() };
painter.fill_rect(text_rect, palette().button());
painter.draw_text(text_rect, m_title, TextAlignment::Center, palette().button_text());
painter.draw_text(text_rect, m_title, Gfx::TextAlignment::Center, palette().button_text());
}
void GroupBox::set_title(const StringView& title)

14
Libraries/LibGUI/GIcon.cpp
View file

@ -41,7 +41,7 @@ GIcon::GIcon(const GIcon& other)
{
}
GIcon::GIcon(RefPtr<GraphicsBitmap>&& bitmap)
GIcon::GIcon(RefPtr<Gfx::Bitmap>&& bitmap)
: GIcon()
{
if (bitmap) {
@ -51,7 +51,7 @@ GIcon::GIcon(RefPtr<GraphicsBitmap>&& bitmap)
}
}
GIcon::GIcon(RefPtr<GraphicsBitmap>&& bitmap1, RefPtr<GraphicsBitmap>&& bitmap2)
GIcon::GIcon(RefPtr<Gfx::Bitmap>&& bitmap1, RefPtr<Gfx::Bitmap>&& bitmap2)
: GIcon(move(bitmap1))
{
if (bitmap2) {
@ -61,14 +61,14 @@ GIcon::GIcon(RefPtr<GraphicsBitmap>&& bitmap1, RefPtr<GraphicsBitmap>&& bitmap2)
}
}
const GraphicsBitmap* GIconImpl::bitmap_for_size(int size) const
const Gfx::Bitmap* GIconImpl::bitmap_for_size(int size) const
{
auto it = m_bitmaps.find(size);
if (it != m_bitmaps.end())
return it->value.ptr();
int best_diff_so_far = INT32_MAX;
const GraphicsBitmap* best_fit = nullptr;
const Gfx::Bitmap* best_fit = nullptr;
for (auto& it : m_bitmaps) {
int abs_diff = abs(it.key - size);
if (abs_diff < best_diff_so_far) {
@ -79,7 +79,7 @@ const GraphicsBitmap* GIconImpl::bitmap_for_size(int size) const
return best_fit;
}
void GIconImpl::set_bitmap_for_size(int size, RefPtr<GraphicsBitmap>&& bitmap)
void GIconImpl::set_bitmap_for_size(int size, RefPtr<Gfx::Bitmap>&& bitmap)
{
if (!bitmap) {
m_bitmaps.remove(size);
@ -90,7 +90,7 @@ void GIconImpl::set_bitmap_for_size(int size, RefPtr<GraphicsBitmap>&& bitmap)
GIcon GIcon::default_icon(const StringView& name)
{
auto bitmap16 = GraphicsBitmap::load_from_file(String::format("/res/icons/16x16/%s.png", String(name).characters()));
auto bitmap32 = GraphicsBitmap::load_from_file(String::format("/res/icons/32x32/%s.png", String(name).characters()));
auto bitmap16 = Gfx::Bitmap::load_from_file(String::format("/res/icons/16x16/%s.png", String(name).characters()));
auto bitmap32 = Gfx::Bitmap::load_from_file(String::format("/res/icons/32x32/%s.png", String(name).characters()));
return GIcon(move(bitmap16), move(bitmap32));
}

14
Libraries/LibGUI/GIcon.h
View file

@ -34,19 +34,19 @@ public:
static NonnullRefPtr<GIconImpl> create() { return adopt(*new GIconImpl); }
~GIconImpl() {}
const GraphicsBitmap* bitmap_for_size(int) const;
void set_bitmap_for_size(int, RefPtr<GraphicsBitmap>&&);
const Gfx::Bitmap* bitmap_for_size(int) const;
void set_bitmap_for_size(int, RefPtr<Gfx::Bitmap>&&);
private:
GIconImpl() {}
HashMap<int, RefPtr<GraphicsBitmap>> m_bitmaps;
HashMap<int, RefPtr<Gfx::Bitmap>> m_bitmaps;
};
class GIcon {
public:
GIcon();
explicit GIcon(RefPtr<GraphicsBitmap>&&);
explicit GIcon(RefPtr<GraphicsBitmap>&&, RefPtr<GraphicsBitmap>&&);
explicit GIcon(RefPtr<Gfx::Bitmap>&&);
explicit GIcon(RefPtr<Gfx::Bitmap>&&, RefPtr<Gfx::Bitmap>&&);
explicit GIcon(const GIconImpl&);
GIcon(const GIcon&);
~GIcon() {}
@ -60,8 +60,8 @@ public:
return *this;
}
const GraphicsBitmap* bitmap_for_size(int size) const { return m_impl->bitmap_for_size(size); }
void set_bitmap_for_size(int size, RefPtr<GraphicsBitmap>&& bitmap) { m_impl->set_bitmap_for_size(size, move(bitmap)); }
const Gfx::Bitmap* bitmap_for_size(int size) const { return m_impl->bitmap_for_size(size); }
void set_bitmap_for_size(int size, RefPtr<Gfx::Bitmap>&& bitmap) { m_impl->set_bitmap_for_size(size, move(bitmap)); }
const GIconImpl& impl() const { return *m_impl; }

14
Libraries/LibGUI/GItemView.cpp
View file

@ -40,8 +40,8 @@ ItemView::ItemView(Widget* parent)
{
set_background_role(ColorRole::Base);
set_foreground_role(ColorRole::BaseText);
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
horizontal_scrollbar().set_visible(false);
}
@ -99,7 +99,7 @@ Rect ItemView::item_rect(int item_index) const
};
}
Vector<int> ItemView::items_intersecting_rect(const Rect& rect) const
Vector<int> ItemView::items_intersecting_rect(const Gfx::Rect& rect) const
{
ASSERT(model());
const auto& column_metadata = model()->column_metadata(model_column());
@ -117,7 +117,7 @@ Vector<int> ItemView::items_intersecting_rect(const Rect& rect) const
return item_indexes;
}
ModelIndex ItemView::index_at_event_position(const Point& position) const
ModelIndex ItemView::index_at_event_position(const Gfx::Point& position) const
{
ASSERT(model());
// FIXME: Since all items are the same size, just compute the clicked item index
@ -204,7 +204,7 @@ void ItemView::mousemove_event(MouseEvent& event)
AbstractView::mousemove_event(event);
}
void ItemView::get_item_rects(int item_index, const Font& font, const Variant& item_text, Rect& item_rect, Rect& icon_rect, Rect& text_rect) const
void ItemView::get_item_rects(int item_index, const Gfx::Font& font, const Variant& item_text, Rect& item_rect, Rect& icon_rect, Rect& text_rect) const
{
item_rect = this->item_rect(item_index);
icon_rect = { 0, 0, 32, 32 };
@ -241,7 +241,7 @@ void ItemView::paint_event(PaintEvent& event)
painter.translate(-horizontal_scrollbar().value(), -vertical_scrollbar().value());
auto column_metadata = model()->column_metadata(m_model_column);
const Font& font = column_metadata.font ? *column_metadata.font : this->font();
const Gfx::Font& font = column_metadata.font ? *column_metadata.font : this->font();
for (int item_index = 0; item_index < model()->row_count(); ++item_index) {
auto model_index = model()->index(item_index, m_model_column);
@ -272,7 +272,7 @@ void ItemView::paint_event(PaintEvent& event)
else
text_color = model()->data(model_index, Model::Role::ForegroundColor).to_color(palette().color(foreground_role()));
painter.fill_rect(text_rect, background_color);
painter.draw_text(text_rect, item_text.to_string(), font, TextAlignment::Center, text_color, TextElision::Right);
painter.draw_text(text_rect, item_text.to_string(), font, Gfx::TextAlignment::Center, text_color, Gfx::TextElision::Right);
};
}

12
Libraries/LibGUI/GItemView.h
View file

@ -50,7 +50,7 @@ public:
int model_column() const { return m_model_column; }
void set_model_column(int column) { m_model_column = column; }
virtual ModelIndex index_at_event_position(const Point&) const override;
virtual ModelIndex index_at_event_position(const Gfx::Point&) const override;
private:
explicit ItemView(Widget* parent);
@ -66,20 +66,20 @@ private:
int item_count() const;
Rect item_rect(int item_index) const;
Vector<int> items_intersecting_rect(const Rect&) const;
Vector<int> items_intersecting_rect(const Gfx::Rect&) const;
void update_content_size();
void get_item_rects(int item_index, const Font&, const Variant& item_text, Rect& item_rect, Rect& icon_rect, Rect& text_rect) const;
void get_item_rects(int item_index, const Gfx::Font&, const Variant& item_text, Rect& item_rect, Rect& icon_rect, Rect& text_rect) const;
int m_horizontal_padding { 5 };
int m_model_column { 0 };
int m_visual_column_count { 0 };
int m_visual_row_count { 0 };
Size m_effective_item_size { 80, 80 };
Gfx::Size m_effective_item_size { 80, 80 };
bool m_rubber_banding { false };
Point m_rubber_band_origin;
Point m_rubber_band_current;
Gfx::Point m_rubber_band_origin;
Gfx::Point m_rubber_band_current;
Vector<ModelIndex> m_rubber_band_remembered_selection;
};

6
Libraries/LibGUI/GJsonArrayModel.h
View file

@ -35,7 +35,7 @@ namespace GUI {
class JsonArrayModel final : public Model {
public:
struct FieldSpec {
FieldSpec(const String& a_column_name, TextAlignment a_text_alignment, Function<Variant(const JsonObject&)>&& a_massage_for_display, Function<Variant(const JsonObject&)>&& a_massage_for_sort = {}, Function<Variant(const JsonObject&)>&& a_massage_for_custom = {})
FieldSpec(const String& a_column_name, Gfx::TextAlignment a_text_alignment, Function<Variant(const JsonObject&)>&& a_massage_for_display, Function<Variant(const JsonObject&)>&& a_massage_for_sort = {}, Function<Variant(const JsonObject&)>&& a_massage_for_custom = {})
: column_name(a_column_name)
, text_alignment(a_text_alignment)
, massage_for_display(move(a_massage_for_display))
@ -44,7 +44,7 @@ public:
{
}
FieldSpec(const String& a_json_field_name, const String& a_column_name, TextAlignment a_text_alignment)
FieldSpec(const String& a_json_field_name, const String& a_column_name, Gfx::TextAlignment a_text_alignment)
: json_field_name(a_json_field_name)
, column_name(a_column_name)
, text_alignment(a_text_alignment)
@ -53,7 +53,7 @@ public:
String json_field_name;
String column_name;
TextAlignment text_alignment;
Gfx::TextAlignment text_alignment;
Function<Variant(const JsonObject&)> massage_for_display;
Function<Variant(const JsonObject&)> massage_for_sort;
Function<Variant(const JsonObject&)> massage_for_custom;

8
Libraries/LibGUI/GLabel.cpp
View file

@ -46,7 +46,7 @@ Label::~Label()
{
}
void Label::set_icon(GraphicsBitmap* icon)
void Label::set_icon(Gfx::Bitmap* icon)
{
if (m_icon == icon)
return;
@ -87,10 +87,10 @@ void Label::paint_event(PaintEvent& event)
text_rect.set_width(text_rect.width() - indent * 2);
if (is_enabled()) {
painter.draw_text(text_rect, text(), m_text_alignment, palette().window_text(), TextElision::Right);
painter.draw_text(text_rect, text(), m_text_alignment, palette().window_text(), Gfx::TextElision::Right);
} else {
painter.draw_text(text_rect.translated(1, 1), text(), font(), text_alignment(), Color::White, TextElision::Right);
painter.draw_text(text_rect, text(), font(), text_alignment(), Color::from_rgb(0x808080), TextElision::Right);
painter.draw_text(text_rect.translated(1, 1), text(), font(), text_alignment(), Color::White, Gfx::TextElision::Right);
painter.draw_text(text_rect, text(), font(), text_alignment(), Color::from_rgb(0x808080), Gfx::TextElision::Right);
}
}

18
Libraries/LibGUI/GLabel.h
View file

@ -29,7 +29,9 @@
#include <LibDraw/TextAlignment.h>
#include <LibGUI/GFrame.h>
class GraphicsBitmap;
namespace Gfx {
class Bitmap;
}
namespace GUI {
@ -41,12 +43,12 @@ public:
String text() const { return m_text; }
void set_text(const StringView&);
void set_icon(GraphicsBitmap*);
const GraphicsBitmap* icon() const { return m_icon.ptr(); }
GraphicsBitmap* icon() { return m_icon.ptr(); }
void set_icon(Gfx::Bitmap*);
const Gfx::Bitmap* icon() const { return m_icon.ptr(); }
Gfx::Bitmap* icon() { return m_icon.ptr(); }
TextAlignment text_alignment() const { return m_text_alignment; }
void set_text_alignment(TextAlignment text_alignment) { m_text_alignment = text_alignment; }
Gfx::TextAlignment text_alignment() const { return m_text_alignment; }
void set_text_alignment(Gfx::TextAlignment text_alignment) { m_text_alignment = text_alignment; }
bool should_stretch_icon() const { return m_should_stretch_icon; }
void set_should_stretch_icon(bool b) { m_should_stretch_icon = b; }
@ -61,8 +63,8 @@ protected:
private:
String m_text;
RefPtr<GraphicsBitmap> m_icon;
TextAlignment m_text_alignment { TextAlignment::Center };
RefPtr<Gfx::Bitmap> m_icon;
Gfx::TextAlignment m_text_alignment { Gfx::TextAlignment::Center };
bool m_should_stretch_icon { false };
};

8
Libraries/LibGUI/GListView.cpp
View file

@ -37,8 +37,8 @@ ListView::ListView(Widget* parent)
{
set_background_role(ColorRole::Base);
set_foreground_role(ColorRole::BaseText);
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
}
@ -86,7 +86,7 @@ Rect ListView::content_rect(const ModelIndex& index) const
return content_rect(index.row());
}
ModelIndex ListView::index_at_event_position(const Point& point) const
ModelIndex ListView::index_at_event_position(const Gfx::Point& point) const
{
ASSERT(model());
@ -99,7 +99,7 @@ ModelIndex ListView::index_at_event_position(const Point& point) const
return {};
}
Point ListView::adjusted_position(const Point& position) const
Point ListView::adjusted_position(const Gfx::Point& position) const
{
return position.translated(horizontal_scrollbar().value() - frame_thickness(), vertical_scrollbar().value() - frame_thickness());
}

4
Libraries/LibGUI/GListView.h
View file

@ -51,9 +51,9 @@ public:
void scroll_into_view(const ModelIndex&, Orientation);
Point adjusted_position(const Point&) const;
Point adjusted_position(const Gfx::Point&) const;
virtual ModelIndex index_at_event_position(const Point&) const override;
virtual ModelIndex index_at_event_position(const Gfx::Point&) const override;
virtual Rect content_rect(const ModelIndex&) const override;
int model_column() const { return m_model_column; }

6
Libraries/LibGUI/GMenu.cpp
View file

@ -84,7 +84,7 @@ void Menu::realize_if_needed()
realize_menu();
}
void Menu::popup(const Point& screen_position)
void Menu::popup(const Gfx::Point& screen_position)
{
realize_if_needed();
WindowServerConnection::the().post_message(WindowServer::PopupMenu(m_menu_id, screen_position));
@ -123,12 +123,12 @@ int Menu::realize_menu()
auto& action = *item.action();
int icon_buffer_id = -1;
if (action.icon()) {
ASSERT(action.icon()->format() == GraphicsBitmap::Format::RGBA32);
ASSERT(action.icon()->format() == Gfx::Bitmap::Format::RGBA32);
ASSERT(action.icon()->size() == Size(16, 16));
if (action.icon()->shared_buffer_id() == -1) {
auto shared_buffer = SharedBuffer::create_with_size(action.icon()->size_in_bytes());
ASSERT(shared_buffer);
auto shared_icon = GraphicsBitmap::create_with_shared_buffer(GraphicsBitmap::Format::RGBA32, *shared_buffer, action.icon()->size());
auto shared_icon = Gfx::Bitmap::create_with_shared_buffer(Gfx::Bitmap::Format::RGBA32, *shared_buffer, action.icon()->size());
memcpy(shared_buffer->data(), action.icon()->bits(0), action.icon()->size_in_bytes());
shared_buffer->seal();
shared_buffer->share_with(WindowServerConnection::the().server_pid());

4
Libraries/LibGUI/GMenu.h
View file

@ -32,7 +32,9 @@
#include <LibCore/CObject.h>
#include <LibGUI/GMenuItem.h>
namespace Gfx {
class Point;
}
namespace GUI {
@ -54,7 +56,7 @@ public:
void add_separator();
void add_submenu(NonnullRefPtr<Menu>);
void popup(const Point& screen_position);
void popup(const Gfx::Point& screen_position);
void dismiss();
Function<void(unsigned)> on_item_activation;

8
Libraries/LibGUI/GMessageBox.cpp
View file

@ -52,15 +52,15 @@ MessageBox::~MessageBox()
{
}
RefPtr<GraphicsBitmap> MessageBox::icon() const
RefPtr<Gfx::Bitmap> MessageBox::icon() const
{
switch (m_type) {
case Type::Information:
return GraphicsBitmap::load_from_file("/res/icons/32x32/msgbox-information.png");
return Gfx::Bitmap::load_from_file("/res/icons/32x32/msgbox-information.png");
case Type::Warning:
return GraphicsBitmap::load_from_file("/res/icons/32x32/msgbox-warning.png");
return Gfx::Bitmap::load_from_file("/res/icons/32x32/msgbox-warning.png");
case Type::Error:
return GraphicsBitmap::load_from_file("/res/icons/32x32/msgbox-error.png");
return Gfx::Bitmap::load_from_file("/res/icons/32x32/msgbox-error.png");
default:
return nullptr;
}

2
Libraries/LibGUI/GMessageBox.h
View file

@ -55,7 +55,7 @@ private:
bool should_include_ok_button() const;
bool should_include_cancel_button() const;
void build();
RefPtr<GraphicsBitmap> icon() const;
RefPtr<Gfx::Bitmap> icon() const;
String m_text;
Type m_type { Type::None };

6
Libraries/LibGUI/GModel.h
View file

@ -35,7 +35,9 @@
#include <LibGUI/GModelIndex.h>
#include <LibGUI/GVariant.h>
namespace Gfx {
class Font;
}
namespace GUI {
@ -51,8 +53,8 @@ class Model : public RefCounted<Model> {
public:
struct ColumnMetadata {
int preferred_width { 0 };
TextAlignment text_alignment { TextAlignment::CenterLeft };
const Font* font { nullptr };
Gfx::TextAlignment text_alignment { Gfx::TextAlignment::CenterLeft };
const Gfx::Font* font { nullptr };
enum class Sortable {
False,
True,

4
Libraries/LibGUI/GPainter.cpp
View file

@ -29,8 +29,8 @@
#include <LibGUI/GWindow.h>
namespace GUI {
Painter::Painter(GraphicsBitmap& bitmap)
: ::Painter(bitmap)
Painter::Painter(Gfx::Bitmap& bitmap)
: Gfx::Painter(bitmap)
{
}

4
Libraries/LibGUI/GPainter.h
View file

@ -32,10 +32,10 @@ namespace GUI {
class Widget;
class Painter : public ::Painter {
class Painter : public Gfx::Painter {
public:
explicit Painter(Widget&);
explicit Painter(GraphicsBitmap&);
explicit Painter(Gfx::Bitmap&);
};
}

6
Libraries/LibGUI/GProgressBar.cpp
View file

@ -33,8 +33,8 @@ namespace GUI {
ProgressBar::ProgressBar(Widget* parent)
: Frame(parent)
{
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
}
@ -83,7 +83,7 @@ void ProgressBar::paint_event(PaintEvent& event)
progress_text = builder.to_string();
}
StylePainter::paint_progress_bar(painter, rect, palette(), m_min, m_max, m_value, progress_text);
Gfx::StylePainter::paint_progress_bar(painter, rect, palette(), m_min, m_max, m_value, progress_text);
}
}

4
Libraries/LibGUI/GRadioButton.cpp
View file

@ -58,11 +58,11 @@ void RadioButton::paint_event(PaintEvent& event)
Rect circle_rect { { 2, 0 }, circle_size() };
circle_rect.center_vertically_within(rect());
StylePainter::paint_radio_button(painter, circle_rect, palette(), is_checked(), is_being_pressed());
Gfx::StylePainter::paint_radio_button(painter, circle_rect, palette(), is_checked(), is_being_pressed());
Rect text_rect { circle_rect.right() + 4, 0, font().width(text()), font().glyph_height() };
text_rect.center_vertically_within(rect());
paint_text(painter, text_rect, font(), TextAlignment::TopLeft);
paint_text(painter, text_rect, font(), Gfx::TextAlignment::TopLeft);
}
template<typename Callback>

2
Libraries/LibGUI/GResizeCorner.cpp
View file

@ -38,7 +38,7 @@ ResizeCorner::ResizeCorner(Widget* parent)
set_background_role(ColorRole::Button);
set_size_policy(SizePolicy::Fixed, SizePolicy::Fixed);
set_preferred_size(16, 16);
m_bitmap = GraphicsBitmap::load_from_file("/res/icons/resize-corner.png");
m_bitmap = Gfx::Bitmap::load_from_file("/res/icons/resize-corner.png");
ASSERT(m_bitmap);
}

2
Libraries/LibGUI/GResizeCorner.h
View file

@ -42,7 +42,7 @@ protected:
virtual void leave_event(Core::Event&) override;
private:
RefPtr<GraphicsBitmap> m_bitmap;
RefPtr<Gfx::Bitmap> m_bitmap;
};
}

22
Libraries/LibGUI/GScrollBar.cpp
View file

@ -81,10 +81,10 @@ static const char* s_right_arrow_bitmap_data = {
" "
};
static CharacterBitmap* s_up_arrow_bitmap;
static CharacterBitmap* s_down_arrow_bitmap;
static CharacterBitmap* s_left_arrow_bitmap;
static CharacterBitmap* s_right_arrow_bitmap;
static Gfx::CharacterBitmap* s_up_arrow_bitmap;
static Gfx::CharacterBitmap* s_down_arrow_bitmap;
static Gfx::CharacterBitmap* s_left_arrow_bitmap;
static Gfx::CharacterBitmap* s_right_arrow_bitmap;
ScrollBar::ScrollBar(Widget* parent)
: ScrollBar(Orientation::Vertical, parent)
@ -97,13 +97,13 @@ ScrollBar::ScrollBar(Orientation orientation, Widget* parent)
{
m_automatic_scrolling_timer = Core::Timer::construct(this);
if (!s_up_arrow_bitmap)
s_up_arrow_bitmap = &CharacterBitmap::create_from_ascii(s_up_arrow_bitmap_data, 9, 9).leak_ref();
s_up_arrow_bitmap = &Gfx::CharacterBitmap::create_from_ascii(s_up_arrow_bitmap_data, 9, 9).leak_ref();
if (!s_down_arrow_bitmap)
s_down_arrow_bitmap = &CharacterBitmap::create_from_ascii(s_down_arrow_bitmap_data, 9, 9).leak_ref();
s_down_arrow_bitmap = &Gfx::CharacterBitmap::create_from_ascii(s_down_arrow_bitmap_data, 9, 9).leak_ref();
if (!s_left_arrow_bitmap)
s_left_arrow_bitmap = &CharacterBitmap::create_from_ascii(s_left_arrow_bitmap_data, 9, 9).leak_ref();
s_left_arrow_bitmap = &Gfx::CharacterBitmap::create_from_ascii(s_left_arrow_bitmap_data, 9, 9).leak_ref();
if (!s_right_arrow_bitmap)
s_right_arrow_bitmap = &CharacterBitmap::create_from_ascii(s_right_arrow_bitmap_data, 9, 9).leak_ref();
s_right_arrow_bitmap = &Gfx::CharacterBitmap::create_from_ascii(s_right_arrow_bitmap_data, 9, 9).leak_ref();
if (m_orientation == Orientation::Vertical) {
set_preferred_size(15, 0);
@ -228,8 +228,8 @@ void ScrollBar::paint_event(PaintEvent& event)
painter.fill_rect(rect(), palette().button().lightened());
StylePainter::paint_button(painter, decrement_button_rect(), palette(), ButtonStyle::Normal, false, m_hovered_component == Component::DecrementButton);
StylePainter::paint_button(painter, increment_button_rect(), palette(), ButtonStyle::Normal, false, m_hovered_component == Component::IncrementButton);
Gfx::StylePainter::paint_button(painter, decrement_button_rect(), palette(), Gfx::ButtonStyle::Normal, false, m_hovered_component == Component::DecrementButton);
Gfx::StylePainter::paint_button(painter, increment_button_rect(), palette(), Gfx::ButtonStyle::Normal, false, m_hovered_component == Component::IncrementButton);
if (length(orientation()) > default_button_size()) {
painter.draw_bitmap(decrement_button_rect().location().translated(3, 3), orientation() == Orientation::Vertical ? *s_up_arrow_bitmap : *s_left_arrow_bitmap, has_scrubber() ? palette().button_text() : palette().threed_shadow1());
@ -237,7 +237,7 @@ void ScrollBar::paint_event(PaintEvent& event)
}
if (has_scrubber())
StylePainter::paint_button(painter, scrubber_rect(), palette(), ButtonStyle::Normal, false, m_hovered_component == Component::Scrubber || m_scrubber_in_use);
Gfx::StylePainter::paint_button(painter, scrubber_rect(), palette(), Gfx::ButtonStyle::Normal, false, m_hovered_component == Component::Scrubber || m_scrubber_in_use);
}
void ScrollBar::on_automatic_scrolling_timer_fired()

2
Libraries/LibGUI/GScrollBar.h
View file

@ -99,7 +99,7 @@ private:
bool m_scrubbing { false };
int m_scrub_start_value { 0 };
Point m_scrub_origin;
Gfx::Point m_scrub_origin;
Orientation m_orientation { Orientation::Vertical };
Component m_hovered_component { Component::Invalid };

12
Libraries/LibGUI/GScrollableWidget.cpp
View file

@ -118,7 +118,7 @@ void ScrollableWidget::update_scrollbar_ranges()
m_vertical_scrollbar->set_big_step(visible_content_rect().height() - m_vertical_scrollbar->step());
}
void ScrollableWidget::set_content_size(const Size& size)
void ScrollableWidget::set_content_size(const Gfx::Size& size)
{
if (m_content_size == size)
return;
@ -126,7 +126,7 @@ void ScrollableWidget::set_content_size(const Size& size)
update_scrollbar_ranges();
}
void ScrollableWidget::set_size_occupied_by_fixed_elements(const Size& size)
void ScrollableWidget::set_size_occupied_by_fixed_elements(const Gfx::Size& size)
{
if (m_size_occupied_by_fixed_elements == size)
return;
@ -154,14 +154,14 @@ Rect ScrollableWidget::visible_content_rect() const
};
}
void ScrollableWidget::scroll_into_view(const Rect& rect, Orientation orientation)
void ScrollableWidget::scroll_into_view(const Gfx::Rect& rect, Orientation orientation)
{
if (orientation == Orientation::Vertical)
return scroll_into_view(rect, false, true);
return scroll_into_view(rect, true, false);
}
void ScrollableWidget::scroll_into_view(const Rect& rect, bool scroll_horizontally, bool scroll_vertically)
void ScrollableWidget::scroll_into_view(const Gfx::Rect& rect, bool scroll_horizontally, bool scroll_vertically)
{
auto visible_content_rect = this->visible_content_rect();
if (visible_content_rect.contains(rect))
@ -209,7 +209,7 @@ Rect ScrollableWidget::widget_inner_rect() const
return rect;
}
Point ScrollableWidget::to_content_position(const Point& widget_position) const
Point ScrollableWidget::to_content_position(const Gfx::Point& widget_position) const
{
auto content_position = widget_position;
content_position.move_by(horizontal_scrollbar().value(), vertical_scrollbar().value());
@ -217,7 +217,7 @@ Point ScrollableWidget::to_content_position(const Point& widget_position) const
return content_position;
}
Point ScrollableWidget::to_widget_position(const Point& content_position) const
Point ScrollableWidget::to_widget_position(const Gfx::Point& content_position) const
{
auto widget_position = content_position;
widget_position.move_by(-horizontal_scrollbar().value(), -vertical_scrollbar().value());

16
Libraries/LibGUI/GScrollableWidget.h
View file

@ -45,8 +45,8 @@ public:
Rect widget_inner_rect() const;
void scroll_into_view(const Rect&, Orientation);
void scroll_into_view(const Rect&, bool scroll_horizontally, bool scroll_vertically);
void scroll_into_view(const Gfx::Rect&, Orientation);
void scroll_into_view(const Gfx::Rect&, bool scroll_horizontally, bool scroll_vertically);
void set_scrollbars_enabled(bool);
bool is_scrollbars_enabled() const { return m_scrollbars_enabled; }
@ -69,8 +69,8 @@ public:
void set_should_hide_unnecessary_scrollbars(bool b) { m_should_hide_unnecessary_scrollbars = b; }
bool should_hide_unnecessary_scrollbars() const { return m_should_hide_unnecessary_scrollbars; }
Point to_content_position(const Point& widget_position) const;
Point to_widget_position(const Point& content_position) const;
Point to_content_position(const Gfx::Point& widget_position) const;
Point to_widget_position(const Gfx::Point& content_position) const;
protected:
explicit ScrollableWidget(Widget* parent);
@ -78,8 +78,8 @@ protected:
virtual void resize_event(ResizeEvent&) override;
virtual void mousewheel_event(MouseEvent&) override;
virtual void did_scroll() {}
void set_content_size(const Size&);
void set_size_occupied_by_fixed_elements(const Size&);
void set_content_size(const Gfx::Size&);
void set_size_occupied_by_fixed_elements(const Gfx::Size&);
private:
void update_scrollbar_ranges();
@ -87,8 +87,8 @@ private:
RefPtr<ScrollBar> m_vertical_scrollbar;
RefPtr<ScrollBar> m_horizontal_scrollbar;
RefPtr<Widget> m_corner_widget;
Size m_content_size;
Size m_size_occupied_by_fixed_elements;
Gfx::Size m_content_size;
Gfx::Size m_size_occupied_by_fixed_elements;
bool m_scrollbars_enabled { true };
bool m_should_hide_unnecessary_scrollbars { false };
};

4
Libraries/LibGUI/GSlider.cpp
View file

@ -83,8 +83,8 @@ void Slider::paint_event(PaintEvent& event)
track_rect.center_horizontally_within(inner_rect());
}
StylePainter::paint_frame(painter, track_rect, palette(), FrameShape::Panel, FrameShadow::Sunken, 1);
StylePainter::paint_button(painter, knob_rect(), palette(), ButtonStyle::Normal, false, m_knob_hovered);
Gfx::StylePainter::paint_frame(painter, track_rect, palette(), Gfx::FrameShape::Panel, Gfx::FrameShadow::Sunken, 1);
Gfx::StylePainter::paint_button(painter, knob_rect(), palette(), Gfx::ButtonStyle::Normal, false, m_knob_hovered);
}
Rect Slider::knob_rect() const

2
Libraries/LibGUI/GSlider.h
View file

@ -91,7 +91,7 @@ private:
bool m_knob_hovered { false };
bool m_dragging { false };
int m_drag_origin_value { 0 };
Point m_drag_origin;
Gfx::Point m_drag_origin;
KnobSizeMode m_knob_size_mode { KnobSizeMode::Fixed };
Orientation m_orientation { Orientation::Horizontal };
};

6
Libraries/LibGUI/GSplitter.h
View file

@ -47,11 +47,11 @@ protected:
private:
Orientation m_orientation;
bool m_resizing { false };
Point m_resize_origin;
Gfx::Point m_resize_origin;
WeakPtr<Widget> m_first_resizee;
WeakPtr<Widget> m_second_resizee;
Size m_first_resizee_start_size;
Size m_second_resizee_start_size;
Gfx::Size m_first_resizee_start_size;
Gfx::Size m_second_resizee_start_size;
};
}

8
Libraries/LibGUI/GStatusBar.cpp
View file

@ -63,10 +63,10 @@ StatusBar::~StatusBar()
NonnullRefPtr<Label> StatusBar::create_label()
{
auto label = Label::construct(this);
label->set_frame_shadow(FrameShadow::Sunken);
label->set_frame_shape(FrameShape::Panel);
label->set_frame_shadow(Gfx::FrameShadow::Sunken);
label->set_frame_shape(Gfx::FrameShape::Panel);
label->set_frame_thickness(1);
label->set_text_alignment(TextAlignment::CenterLeft);
label->set_text_alignment(Gfx::TextAlignment::CenterLeft);
return label;
}
@ -94,7 +94,7 @@ void StatusBar::paint_event(PaintEvent& event)
{
Painter painter(*this);
painter.add_clip_rect(event.rect());
StylePainter::paint_surface(painter, rect(), palette(), !spans_entire_window_horizontally());
Gfx::StylePainter::paint_surface(painter, rect(), palette(), !spans_entire_window_horizontally());
}
}

14
Libraries/LibGUI/GTabWidget.cpp
View file

@ -70,7 +70,7 @@ void TabWidget::resize_event(ResizeEvent& event)
m_active_widget->set_relative_rect(child_rect_for_size(event.size()));
}
Rect TabWidget::child_rect_for_size(const Size& size) const
Rect TabWidget::child_rect_for_size(const Gfx::Size& size) const
{
Rect rect;
switch (m_tab_position) {
@ -143,15 +143,15 @@ void TabWidget::paint_event(PaintEvent& event)
padding_rect.shrink(2, 2);
}
StylePainter::paint_frame(painter, container_rect, palette(), FrameShape::Container, FrameShadow::Raised, 2);
Gfx::StylePainter::paint_frame(painter, container_rect, palette(), Gfx::FrameShape::Container, Gfx::FrameShadow::Raised, 2);
for (int i = 0; i < m_tabs.size(); ++i) {
if (m_tabs[i].widget == m_active_widget)
continue;
bool hovered = i == m_hovered_tab_index;
auto button_rect = this->button_rect(i);
StylePainter::paint_tab_button(painter, button_rect, palette(), false, hovered, m_tabs[i].widget->is_enabled());
painter.draw_text(button_rect.translated(0, 1), m_tabs[i].title, TextAlignment::Center, palette().button_text());
Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), false, hovered, m_tabs[i].widget->is_enabled());
painter.draw_text(button_rect.translated(0, 1), m_tabs[i].title, Gfx::TextAlignment::Center, palette().button_text());
}
for (int i = 0; i < m_tabs.size(); ++i) {
@ -159,8 +159,8 @@ void TabWidget::paint_event(PaintEvent& event)
continue;
bool hovered = i == m_hovered_tab_index;
auto button_rect = this->button_rect(i);
StylePainter::paint_tab_button(painter, button_rect, palette(), true, hovered, m_tabs[i].widget->is_enabled());
painter.draw_text(button_rect.translated(0, 1), m_tabs[i].title, TextAlignment::Center, palette().button_text());
Gfx::StylePainter::paint_tab_button(painter, button_rect, palette(), true, hovered, m_tabs[i].widget->is_enabled());
painter.draw_text(button_rect.translated(0, 1), m_tabs[i].title, Gfx::TextAlignment::Center, palette().button_text());
painter.draw_line(button_rect.bottom_left().translated(1, 1), button_rect.bottom_right().translated(-1, 1), palette().button());
break;
}
@ -183,7 +183,7 @@ Rect TabWidget::button_rect(int index) const
return rect;
}
int TabWidget::TabData::width(const Font& font) const
int TabWidget::TabData::width(const Gfx::Font& font) const
{
return 16 + font.width(title);
}

6
Libraries/LibGUI/GTabWidget.h
View file

@ -64,7 +64,7 @@ protected:
virtual void leave_event(Core::Event&) override;
private:
Rect child_rect_for_size(const Size&) const;
Rect child_rect_for_size(const Gfx::Size&) const;
Rect button_rect(int index) const;
Rect bar_rect() const;
Rect container_rect() const;
@ -73,8 +73,8 @@ private:
RefPtr<Widget> m_active_widget;
struct TabData {
Rect rect(const Font&) const;
int width(const Font&) const;
Rect rect(const Gfx::Font&) const;
int width(const Gfx::Font&) const;
String title;
Widget* widget { nullptr };
};

4
Libraries/LibGUI/GTableView.cpp
View file

@ -104,7 +104,7 @@ void TableView::paint_event(PaintEvent& event)
continue;
auto column_metadata = model()->column_metadata(column_index);
int column_width = this->column_width(column_index);
const Font& font = column_metadata.font ? *column_metadata.font : this->font();
const Gfx::Font& font = column_metadata.font ? *column_metadata.font : this->font();
bool is_key_column = model()->key_column() == column_index;
Rect cell_rect(horizontal_padding() + x_offset, y, column_width, item_height());
if (is_key_column) {
@ -128,7 +128,7 @@ void TableView::paint_event(PaintEvent& event)
text_color = palette().selection_text();
else
text_color = model()->data(cell_index, Model::Role::ForegroundColor).to_color(palette().color(foreground_role()));
painter.draw_text(cell_rect, data.to_string(), font, column_metadata.text_alignment, text_color, TextElision::Right);
painter.draw_text(cell_rect, data.to_string(), font, column_metadata.text_alignment, text_color, Gfx::TextElision::Right);
}
}
x_offset += column_width + horizontal_padding() * 2;

2
Libraries/LibGUI/GTextDocument.h
View file

@ -49,7 +49,7 @@ struct TextDocumentSpan {
Color color;
Optional<Color> background_color;
bool is_skippable { false };
const Font* font { nullptr };
const Gfx::Font* font { nullptr };
void* data { nullptr };
};

36
Libraries/LibGUI/GTextEditor.cpp
View file

@ -58,8 +58,8 @@ TextEditor::TextEditor(Type type, Widget* parent)
set_background_role(ColorRole::Base);
set_foreground_role(ColorRole::BaseText);
set_document(TextDocument::create());
set_frame_shape(FrameShape::Container);
set_frame_shadow(FrameShadow::Sunken);
set_frame_shape(Gfx::FrameShape::Container);
set_frame_shadow(Gfx::FrameShadow::Sunken);
set_frame_thickness(2);
set_scrollbars_enabled(is_multi_line());
set_font(GFontDatabase::the().get_by_name("Csilla Thin"));
@ -86,7 +86,7 @@ void TextEditor::create_actions()
m_paste_action = CommonActions::make_paste_action([&](auto&) { paste(); }, this);
m_delete_action = CommonActions::make_delete_action([&](auto&) { do_delete(); }, this);
m_go_to_line_action = Action::create(
"Go to line...", { Mod_Ctrl, Key_L }, GraphicsBitmap::load_from_file("/res/icons/16x16/go-forward.png"), [this](auto&) {
"Go to line...", { Mod_Ctrl, Key_L }, Gfx::Bitmap::load_from_file("/res/icons/16x16/go-forward.png"), [this](auto&) {
auto input_box = InputBox::construct("Line:", "Go to line", window());
auto result = input_box->exec();
if (result == InputBox::ExecOK) {
@ -134,7 +134,7 @@ void TextEditor::update_content_size()
set_size_occupied_by_fixed_elements({ ruler_width(), 0 });
}
TextPosition TextEditor::text_position_at(const Point& a_position) const
TextPosition TextEditor::text_position_at(const Gfx::Point& a_position) const
{
auto position = a_position;
position.move_by(horizontal_scrollbar().value(), vertical_scrollbar().value());
@ -161,10 +161,10 @@ TextPosition TextEditor::text_position_at(const Point& a_position) const
size_t column_index;
switch (m_text_alignment) {
case TextAlignment::CenterLeft:
case Gfx::TextAlignment::CenterLeft:
column_index = (position.x() + glyph_width() / 2) / glyph_width();
if (is_line_wrapping_enabled()) {
for_each_visual_line(line_index, [&](const Rect& rect, const StringView&, size_t start_of_line) {
for_each_visual_line(line_index, [&](const Gfx::Rect& rect, const StringView&, size_t start_of_line) {
if (rect.contains_vertically(position.y())) {
column_index += start_of_line;
return IterationDecision::Break;
@ -173,7 +173,7 @@ TextPosition TextEditor::text_position_at(const Point& a_position) const
});
}
break;
case TextAlignment::CenterRight:
case Gfx::TextAlignment::CenterRight:
// FIXME: Support right-aligned line wrapping, I guess.
ASSERT(!is_line_wrapping_enabled());
column_index = (position.x() - content_x_for_position({ line_index, 0 }) + glyph_width() / 2) / glyph_width();
@ -376,8 +376,8 @@ void TextEditor::paint_event(PaintEvent& event)
painter.draw_text(
ruler_line_rect.shrunken(2, 0).translated(0, m_line_spacing / 2),
String::number(i + 1),
is_current_line ? Font::default_bold_font() : font(),
TextAlignment::TopRight,
is_current_line ? Gfx::Font::default_bold_font() : font(),
Gfx::TextAlignment::TopRight,
is_current_line ? widget_background_color.darkened(0.2f) : widget_background_color.darkened(0.4f));
}
}
@ -412,7 +412,7 @@ void TextEditor::paint_event(PaintEvent& event)
size_t selection_end_column_within_line = selection.end().line() == line_index ? selection.end().column() : line.length();
size_t visual_line_index = 0;
for_each_visual_line(line_index, [&](const Rect& visual_line_rect, const StringView& visual_line_text, size_t start_of_visual_line) {
for_each_visual_line(line_index, [&](const Gfx::Rect& visual_line_rect, const StringView& visual_line_text, size_t start_of_visual_line) {
if (is_multi_line() && line_index == m_cursor.line())
painter.fill_rect(visual_line_rect, widget_background_color.darkened(0.9f));
#ifdef DEBUG_GTEXTEDITOR
@ -425,7 +425,7 @@ void TextEditor::paint_event(PaintEvent& event)
int advance = font().glyph_width(' ') + font().glyph_spacing();
Rect character_rect = { visual_line_rect.location(), { font().glyph_width(' '), line_height() } };
for (size_t i = 0; i < visual_line_text.length(); ++i) {
const Font* font = &this->font();
const Gfx::Font* font = &this->font();
Color color;
Optional<Color> background_color;
TextPosition physical_position(line_index, start_of_visual_line + i);
@ -479,7 +479,7 @@ void TextEditor::paint_event(PaintEvent& event)
end_of_selection_within_visual_line - start_of_selection_within_visual_line
};
painter.draw_text(selection_rect, visual_selected_text, TextAlignment::CenterLeft, palette().selection_text());
painter.draw_text(selection_rect, visual_selected_text, Gfx::TextAlignment::CenterLeft, palette().selection_text());
}
}
++visual_line_index;
@ -894,8 +894,8 @@ int TextEditor::content_x_for_position(const TextPosition& position) const
auto& line = this->line(position.line());
int x_offset = -1;
switch (m_text_alignment) {
case TextAlignment::CenterLeft:
for_each_visual_line(position.line(), [&](const Rect&, const StringView& view, size_t start_of_visual_line) {
case Gfx::TextAlignment::CenterLeft:
for_each_visual_line(position.line(), [&](const Gfx::Rect&, const StringView& view, size_t start_of_visual_line) {
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
x_offset = (position.column() - start_of_visual_line) * glyph_width();
return IterationDecision::Break;
@ -903,7 +903,7 @@ int TextEditor::content_x_for_position(const TextPosition& position) const
return IterationDecision::Continue;
});
return m_horizontal_content_padding + x_offset;
case TextAlignment::CenterRight:
case Gfx::TextAlignment::CenterRight:
// FIXME
ASSERT(!is_line_wrapping_enabled());
return content_width() - m_horizontal_content_padding - (line.length() * glyph_width()) + (position.column() * glyph_width());
@ -928,7 +928,7 @@ Rect TextEditor::content_rect_for_position(const TextPosition& position) const
}
Rect rect;
for_each_visual_line(position.line(), [&](const Rect& visual_line_rect, const StringView& view, size_t start_of_visual_line) {
for_each_visual_line(position.line(), [&](const Gfx::Rect& visual_line_rect, const StringView& view, size_t start_of_visual_line) {
if (position.column() >= start_of_visual_line && ((position.column() - start_of_visual_line) <= view.length())) {
// NOTE: We have to subtract the horizontal padding here since it's part of the visual line rect
// *and* included in what we get from content_x_for_position().
@ -1250,7 +1250,7 @@ void TextEditor::context_menu_event(ContextMenuEvent& event)
m_context_menu->popup(event.screen_position());
}
void TextEditor::set_text_alignment(TextAlignment alignment)
void TextEditor::set_text_alignment(Gfx::TextAlignment alignment)
{
if (m_text_alignment == alignment)
return;
@ -1309,7 +1309,7 @@ void TextEditor::ensure_cursor_is_valid()
size_t TextEditor::visual_line_containing(size_t line_index, size_t column) const
{
size_t visual_line_index = 0;
for_each_visual_line(line_index, [&](const Rect&, const StringView& view, size_t start_of_visual_line) {
for_each_visual_line(line_index, [&](const Gfx::Rect&, const StringView& view, size_t start_of_visual_line) {
if (column >= start_of_visual_line && ((column - start_of_visual_line) < view.length()))
return IterationDecision::Break;
++visual_line_index;

8
Libraries/LibGUI/GTextEditor.h
View file

@ -70,8 +70,8 @@ public:
bool is_line_wrapping_enabled() const { return m_line_wrapping_enabled; }
void set_line_wrapping_enabled(bool);
TextAlignment text_alignment() const { return m_text_alignment; }
void set_text_alignment(TextAlignment);
Gfx::TextAlignment text_alignment() const { return m_text_alignment; }
void set_text_alignment(Gfx::TextAlignment);
Type type() const { return m_type; }
bool is_single_line() const { return m_type == SingleLine; }
@ -154,7 +154,7 @@ protected:
virtual void resize_event(ResizeEvent&) override;
virtual void cursor_did_change() {}
TextPosition text_position_at(const Point&) const;
TextPosition text_position_at(const Gfx::Point&) const;
private:
friend class TextDocumentLine;
@ -214,7 +214,7 @@ private:
Type m_type { MultiLine };
TextPosition m_cursor;
TextAlignment m_text_alignment { TextAlignment::CenterLeft };
Gfx::TextAlignment m_text_alignment { Gfx::TextAlignment::CenterLeft };
bool m_cursor_state { true };
bool m_in_drag_select { false };
bool m_ruler_visible { false };

4
Libraries/LibGUI/GToolBar.cpp
View file

@ -75,7 +75,7 @@ void ToolBar::add_action(Action& action)
else
button->set_text(item->action->text());
button->set_button_style(ButtonStyle::CoolBar);
button->set_button_style(Gfx::ButtonStyle::CoolBar);
button->set_size_policy(SizePolicy::Fixed, SizePolicy::Fixed);
ASSERT(button->size_policy(Orientation::Horizontal) == SizePolicy::Fixed);
ASSERT(button->size_policy(Orientation::Vertical) == SizePolicy::Fixed);
@ -119,7 +119,7 @@ void ToolBar::paint_event(PaintEvent& event)
painter.add_clip_rect(event.rect());
if (m_has_frame)
StylePainter::paint_surface(painter, rect(), palette(), x() != 0, y() != 0);
Gfx::StylePainter::paint_surface(painter, rect(), palette(), x() != 0, y() != 0);
else
painter.fill_rect(event.rect(), palette().button());
}

Some files were not shown because too many files have changed in this diff Show more