357 lines
11 KiB
C++
357 lines
11 KiB
C++
/*
|
|
* Copyright (c) 2018-2021, Andreas Kling <kling@serenityos.org>
|
|
*
|
|
* SPDX-License-Identifier: BSD-2-Clause
|
|
*/
|
|
|
|
#include <AK/StdLibExtras.h>
|
|
#include <AK/String.h>
|
|
#include <AK/Vector.h>
|
|
#include <LibGfx/Line.h>
|
|
#include <LibGfx/Rect.h>
|
|
#include <LibIPC/Decoder.h>
|
|
#include <LibIPC/Encoder.h>
|
|
|
|
namespace Gfx {
|
|
|
|
template<typename T>
|
|
|
|
Rect<T>::RelativeLocation::RelativeLocation(Rect<T> const& base_rect, Rect<T> const& other_rect)
|
|
{
|
|
if (base_rect.is_empty() || other_rect.is_empty())
|
|
return;
|
|
auto parts = base_rect.shatter(other_rect);
|
|
for (auto& part : parts) {
|
|
if (part.x() < other_rect.x()) {
|
|
if (part.y() < other_rect.y())
|
|
m_top_left = true;
|
|
if ((part.y() >= other_rect.y() && part.y() < other_rect.bottom()) || (part.y() <= other_rect.bottom() && part.bottom() > other_rect.y()))
|
|
m_left = true;
|
|
if (part.y() >= other_rect.bottom() || part.bottom() > other_rect.y())
|
|
m_bottom_left = true;
|
|
}
|
|
if (part.x() >= other_rect.x() || part.right() > other_rect.x()) {
|
|
if (part.y() < other_rect.y())
|
|
m_top = true;
|
|
if (part.y() >= other_rect.bottom() || part.bottom() > other_rect.bottom())
|
|
m_bottom = true;
|
|
}
|
|
if (part.x() >= other_rect.right() || part.right() > other_rect.right()) {
|
|
if (part.y() < other_rect.y())
|
|
m_top_right = true;
|
|
if ((part.y() >= other_rect.y() && part.y() < other_rect.bottom()) || (part.y() <= other_rect.bottom() && part.bottom() > other_rect.y()))
|
|
m_right = true;
|
|
if (part.y() >= other_rect.bottom() || part.bottom() > other_rect.y())
|
|
m_bottom_right = true;
|
|
}
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
Vector<Point<T>, 2> Rect<T>::intersected(Line<T> const& line) const
|
|
{
|
|
if (is_empty())
|
|
return {};
|
|
Vector<Point<T>, 2> points;
|
|
if (auto point = line.intersected({ top_left(), top_right() }); point.has_value())
|
|
points.append({ point.value().x(), y() });
|
|
if (auto point = line.intersected({ bottom_left(), bottom_right() }); point.has_value()) {
|
|
points.append({ point.value().x(), bottom() });
|
|
if (points.size() == 2)
|
|
return points;
|
|
}
|
|
if (height() > 2) {
|
|
if (auto point = line.intersected({ { x(), y() + 1 }, { x(), bottom() - 1 } }); point.has_value()) {
|
|
points.append({ x(), point.value().y() });
|
|
if (points.size() == 2)
|
|
return points;
|
|
}
|
|
if (auto point = line.intersected({ { right(), y() + 1 }, { right(), bottom() - 1 } }); point.has_value())
|
|
points.append({ right(), point.value().y() });
|
|
}
|
|
return points;
|
|
}
|
|
|
|
template<typename T>
|
|
float Rect<T>::center_point_distance_to(Rect<T> const& other) const
|
|
{
|
|
return Line { center(), other.center() }.length();
|
|
}
|
|
|
|
template<typename T>
|
|
Vector<Point<T>, 2> Rect<T>::closest_outside_center_points(Rect<T> const& other) const
|
|
{
|
|
if (intersects(other))
|
|
return {};
|
|
Line centers_line { center(), other.center() };
|
|
auto points_this = intersected(centers_line);
|
|
VERIFY(points_this.size() == 1);
|
|
auto points_other = other.intersected(centers_line);
|
|
VERIFY(points_other.size() == 1);
|
|
return { points_this[0], points_other[0] };
|
|
}
|
|
|
|
template<typename T>
|
|
float Rect<T>::outside_center_point_distance_to(Rect<T> const& other) const
|
|
{
|
|
auto points = closest_outside_center_points(other);
|
|
if (points.is_empty())
|
|
return 0.0;
|
|
return Line { points[0], points[0] }.length();
|
|
}
|
|
|
|
template<typename T>
|
|
Rect<T> Rect<T>::constrained_to(Rect<T> const& constrain_rect) const
|
|
{
|
|
if (constrain_rect.contains(*this))
|
|
return *this;
|
|
T move_x = 0, move_y = 0;
|
|
if (right() > constrain_rect.right())
|
|
move_x = constrain_rect.right() - right();
|
|
if (bottom() > constrain_rect.bottom())
|
|
move_y = constrain_rect.bottom() - bottom();
|
|
if (x() < constrain_rect.x())
|
|
move_x = x() - constrain_rect.x();
|
|
if (y() < constrain_rect.y())
|
|
move_y = y() - constrain_rect.y();
|
|
auto rect = *this;
|
|
if (move_x != 0 || move_y != 0)
|
|
rect.translate_by(move_x, move_y);
|
|
return rect;
|
|
}
|
|
|
|
template<typename T>
|
|
Rect<T> Rect<T>::aligned_within(Size<T> const& rect_size, Point<T> const& align_at, TextAlignment alignment) const
|
|
{
|
|
if (rect_size.is_empty())
|
|
return {};
|
|
if (!size().contains(rect_size))
|
|
return {};
|
|
if (!contains(align_at))
|
|
return {};
|
|
|
|
Rect<T> rect;
|
|
switch (alignment) {
|
|
case TextAlignment::TopCenter:
|
|
rect = { { align_at.x() - rect_size.width() / 2, align_at.y() }, rect_size };
|
|
break;
|
|
case TextAlignment::TopLeft:
|
|
rect = { align_at, rect_size };
|
|
break;
|
|
case TextAlignment::TopRight:
|
|
rect = { { align_at.x() - rect_size.width(), align_at.y() }, rect_size };
|
|
break;
|
|
case TextAlignment::CenterLeft:
|
|
rect = { { align_at.x(), align_at.y() - rect_size.height() / 2 }, rect_size };
|
|
break;
|
|
case TextAlignment::Center:
|
|
rect = { { align_at.x() - rect_size.width() / 2, align_at.y() - rect_size.height() / 2 }, rect_size };
|
|
break;
|
|
case TextAlignment::CenterRight:
|
|
rect = { { align_at.x() - rect_size.width() / 2, align_at.y() }, rect_size };
|
|
break;
|
|
case TextAlignment::BottomCenter:
|
|
rect = { { align_at.x() - rect_size.width() / 2, align_at.y() - rect_size.width() }, rect_size };
|
|
break;
|
|
case TextAlignment::BottomLeft:
|
|
rect = { { align_at.x(), align_at.y() - rect_size.width() }, rect_size };
|
|
break;
|
|
case TextAlignment::BottomRight:
|
|
rect = { { align_at.x() - rect_size.width(), align_at.y() - rect_size.width() }, rect_size };
|
|
break;
|
|
}
|
|
return rect.constrained_to(*this);
|
|
}
|
|
|
|
template<typename T>
|
|
Point<T> Rect<T>::closest_to(Point<T> const& point) const
|
|
{
|
|
if (is_empty())
|
|
return {};
|
|
Optional<Point<T>> closest_point;
|
|
float closest_distance = 0.0;
|
|
auto check_distance = [&](Line<T> const& line) {
|
|
auto point_on_line = line.closest_to(point);
|
|
auto distance = Line { point_on_line, point }.length();
|
|
if (!closest_point.has_value() || distance < closest_distance) {
|
|
closest_point = point_on_line;
|
|
closest_distance = distance;
|
|
}
|
|
};
|
|
|
|
check_distance({ top_left(), top_right() });
|
|
check_distance({ bottom_left(), bottom_right() });
|
|
if (height() > 2) {
|
|
check_distance({ { x(), y() + 1 }, { x(), bottom() - 1 } });
|
|
check_distance({ { right(), y() + 1 }, { right(), bottom() - 1 } });
|
|
}
|
|
VERIFY(closest_point.has_value());
|
|
VERIFY(side(closest_point.value()) != Side::None);
|
|
return closest_point.value();
|
|
}
|
|
|
|
template<typename T>
|
|
void Rect<T>::intersect(Rect<T> const& other)
|
|
{
|
|
T l = max(left(), other.left());
|
|
T r = min(right(), other.right());
|
|
T t = max(top(), other.top());
|
|
T b = min(bottom(), other.bottom());
|
|
|
|
if (l > r || t > b) {
|
|
m_location = {};
|
|
m_size = {};
|
|
return;
|
|
}
|
|
|
|
m_location.set_x(l);
|
|
m_location.set_y(t);
|
|
m_size.set_width((r - l) + 1);
|
|
m_size.set_height((b - t) + 1);
|
|
}
|
|
|
|
template<typename T>
|
|
Rect<T> Rect<T>::united(Rect<T> const& other) const
|
|
{
|
|
if (is_null())
|
|
return other;
|
|
if (other.is_null())
|
|
return *this;
|
|
Rect<T> rect;
|
|
rect.set_left(min(left(), other.left()));
|
|
rect.set_top(min(top(), other.top()));
|
|
rect.set_right(max(right(), other.right()));
|
|
rect.set_bottom(max(bottom(), other.bottom()));
|
|
return rect;
|
|
}
|
|
|
|
template<typename T>
|
|
Vector<Rect<T>, 4> Rect<T>::shatter(Rect<T> const& hammer) const
|
|
{
|
|
Vector<Rect<T>, 4> pieces;
|
|
if (!intersects(hammer)) {
|
|
pieces.unchecked_append(*this);
|
|
return pieces;
|
|
}
|
|
Rect<T> top_shard {
|
|
x(),
|
|
y(),
|
|
width(),
|
|
hammer.y() - y()
|
|
};
|
|
Rect<T> bottom_shard {
|
|
x(),
|
|
hammer.y() + hammer.height(),
|
|
width(),
|
|
(y() + height()) - (hammer.y() + hammer.height())
|
|
};
|
|
Rect<T> left_shard {
|
|
x(),
|
|
max(hammer.y(), y()),
|
|
hammer.x() - x(),
|
|
min((hammer.y() + hammer.height()), (y() + height())) - max(hammer.y(), y())
|
|
};
|
|
Rect<T> right_shard {
|
|
hammer.x() + hammer.width(),
|
|
max(hammer.y(), y()),
|
|
right() - hammer.right(),
|
|
min((hammer.y() + hammer.height()), (y() + height())) - max(hammer.y(), y())
|
|
};
|
|
if (!top_shard.is_empty())
|
|
pieces.unchecked_append(top_shard);
|
|
if (!bottom_shard.is_empty())
|
|
pieces.unchecked_append(bottom_shard);
|
|
if (!left_shard.is_empty())
|
|
pieces.unchecked_append(left_shard);
|
|
if (!right_shard.is_empty())
|
|
pieces.unchecked_append(right_shard);
|
|
|
|
return pieces;
|
|
}
|
|
|
|
template<typename T>
|
|
void Rect<T>::align_within(Rect<T> const& other, TextAlignment alignment)
|
|
{
|
|
switch (alignment) {
|
|
case TextAlignment::Center:
|
|
center_within(other);
|
|
return;
|
|
case TextAlignment::TopCenter:
|
|
set_x(other.x() + other.width() / 2);
|
|
return;
|
|
case TextAlignment::TopLeft:
|
|
set_location(other.location());
|
|
return;
|
|
case TextAlignment::TopRight:
|
|
set_x(other.x() + other.width() - width());
|
|
set_y(other.y());
|
|
return;
|
|
case TextAlignment::CenterLeft:
|
|
set_x(other.x());
|
|
center_vertically_within(other);
|
|
return;
|
|
case TextAlignment::CenterRight:
|
|
set_x(other.x() + other.width() - width());
|
|
center_vertically_within(other);
|
|
return;
|
|
case TextAlignment::BottomCenter:
|
|
set_x(other.x() + other.width() / 2);
|
|
set_y(other.y() + other.height() - height());
|
|
return;
|
|
case TextAlignment::BottomLeft:
|
|
set_x(other.x());
|
|
set_y(other.y() + other.height() - height());
|
|
return;
|
|
case TextAlignment::BottomRight:
|
|
set_x(other.x() + other.width() - width());
|
|
set_y(other.y() + other.height() - height());
|
|
return;
|
|
}
|
|
}
|
|
|
|
template<typename T>
|
|
void Rect<T>::set_size_around(Size<T> const& new_size, Point<T> const& fixed_point)
|
|
{
|
|
const T new_x = fixed_point.x() - (T)(new_size.width() * ((float)(fixed_point.x() - x()) / width()));
|
|
const T new_y = fixed_point.y() - (T)(new_size.height() * ((float)(fixed_point.y() - y()) / height()));
|
|
|
|
set_location({ new_x, new_y });
|
|
set_size(new_size);
|
|
}
|
|
|
|
template<>
|
|
String IntRect::to_string() const
|
|
{
|
|
return String::formatted("[{},{} {}x{}]", x(), y(), width(), height());
|
|
}
|
|
|
|
template<>
|
|
String FloatRect::to_string() const
|
|
{
|
|
return String::formatted("[{},{} {}x{}]", x(), y(), width(), height());
|
|
}
|
|
|
|
}
|
|
|
|
namespace IPC {
|
|
|
|
bool encode(Encoder& encoder, Gfx::IntRect const& rect)
|
|
{
|
|
encoder << rect.location() << rect.size();
|
|
return true;
|
|
}
|
|
|
|
ErrorOr<void> decode(Decoder& decoder, Gfx::IntRect& rect)
|
|
{
|
|
Gfx::IntPoint point;
|
|
Gfx::IntSize size;
|
|
TRY(decoder.decode(point));
|
|
TRY(decoder.decode(size));
|
|
rect = { point, size };
|
|
return {};
|
|
}
|
|
|
|
}
|
|
|
|
template class Gfx::Rect<int>;
|
|
template class Gfx::Rect<float>;
|