2020-01-18 08:38:21 +00:00
|
|
|
/*
|
|
|
|
* Copyright (c) 2018-2020, Andreas Kling <kling@serenityos.org>
|
|
|
|
* All rights reserved.
|
|
|
|
*
|
|
|
|
* Redistribution and use in source and binary forms, with or without
|
|
|
|
* modification, are permitted provided that the following conditions are met:
|
|
|
|
*
|
|
|
|
* 1. Redistributions of source code must retain the above copyright notice, this
|
|
|
|
* list of conditions and the following disclaimer.
|
|
|
|
*
|
|
|
|
* 2. Redistributions in binary form must reproduce the above copyright notice,
|
|
|
|
* this list of conditions and the following disclaimer in the documentation
|
|
|
|
* and/or other materials provided with the distribution.
|
|
|
|
*
|
|
|
|
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
|
|
|
|
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
|
|
|
|
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
|
|
|
|
* DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE
|
|
|
|
* FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL
|
|
|
|
* DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
|
|
|
|
* SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
|
|
|
|
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY,
|
|
|
|
* OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
|
|
|
|
* OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
|
|
|
|
*/
|
|
|
|
|
2018-10-10 14:49:36 +00:00
|
|
|
#pragma once
|
|
|
|
|
2020-02-14 22:28:42 +00:00
|
|
|
#include <AK/Forward.h>
|
2020-02-14 23:58:14 +00:00
|
|
|
#include <AK/NonnullRefPtr.h>
|
2020-02-14 20:41:10 +00:00
|
|
|
#include <AK/Vector.h>
|
|
|
|
#include <LibGfx/Color.h>
|
2020-02-14 22:28:42 +00:00
|
|
|
#include <LibGfx/Forward.h>
|
2020-02-14 20:41:10 +00:00
|
|
|
#include <LibGfx/Point.h>
|
|
|
|
#include <LibGfx/Rect.h>
|
|
|
|
#include <LibGfx/Size.h>
|
2020-02-06 11:04:00 +00:00
|
|
|
#include <LibGfx/TextAlignment.h>
|
|
|
|
#include <LibGfx/TextElision.h>
|
2018-10-10 14:49:36 +00:00
|
|
|
|
2020-02-06 10:56:38 +00:00
|
|
|
namespace Gfx {
|
|
|
|
|
2018-10-10 14:49:36 +00:00
|
|
|
class Painter {
|
|
|
|
public:
|
2020-02-06 10:56:38 +00:00
|
|
|
explicit Painter(Gfx::Bitmap&);
|
2018-10-10 14:49:36 +00:00
|
|
|
~Painter();
|
2020-05-10 10:58:33 +00:00
|
|
|
|
|
|
|
enum class LineStyle {
|
|
|
|
Solid,
|
|
|
|
Dotted,
|
2020-05-10 15:17:26 +00:00
|
|
|
Dashed,
|
2020-05-10 10:58:33 +00:00
|
|
|
};
|
|
|
|
|
2020-06-10 08:57:59 +00:00
|
|
|
void clear_rect(const IntRect&, Color);
|
|
|
|
void fill_rect(const IntRect&, Color);
|
|
|
|
void fill_rect_with_dither_pattern(const IntRect&, Color, Color);
|
|
|
|
void fill_rect_with_checkerboard(const IntRect&, const IntSize&, Color color_dark, Color color_light);
|
|
|
|
void fill_rect_with_gradient(Orientation, const IntRect&, Color gradient_start, Color gradient_end);
|
|
|
|
void fill_rect_with_gradient(const IntRect&, Color gradient_start, Color gradient_end);
|
|
|
|
void fill_ellipse(const IntRect&, Color);
|
|
|
|
void draw_rect(const IntRect&, Color, bool rough = false);
|
2020-10-26 19:43:59 +00:00
|
|
|
void draw_focus_rect(const IntRect&, Color);
|
2020-06-10 08:57:59 +00:00
|
|
|
void draw_bitmap(const IntPoint&, const CharacterBitmap&, Color = Color());
|
|
|
|
void draw_bitmap(const IntPoint&, const GlyphBitmap&, Color = Color());
|
2020-07-22 06:46:15 +00:00
|
|
|
void draw_scaled_bitmap(const IntRect& dst_rect, const Gfx::Bitmap&, const IntRect& src_rect, float opacity = 1.0f);
|
2020-06-10 08:57:59 +00:00
|
|
|
void draw_triangle(const IntPoint&, const IntPoint&, const IntPoint&, Color);
|
|
|
|
void draw_ellipse_intersecting(const IntRect&, Color, int thickness = 1);
|
|
|
|
void set_pixel(const IntPoint&, Color);
|
2020-08-23 21:39:27 +00:00
|
|
|
void set_pixel(int x, int y, Color color) { set_pixel({ x, y }, color); }
|
2020-06-10 08:57:59 +00:00
|
|
|
void draw_line(const IntPoint&, const IntPoint&, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
|
|
|
|
void draw_quadratic_bezier_curve(const IntPoint& control_point, const IntPoint&, const IntPoint&, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
|
2020-07-22 06:46:15 +00:00
|
|
|
void draw_elliptical_arc(const IntPoint& p1, const IntPoint& p2, const IntPoint& center, const FloatPoint& radii, float x_axis_rotation, float theta_1, float theta_delta, Color, int thickness = 1, LineStyle style = LineStyle::Solid);
|
2020-06-10 08:57:59 +00:00
|
|
|
void blit(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect, float opacity = 1.0f);
|
|
|
|
void blit_dimmed(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect);
|
|
|
|
void blit_brightened(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect);
|
|
|
|
void blit_filtered(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect, Function<Color(Color)>);
|
|
|
|
void draw_tiled_bitmap(const IntRect& dst_rect, const Gfx::Bitmap&);
|
|
|
|
void blit_offset(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect, const IntPoint&);
|
|
|
|
void blit_scaled(const IntRect&, const Gfx::Bitmap&, const IntRect&, float, float);
|
2020-10-27 20:17:50 +00:00
|
|
|
void blit_disabled(const IntPoint&, const Gfx::Bitmap&, const IntRect&, const Palette&);
|
2020-06-10 08:57:59 +00:00
|
|
|
void draw_text(const IntRect&, const StringView&, const Font&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
|
|
|
|
void draw_text(const IntRect&, const StringView&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
|
|
|
|
void draw_text(const IntRect&, const Utf32View&, const Font&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
|
|
|
|
void draw_text(const IntRect&, const Utf32View&, TextAlignment = TextAlignment::TopLeft, Color = Color::Black, TextElision = TextElision::None);
|
2020-10-20 15:51:04 +00:00
|
|
|
void draw_text(Function<void(const IntRect&, u32)>, const IntRect&, const StringView&, const Font&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None);
|
|
|
|
void draw_text(Function<void(const IntRect&, u32)>, const IntRect&, const Utf8View&, const Font&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None);
|
|
|
|
void draw_text(Function<void(const IntRect&, u32)>, const IntRect&, const Utf32View&, const Font&, TextAlignment = TextAlignment::TopLeft, TextElision = TextElision::None);
|
2020-06-10 08:57:59 +00:00
|
|
|
void draw_glyph(const IntPoint&, u32, Color);
|
|
|
|
void draw_glyph(const IntPoint&, u32, const Font&, Color);
|
|
|
|
void draw_emoji(const IntPoint&, const Gfx::Bitmap&, const Font&);
|
2020-08-05 20:31:20 +00:00
|
|
|
void draw_glyph_or_emoji(const IntPoint&, u32 code_point, const Font&, Color);
|
2019-01-12 16:02:54 +00:00
|
|
|
|
2020-05-06 07:25:12 +00:00
|
|
|
static void for_each_line_segment_on_bezier_curve(const FloatPoint& control_point, const FloatPoint& p1, const FloatPoint& p2, Function<void(const FloatPoint&, const FloatPoint&)>&);
|
|
|
|
static void for_each_line_segment_on_bezier_curve(const FloatPoint& control_point, const FloatPoint& p1, const FloatPoint& p2, Function<void(const FloatPoint&, const FloatPoint&)>&&);
|
|
|
|
|
2020-07-22 06:46:15 +00:00
|
|
|
static void for_each_line_segment_on_elliptical_arc(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& center, const FloatPoint radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(const FloatPoint&, const FloatPoint&)>&);
|
|
|
|
static void for_each_line_segment_on_elliptical_arc(const FloatPoint& p1, const FloatPoint& p2, const FloatPoint& center, const FloatPoint radii, float x_axis_rotation, float theta_1, float theta_delta, Function<void(const FloatPoint&, const FloatPoint&)>&&);
|
|
|
|
|
2020-04-16 19:03:17 +00:00
|
|
|
void stroke_path(const Path&, Color, int thickness);
|
|
|
|
|
2020-05-06 07:25:12 +00:00
|
|
|
enum class WindingRule {
|
|
|
|
Nonzero,
|
|
|
|
EvenOdd,
|
|
|
|
};
|
|
|
|
void fill_path(Path&, Color, WindingRule rule = WindingRule::Nonzero);
|
|
|
|
|
2019-03-09 15:48:02 +00:00
|
|
|
const Font& font() const { return *state().font; }
|
|
|
|
void set_font(const Font& font) { state().font = &font; }
|
2018-10-11 21:45:57 +00:00
|
|
|
|
2019-06-07 15:13:23 +00:00
|
|
|
enum class DrawOp {
|
2019-06-05 16:22:11 +00:00
|
|
|
Copy,
|
2020-09-08 04:25:30 +00:00
|
|
|
Xor,
|
|
|
|
Invert
|
2019-06-05 16:22:11 +00:00
|
|
|
};
|
2019-03-09 15:48:02 +00:00
|
|
|
void set_draw_op(DrawOp op) { state().draw_op = op; }
|
|
|
|
DrawOp draw_op() const { return state().draw_op; }
|
2019-01-11 02:52:09 +00:00
|
|
|
|
2020-06-10 08:57:59 +00:00
|
|
|
void add_clip_rect(const IntRect& rect);
|
2019-01-24 22:40:12 +00:00
|
|
|
void clear_clip_rect();
|
2020-06-10 08:57:59 +00:00
|
|
|
IntRect clip_rect() const { return state().clip_rect; }
|
2019-01-20 22:42:36 +00:00
|
|
|
|
2019-03-09 15:48:02 +00:00
|
|
|
void translate(int dx, int dy) { state().translation.move_by(dx, dy); }
|
2020-06-10 08:57:59 +00:00
|
|
|
void translate(const IntPoint& delta) { state().translation.move_by(delta); }
|
2019-02-04 14:37:23 +00:00
|
|
|
|
2020-06-10 08:57:59 +00:00
|
|
|
IntPoint translation() const { return state().translation; }
|
2019-03-07 12:13:25 +00:00
|
|
|
|
2020-02-06 10:56:38 +00:00
|
|
|
Gfx::Bitmap* target() { return m_target.ptr(); }
|
2019-02-10 13:28:39 +00:00
|
|
|
|
2019-03-09 15:48:02 +00:00
|
|
|
void save() { m_state_stack.append(m_state_stack.last()); }
|
2019-06-05 16:22:11 +00:00
|
|
|
void restore()
|
|
|
|
{
|
|
|
|
ASSERT(m_state_stack.size() > 1);
|
|
|
|
m_state_stack.take_last();
|
|
|
|
}
|
2019-03-09 15:48:02 +00:00
|
|
|
|
2019-03-28 16:19:56 +00:00
|
|
|
protected:
|
2019-07-03 19:17:35 +00:00
|
|
|
void set_pixel_with_draw_op(u32& pixel, const Color&);
|
2020-09-08 04:25:30 +00:00
|
|
|
void fill_scanline_with_draw_op(int y, int x, int width, const Color& color);
|
2020-06-10 08:57:59 +00:00
|
|
|
void fill_rect_with_draw_op(const IntRect&, Color);
|
|
|
|
void blit_with_alpha(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect);
|
|
|
|
void blit_with_opacity(const IntPoint&, const Gfx::Bitmap&, const IntRect& src_rect, float opacity);
|
|
|
|
void draw_pixel(const IntPoint&, Color, int thickness = 1);
|
2019-01-11 02:52:09 +00:00
|
|
|
|
2019-03-09 15:48:02 +00:00
|
|
|
struct State {
|
|
|
|
const Font* font;
|
2020-06-10 08:57:59 +00:00
|
|
|
IntPoint translation;
|
|
|
|
IntRect clip_rect;
|
2019-03-09 15:48:02 +00:00
|
|
|
DrawOp draw_op;
|
|
|
|
};
|
|
|
|
|
|
|
|
State& state() { return m_state_stack.last(); }
|
|
|
|
const State& state() const { return m_state_stack.last(); }
|
|
|
|
|
2020-06-10 08:57:59 +00:00
|
|
|
IntRect m_clip_origin;
|
2020-02-06 10:56:38 +00:00
|
|
|
NonnullRefPtr<Gfx::Bitmap> m_target;
|
2019-04-20 12:02:19 +00:00
|
|
|
Vector<State, 4> m_state_stack;
|
2018-10-10 14:49:36 +00:00
|
|
|
};
|
2019-03-09 15:54:41 +00:00
|
|
|
|
|
|
|
class PainterStateSaver {
|
|
|
|
public:
|
2019-04-15 23:01:03 +00:00
|
|
|
explicit PainterStateSaver(Painter&);
|
|
|
|
~PainterStateSaver();
|
2019-03-09 15:54:41 +00:00
|
|
|
|
|
|
|
private:
|
|
|
|
Painter& m_painter;
|
|
|
|
};
|
2020-02-06 10:56:38 +00:00
|
|
|
|
|
|
|
}
|