From 6cc48b5c62bac287b8f9f1c79c1fb7486c51b18f Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Fri, 3 Mar 2023 04:57:55 +0100
Subject: Move `Canvas` and `QRCode` to `iced` crate
Rename `canvas` modules to `geometry` in graphics subcrates
---
graphics/src/geometry/fill.rs | 63 +++++++++++
graphics/src/geometry/path.rs | 67 ++++++++++++
graphics/src/geometry/path/arc.rs | 42 ++++++++
graphics/src/geometry/path/builder.rs | 192 ++++++++++++++++++++++++++++++++++
graphics/src/geometry/stroke.rs | 106 +++++++++++++++++++
graphics/src/geometry/style.rs | 23 ++++
graphics/src/geometry/text.rs | 57 ++++++++++
7 files changed, 550 insertions(+)
create mode 100644 graphics/src/geometry/fill.rs
create mode 100644 graphics/src/geometry/path.rs
create mode 100644 graphics/src/geometry/path/arc.rs
create mode 100644 graphics/src/geometry/path/builder.rs
create mode 100644 graphics/src/geometry/stroke.rs
create mode 100644 graphics/src/geometry/style.rs
create mode 100644 graphics/src/geometry/text.rs
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/fill.rs b/graphics/src/geometry/fill.rs
new file mode 100644
index 00000000..109d5e99
--- /dev/null
+++ b/graphics/src/geometry/fill.rs
@@ -0,0 +1,63 @@
+//! Fill [crate::widget::canvas::Geometry] with a certain style.
+use crate::{Color, Gradient};
+
+pub use crate::geometry::Style;
+
+/// The style used to fill geometry.
+#[derive(Debug, Clone)]
+pub struct Fill {
+ /// The color or gradient of the fill.
+ ///
+ /// By default, it is set to [`Style::Solid`] with [`Color::BLACK`].
+ pub style: Style,
+
+ /// The fill rule defines how to determine what is inside and what is
+ /// outside of a shape.
+ ///
+ /// See the [SVG specification][1] for more details.
+ ///
+ /// By default, it is set to `NonZero`.
+ ///
+ /// [1]: https://www.w3.org/TR/SVG/painting.html#FillRuleProperty
+ pub rule: Rule,
+}
+
+impl Default for Fill {
+ fn default() -> Self {
+ Self {
+ style: Style::Solid(Color::BLACK),
+ rule: Rule::NonZero,
+ }
+ }
+}
+
+impl From<Color> for Fill {
+ fn from(color: Color) -> Fill {
+ Fill {
+ style: Style::Solid(color),
+ ..Fill::default()
+ }
+ }
+}
+
+impl From<Gradient> for Fill {
+ fn from(gradient: Gradient) -> Self {
+ Fill {
+ style: Style::Gradient(gradient),
+ ..Default::default()
+ }
+ }
+}
+
+/// The fill rule defines how to determine what is inside and what is outside of
+/// a shape.
+///
+/// See the [SVG specification][1].
+///
+/// [1]: https://www.w3.org/TR/SVG/painting.html#FillRuleProperty
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+#[allow(missing_docs)]
+pub enum Rule {
+ NonZero,
+ EvenOdd,
+}
diff --git a/graphics/src/geometry/path.rs b/graphics/src/geometry/path.rs
new file mode 100644
index 00000000..30c387c5
--- /dev/null
+++ b/graphics/src/geometry/path.rs
@@ -0,0 +1,67 @@
+//! Build different kinds of 2D shapes.
+pub mod arc;
+
+mod builder;
+
+#[doc(no_inline)]
+pub use arc::Arc;
+pub use builder::Builder;
+
+pub use lyon_path;
+
+use crate::{Point, Size};
+
+/// An immutable set of points that may or may not be connected.
+///
+/// A single [`Path`] can represent different kinds of 2D shapes!
+#[derive(Debug, Clone)]
+pub struct Path {
+ raw: lyon_path::Path,
+}
+
+impl Path {
+ /// Creates a new [`Path`] with the provided closure.
+ ///
+ /// Use the [`Builder`] to configure your [`Path`].
+ pub fn new(f: impl FnOnce(&mut Builder)) -> Self {
+ let mut builder = Builder::new();
+
+ // TODO: Make it pure instead of side-effect-based (?)
+ f(&mut builder);
+
+ builder.build()
+ }
+
+ /// Creates a new [`Path`] representing a line segment given its starting
+ /// and end points.
+ pub fn line(from: Point, to: Point) -> Self {
+ Self::new(|p| {
+ p.move_to(from);
+ p.line_to(to);
+ })
+ }
+
+ /// Creates a new [`Path`] representing a rectangle given its top-left
+ /// corner coordinate and its `Size`.
+ pub fn rectangle(top_left: Point, size: Size) -> Self {
+ Self::new(|p| p.rectangle(top_left, size))
+ }
+
+ /// Creates a new [`Path`] representing a circle given its center
+ /// coordinate and its radius.
+ pub fn circle(center: Point, radius: f32) -> Self {
+ Self::new(|p| p.circle(center, radius))
+ }
+
+ #[inline]
+ pub fn raw(&self) -> &lyon_path::Path {
+ &self.raw
+ }
+
+ #[inline]
+ pub fn transform(&self, transform: &lyon_path::math::Transform) -> Path {
+ Path {
+ raw: self.raw.clone().transformed(transform),
+ }
+ }
+}
diff --git a/graphics/src/geometry/path/arc.rs b/graphics/src/geometry/path/arc.rs
new file mode 100644
index 00000000..e0747d3e
--- /dev/null
+++ b/graphics/src/geometry/path/arc.rs
@@ -0,0 +1,42 @@
+//! Build and draw curves.
+use crate::{Point, Vector};
+
+/// A segment of a differentiable curve.
+#[derive(Debug, Clone, Copy)]
+pub struct Arc {
+ /// The center of the arc.
+ pub center: Point,
+ /// The radius of the arc.
+ pub radius: f32,
+ /// The start of the segment's angle, clockwise rotation.
+ pub start_angle: f32,
+ /// The end of the segment's angle, clockwise rotation.
+ pub end_angle: f32,
+}
+
+/// An elliptical [`Arc`].
+#[derive(Debug, Clone, Copy)]
+pub struct Elliptical {
+ /// The center of the arc.
+ pub center: Point,
+ /// The radii of the arc's ellipse, defining its axes.
+ pub radii: Vector,
+ /// The rotation of the arc's ellipse.
+ pub rotation: f32,
+ /// The start of the segment's angle, clockwise rotation.
+ pub start_angle: f32,
+ /// The end of the segment's angle, clockwise rotation.
+ pub end_angle: f32,
+}
+
+impl From<Arc> for Elliptical {
+ fn from(arc: Arc) -> Elliptical {
+ Elliptical {
+ center: arc.center,
+ radii: Vector::new(arc.radius, arc.radius),
+ rotation: 0.0,
+ start_angle: arc.start_angle,
+ end_angle: arc.end_angle,
+ }
+ }
+}
diff --git a/graphics/src/geometry/path/builder.rs b/graphics/src/geometry/path/builder.rs
new file mode 100644
index 00000000..4a9c5e36
--- /dev/null
+++ b/graphics/src/geometry/path/builder.rs
@@ -0,0 +1,192 @@
+use crate::geometry::path::{arc, Arc, Path};
+use crate::{Point, Size};
+
+use lyon_path::builder::{self, SvgPathBuilder};
+use lyon_path::geom;
+use lyon_path::math;
+
+/// A [`Path`] builder.
+///
+/// Once a [`Path`] is built, it can no longer be mutated.
+#[allow(missing_debug_implementations)]
+pub struct Builder {
+ raw: builder::WithSvg<lyon_path::path::BuilderImpl>,
+}
+
+impl Builder {
+ /// Creates a new [`Builder`].
+ pub fn new() -> Builder {
+ Builder {
+ raw: lyon_path::Path::builder().with_svg(),
+ }
+ }
+
+ /// Moves the starting point of a new sub-path to the given `Point`.
+ #[inline]
+ pub fn move_to(&mut self, point: Point) {
+ let _ = self.raw.move_to(math::Point::new(point.x, point.y));
+ }
+
+ /// Connects the last point in the [`Path`] to the given `Point` with a
+ /// straight line.
+ #[inline]
+ pub fn line_to(&mut self, point: Point) {
+ let _ = self.raw.line_to(math::Point::new(point.x, point.y));
+ }
+
+ /// Adds an [`Arc`] to the [`Path`] from `start_angle` to `end_angle` in
+ /// a clockwise direction.
+ #[inline]
+ pub fn arc(&mut self, arc: Arc) {
+ self.ellipse(arc.into());
+ }
+
+ /// Adds a circular arc to the [`Path`] with the given control points and
+ /// radius.
+ ///
+ /// This essentially draws a straight line segment from the current
+ /// position to `a`, but fits a circular arc of `radius` tangent to that
+ /// segment and tangent to the line between `a` and `b`.
+ ///
+ /// With another `.line_to(b)`, the result will be a path connecting the
+ /// starting point and `b` with straight line segments towards `a` and a
+ /// circular arc smoothing out the corner at `a`.
+ ///
+ /// See [the HTML5 specification of `arcTo`](https://html.spec.whatwg.org/multipage/canvas.html#building-paths:dom-context-2d-arcto)
+ /// for more details and examples.
+ pub fn arc_to(&mut self, a: Point, b: Point, radius: f32) {
+ let start = self.raw.current_position();
+ let mid = math::Point::new(a.x, a.y);
+ let end = math::Point::new(b.x, b.y);
+
+ if start == mid || mid == end || radius == 0.0 {
+ let _ = self.raw.line_to(mid);
+ return;
+ }
+
+ let double_area = start.x * (mid.y - end.y)
+ + mid.x * (end.y - start.y)
+ + end.x * (start.y - mid.y);
+
+ if double_area == 0.0 {
+ let _ = self.raw.line_to(mid);
+ return;
+ }
+
+ let to_start = (start - mid).normalize();
+ let to_end = (end - mid).normalize();
+
+ let inner_angle = to_start.dot(to_end).acos();
+
+ let origin_angle = inner_angle / 2.0;
+
+ let origin_adjacent = radius / origin_angle.tan();
+
+ let arc_start = mid + to_start * origin_adjacent;
+ let arc_end = mid + to_end * origin_adjacent;
+
+ let sweep = to_start.cross(to_end) < 0.0;
+
+ let _ = self.raw.line_to(arc_start);
+
+ self.raw.arc_to(
+ math::Vector::new(radius, radius),
+ math::Angle::radians(0.0),
+ lyon_path::ArcFlags {
+ large_arc: false,
+ sweep,
+ },
+ arc_end,
+ );
+ }
+
+ /// Adds an ellipse to the [`Path`] using a clockwise direction.
+ pub fn ellipse(&mut self, arc: arc::Elliptical) {
+ let arc = geom::Arc {
+ center: math::Point::new(arc.center.x, arc.center.y),
+ radii: math::Vector::new(arc.radii.x, arc.radii.y),
+ x_rotation: math::Angle::radians(arc.rotation),
+ start_angle: math::Angle::radians(arc.start_angle),
+ sweep_angle: math::Angle::radians(arc.end_angle - arc.start_angle),
+ };
+
+ let _ = self.raw.move_to(arc.sample(0.0));
+
+ arc.for_each_quadratic_bezier(&mut |curve| {
+ let _ = self.raw.quadratic_bezier_to(curve.ctrl, curve.to);
+ });
+ }
+
+ /// Adds a cubic Bézier curve to the [`Path`] given its two control points
+ /// and its end point.
+ #[inline]
+ pub fn bezier_curve_to(
+ &mut self,
+ control_a: Point,
+ control_b: Point,
+ to: Point,
+ ) {
+ let _ = self.raw.cubic_bezier_to(
+ math::Point::new(control_a.x, control_a.y),
+ math::Point::new(control_b.x, control_b.y),
+ math::Point::new(to.x, to.y),
+ );
+ }
+
+ /// Adds a quadratic Bézier curve to the [`Path`] given its control point
+ /// and its end point.
+ #[inline]
+ pub fn quadratic_curve_to(&mut self, control: Point, to: Point) {
+ let _ = self.raw.quadratic_bezier_to(
+ math::Point::new(control.x, control.y),
+ math::Point::new(to.x, to.y),
+ );
+ }
+
+ /// Adds a rectangle to the [`Path`] given its top-left corner coordinate
+ /// and its `Size`.
+ #[inline]
+ pub fn rectangle(&mut self, top_left: Point, size: Size) {
+ self.move_to(top_left);
+ self.line_to(Point::new(top_left.x + size.width, top_left.y));
+ self.line_to(Point::new(
+ top_left.x + size.width,
+ top_left.y + size.height,
+ ));
+ self.line_to(Point::new(top_left.x, top_left.y + size.height));
+ self.close();
+ }
+
+ /// Adds a circle to the [`Path`] given its center coordinate and its
+ /// radius.
+ #[inline]
+ pub fn circle(&mut self, center: Point, radius: f32) {
+ self.arc(Arc {
+ center,
+ radius,
+ start_angle: 0.0,
+ end_angle: 2.0 * std::f32::consts::PI,
+ });
+ }
+
+ /// Closes the current sub-path in the [`Path`] with a straight line to
+ /// the starting point.
+ #[inline]
+ pub fn close(&mut self) {
+ self.raw.close()
+ }
+
+ /// Builds the [`Path`] of this [`Builder`].
+ #[inline]
+ pub fn build(self) -> Path {
+ Path {
+ raw: self.raw.build(),
+ }
+ }
+}
+
+impl Default for Builder {
+ fn default() -> Self {
+ Self::new()
+ }
+}
diff --git a/graphics/src/geometry/stroke.rs b/graphics/src/geometry/stroke.rs
new file mode 100644
index 00000000..b551a9c9
--- /dev/null
+++ b/graphics/src/geometry/stroke.rs
@@ -0,0 +1,106 @@
+//! Create lines from a [crate::widget::canvas::Path] and assigns them various attributes/styles.
+pub use crate::geometry::Style;
+
+use crate::Color;
+
+/// The style of a stroke.
+#[derive(Debug, Clone)]
+pub struct Stroke<'a> {
+ /// The color or gradient of the stroke.
+ ///
+ /// By default, it is set to a [`Style::Solid`] with [`Color::BLACK`].
+ pub style: Style,
+ /// The distance between the two edges of the stroke.
+ pub width: f32,
+ /// The shape to be used at the end of open subpaths when they are stroked.
+ pub line_cap: LineCap,
+ /// The shape to be used at the corners of paths or basic shapes when they
+ /// are stroked.
+ pub line_join: LineJoin,
+ /// The dash pattern used when stroking the line.
+ pub line_dash: LineDash<'a>,
+}
+
+impl<'a> Stroke<'a> {
+ /// Sets the color of the [`Stroke`].
+ pub fn with_color(self, color: Color) -> Self {
+ Stroke {
+ style: Style::Solid(color),
+ ..self
+ }
+ }
+
+ /// Sets the width of the [`Stroke`].
+ pub fn with_width(self, width: f32) -> Self {
+ Stroke { width, ..self }
+ }
+
+ /// Sets the [`LineCap`] of the [`Stroke`].
+ pub fn with_line_cap(self, line_cap: LineCap) -> Self {
+ Stroke { line_cap, ..self }
+ }
+
+ /// Sets the [`LineJoin`] of the [`Stroke`].
+ pub fn with_line_join(self, line_join: LineJoin) -> Self {
+ Stroke { line_join, ..self }
+ }
+}
+
+impl<'a> Default for Stroke<'a> {
+ fn default() -> Self {
+ Stroke {
+ style: Style::Solid(Color::BLACK),
+ width: 1.0,
+ line_cap: LineCap::default(),
+ line_join: LineJoin::default(),
+ line_dash: LineDash::default(),
+ }
+ }
+}
+
+/// The shape used at the end of open subpaths when they are stroked.
+#[derive(Debug, Clone, Copy)]
+pub enum LineCap {
+ /// The stroke for each sub-path does not extend beyond its two endpoints.
+ Butt,
+ /// At the end of each sub-path, the shape representing the stroke will be
+ /// extended by a square.
+ Square,
+ /// At the end of each sub-path, the shape representing the stroke will be
+ /// extended by a semicircle.
+ Round,
+}
+
+impl Default for LineCap {
+ fn default() -> LineCap {
+ LineCap::Butt
+ }
+}
+
+/// The shape used at the corners of paths or basic shapes when they are
+/// stroked.
+#[derive(Debug, Clone, Copy)]
+pub enum LineJoin {
+ /// A sharp corner.
+ Miter,
+ /// A round corner.
+ Round,
+ /// A bevelled corner.
+ Bevel,
+}
+
+impl Default for LineJoin {
+ fn default() -> LineJoin {
+ LineJoin::Miter
+ }
+}
+
+/// The dash pattern used when stroking the line.
+#[derive(Debug, Clone, Copy, Default)]
+pub struct LineDash<'a> {
+ /// The alternating lengths of lines and gaps which describe the pattern.
+ pub segments: &'a [f32],
+
+ /// The offset of [`LineDash::segments`] to start the pattern.
+ pub offset: usize,
+}
diff --git a/graphics/src/geometry/style.rs b/graphics/src/geometry/style.rs
new file mode 100644
index 00000000..6794f2e7
--- /dev/null
+++ b/graphics/src/geometry/style.rs
@@ -0,0 +1,23 @@
+use crate::{Color, Gradient};
+
+/// The coloring style of some drawing.
+#[derive(Debug, Clone, PartialEq)]
+pub enum Style {
+ /// A solid [`Color`].
+ Solid(Color),
+
+ /// A [`Gradient`] color.
+ Gradient(Gradient),
+}
+
+impl From<Color> for Style {
+ fn from(color: Color) -> Self {
+ Self::Solid(color)
+ }
+}
+
+impl From<Gradient> for Style {
+ fn from(gradient: Gradient) -> Self {
+ Self::Gradient(gradient)
+ }
+}
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
new file mode 100644
index 00000000..8c0b2dfb
--- /dev/null
+++ b/graphics/src/geometry/text.rs
@@ -0,0 +1,57 @@
+use crate::alignment;
+use crate::{Color, Font, Point};
+
+/// A bunch of text that can be drawn to a canvas
+#[derive(Debug, Clone)]
+pub struct Text {
+ /// The contents of the text
+ pub content: String,
+ /// The position of the text relative to the alignment properties.
+ /// By default, this position will be relative to the top-left corner coordinate meaning that
+ /// if the horizontal and vertical alignments are unchanged, this property will tell where the
+ /// top-left corner of the text should be placed.
+ /// By changing the horizontal_alignment and vertical_alignment properties, you are are able to
+ /// change what part of text is placed at this positions.
+ /// For example, when the horizontal_alignment and vertical_alignment are set to Center, the
+ /// center of the text will be placed at the given position NOT the top-left coordinate.
+ pub position: Point,
+ /// The color of the text
+ pub color: Color,
+ /// The size of the text
+ pub size: f32,
+ /// The font of the text
+ pub font: Font,
+ /// The horizontal alignment of the text
+ pub horizontal_alignment: alignment::Horizontal,
+ /// The vertical alignment of the text
+ pub vertical_alignment: alignment::Vertical,
+}
+
+impl Default for Text {
+ fn default() -> Text {
+ Text {
+ content: String::new(),
+ position: Point::ORIGIN,
+ color: Color::BLACK,
+ size: 16.0,
+ font: Font::SansSerif,
+ horizontal_alignment: alignment::Horizontal::Left,
+ vertical_alignment: alignment::Vertical::Top,
+ }
+ }
+}
+
+impl From<String> for Text {
+ fn from(content: String) -> Text {
+ Text {
+ content,
+ ..Default::default()
+ }
+ }
+}
+
+impl From<&str> for Text {
+ fn from(content: &str) -> Text {
+ String::from(content).into()
+ }
+}
--
cgit
From 3a0d34c0240f4421737a6a08761f99d6f8140d02 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Sat, 4 Mar 2023 05:37:11 +0100
Subject: Create `iced_widget` subcrate and re-organize the whole codebase
---
graphics/src/geometry/fill.rs | 2 +-
graphics/src/geometry/path.rs | 2 +-
graphics/src/geometry/path/arc.rs | 2 +-
graphics/src/geometry/path/builder.rs | 3 ++-
graphics/src/geometry/stroke.rs | 2 +-
graphics/src/geometry/style.rs | 2 +-
graphics/src/geometry/text.rs | 4 ++--
7 files changed, 9 insertions(+), 8 deletions(-)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/fill.rs b/graphics/src/geometry/fill.rs
index 109d5e99..2e8c1669 100644
--- a/graphics/src/geometry/fill.rs
+++ b/graphics/src/geometry/fill.rs
@@ -1,5 +1,5 @@
//! Fill [crate::widget::canvas::Geometry] with a certain style.
-use crate::{Color, Gradient};
+use iced_core::{Color, Gradient};
pub use crate::geometry::Style;
diff --git a/graphics/src/geometry/path.rs b/graphics/src/geometry/path.rs
index 30c387c5..c3127bdf 100644
--- a/graphics/src/geometry/path.rs
+++ b/graphics/src/geometry/path.rs
@@ -9,7 +9,7 @@ pub use builder::Builder;
pub use lyon_path;
-use crate::{Point, Size};
+use iced_core::{Point, Size};
/// An immutable set of points that may or may not be connected.
///
diff --git a/graphics/src/geometry/path/arc.rs b/graphics/src/geometry/path/arc.rs
index e0747d3e..2cdebb66 100644
--- a/graphics/src/geometry/path/arc.rs
+++ b/graphics/src/geometry/path/arc.rs
@@ -1,5 +1,5 @@
//! Build and draw curves.
-use crate::{Point, Vector};
+use iced_core::{Point, Vector};
/// A segment of a differentiable curve.
#[derive(Debug, Clone, Copy)]
diff --git a/graphics/src/geometry/path/builder.rs b/graphics/src/geometry/path/builder.rs
index 4a9c5e36..794dd3bc 100644
--- a/graphics/src/geometry/path/builder.rs
+++ b/graphics/src/geometry/path/builder.rs
@@ -1,5 +1,6 @@
use crate::geometry::path::{arc, Arc, Path};
-use crate::{Point, Size};
+
+use iced_core::{Point, Size};
use lyon_path::builder::{self, SvgPathBuilder};
use lyon_path::geom;
diff --git a/graphics/src/geometry/stroke.rs b/graphics/src/geometry/stroke.rs
index b551a9c9..2d760a6c 100644
--- a/graphics/src/geometry/stroke.rs
+++ b/graphics/src/geometry/stroke.rs
@@ -1,7 +1,7 @@
//! Create lines from a [crate::widget::canvas::Path] and assigns them various attributes/styles.
pub use crate::geometry::Style;
-use crate::Color;
+use iced_core::Color;
/// The style of a stroke.
#[derive(Debug, Clone)]
diff --git a/graphics/src/geometry/style.rs b/graphics/src/geometry/style.rs
index 6794f2e7..be9ee376 100644
--- a/graphics/src/geometry/style.rs
+++ b/graphics/src/geometry/style.rs
@@ -1,4 +1,4 @@
-use crate::{Color, Gradient};
+use iced_core::{Color, Gradient};
/// The coloring style of some drawing.
#[derive(Debug, Clone, PartialEq)]
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index 8c0b2dfb..06e0b4d0 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -1,5 +1,5 @@
-use crate::alignment;
-use crate::{Color, Font, Point};
+use iced_core::alignment;
+use iced_core::{Color, Font, Point};
/// A bunch of text that can be drawn to a canvas
#[derive(Debug, Clone)]
--
cgit
From 707de9d788dc3c49d4ac57a19afac1bb938b78d9 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Thu, 30 Mar 2023 00:56:00 +0200
Subject: Introduce support for `Font` attributes
---
graphics/src/geometry/text.rs | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index 06e0b4d0..0befd635 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -34,7 +34,7 @@ impl Default for Text {
position: Point::ORIGIN,
color: Color::BLACK,
size: 16.0,
- font: Font::SansSerif,
+ font: Font::default(),
horizontal_alignment: alignment::Horizontal::Left,
vertical_alignment: alignment::Vertical::Top,
}
--
cgit
From 33b5a900197e2798a393d6d9a0834039666eddbb Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Wed, 19 Apr 2023 01:19:56 +0200
Subject: Make basic text shaping the default shaping strategy
---
graphics/src/geometry/text.rs | 10 ++++++++++
1 file changed, 10 insertions(+)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index 0befd635..f4af9ee4 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -25,6 +25,15 @@ pub struct Text {
pub horizontal_alignment: alignment::Horizontal,
/// The vertical alignment of the text
pub vertical_alignment: alignment::Vertical,
+ /// Whether the text needs advanced shaping and font fallback.
+ ///
+ /// You will need to enable this flag if the text contains a complex
+ /// script, the font used needs it, and/or multiple fonts in your system
+ /// may be needed to display all of the glyphs.
+ ///
+ /// Advanced shaping is expensive! You should only enable it when
+ /// necessary.
+ pub advanced_shape: bool,
}
impl Default for Text {
@@ -37,6 +46,7 @@ impl Default for Text {
font: Font::default(),
horizontal_alignment: alignment::Horizontal::Left,
vertical_alignment: alignment::Vertical::Top,
+ advanced_shape: false,
}
}
}
--
cgit
From 4bd290afe7d81d9aaf7467b3ce91491f6600261a Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Wed, 19 Apr 2023 02:00:45 +0200
Subject: Introduce `text::Shaping` enum and replace magic boolean
---
graphics/src/geometry/text.rs | 18 ++++++------------
1 file changed, 6 insertions(+), 12 deletions(-)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index f4af9ee4..0f731e74 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -1,5 +1,6 @@
-use iced_core::alignment;
-use iced_core::{Color, Font, Point};
+use crate::core::alignment;
+use crate::core::text::Shaping;
+use crate::core::{Color, Font, Point};
/// A bunch of text that can be drawn to a canvas
#[derive(Debug, Clone)]
@@ -25,15 +26,8 @@ pub struct Text {
pub horizontal_alignment: alignment::Horizontal,
/// The vertical alignment of the text
pub vertical_alignment: alignment::Vertical,
- /// Whether the text needs advanced shaping and font fallback.
- ///
- /// You will need to enable this flag if the text contains a complex
- /// script, the font used needs it, and/or multiple fonts in your system
- /// may be needed to display all of the glyphs.
- ///
- /// Advanced shaping is expensive! You should only enable it when
- /// necessary.
- pub advanced_shape: bool,
+ /// The shaping strategy of the text.
+ pub shaping: Shaping,
}
impl Default for Text {
@@ -46,7 +40,7 @@ impl Default for Text {
font: Font::default(),
horizontal_alignment: alignment::Horizontal::Left,
vertical_alignment: alignment::Vertical::Top,
- advanced_shape: false,
+ shaping: Shaping::Basic,
}
}
}
--
cgit
From 9499a8f9e6f9971dedfae563cb133232aa3cebc2 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Thu, 4 May 2023 13:00:16 +0200
Subject: Support configurable `LineHeight` in text widgets
---
graphics/src/geometry/text.rs | 5 ++++-
1 file changed, 4 insertions(+), 1 deletion(-)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/text.rs b/graphics/src/geometry/text.rs
index 0f731e74..c584f3cd 100644
--- a/graphics/src/geometry/text.rs
+++ b/graphics/src/geometry/text.rs
@@ -1,5 +1,5 @@
use crate::core::alignment;
-use crate::core::text::Shaping;
+use crate::core::text::{LineHeight, Shaping};
use crate::core::{Color, Font, Point};
/// A bunch of text that can be drawn to a canvas
@@ -20,6 +20,8 @@ pub struct Text {
pub color: Color,
/// The size of the text
pub size: f32,
+ /// The line height of the text.
+ pub line_height: LineHeight,
/// The font of the text
pub font: Font,
/// The horizontal alignment of the text
@@ -37,6 +39,7 @@ impl Default for Text {
position: Point::ORIGIN,
color: Color::BLACK,
size: 16.0,
+ line_height: LineHeight::Relative(1.2),
font: Font::default(),
horizontal_alignment: alignment::Horizontal::Left,
vertical_alignment: alignment::Vertical::Top,
--
cgit
From 8622e998f2701e7f4ca8d2f71c85150f436a9945 Mon Sep 17 00:00:00 2001
From: Héctor Ramón Jiménez <hector0193@gmail.com>
Date: Thu, 11 May 2023 15:25:58 +0200
Subject: Write missing documentation in `iced_graphics`
---
graphics/src/geometry/path.rs | 2 ++
1 file changed, 2 insertions(+)
(limited to 'graphics/src/geometry')
diff --git a/graphics/src/geometry/path.rs b/graphics/src/geometry/path.rs
index c3127bdf..3d8fc6fa 100644
--- a/graphics/src/geometry/path.rs
+++ b/graphics/src/geometry/path.rs
@@ -53,11 +53,13 @@ impl Path {
Self::new(|p| p.circle(center, radius))
}
+ /// Returns the internal [`lyon_path::Path`].
#[inline]
pub fn raw(&self) -> &lyon_path::Path {
&self.raw
}
+ /// Returns the current [`Path`] with the given transform applied to it.
#[inline]
pub fn transform(&self, transform: &lyon_path::math::Transform) -> Path {
Path {
--
cgit