Merge pull request #632 from hecrj/improvement/update-docs

Use intra-doc links

16 files changed, 11 insertions, 143 deletions

diff --git a/graphics/src/widget/button.rs b/graphics/src/widget/button.rs
index 87581175..2e3f78ca 100644
--- a/graphics/src/widget/button.rs
+++ b/graphics/src/widget/button.rs
@@ -1,9 +1,6 @@
 //! Allow your users to perform actions by pressing a button.
 //!
 //! A [`Button`] has some local [`State`].
-//!
-//! [`Button`]: type.Button.html
-//! [`State`]: struct.State.html
 use crate::defaults::{self, Defaults};
 use crate::{Backend, Primitive, Renderer};
 use iced_native::mouse;
diff --git a/graphics/src/widget/canvas.rs b/graphics/src/widget/canvas.rs
index ae0d87a4..95ede50f 100644
--- a/graphics/src/widget/canvas.rs
+++ b/graphics/src/widget/canvas.rs
@@ -3,9 +3,6 @@
 //! A [`Canvas`] widget can be used to draw different kinds of 2D shapes in a
 //! [`Frame`]. It can be used for animation, data visualization, game graphics,
 //! and more!
-//!
-//! [`Canvas`]: struct.Canvas.html
-//! [`Frame`]: struct.Frame.html
 use crate::{Backend, Defaults, Primitive, Renderer};
 use iced_native::layout;
 use iced_native::mouse;
@@ -41,8 +38,6 @@ pub use text::Text;
 
 /// A widget capable of drawing 2D graphics.
 ///
-/// [`Canvas`]: struct.Canvas.html
-///
 /// # Examples
 /// The repository has a couple of [examples] showcasing how to use a
 /// [`Canvas`]:
@@ -108,8 +103,6 @@ impl<Message, P: Program<Message>> Canvas<Message, P> {
     const DEFAULT_SIZE: u16 = 100;
 
     /// Creates a new [`Canvas`].
-    ///
-    /// [`Canvas`]: struct.Canvas.html
     pub fn new(program: P) -> Self {
         Canvas {
             width: Length::Units(Self::DEFAULT_SIZE),
@@ -120,16 +113,12 @@ impl<Message, P: Program<Message>> Canvas<Message, P> {
     }
 
     /// Sets the width of the [`Canvas`].
-    ///
-    /// [`Canvas`]: struct.Canvas.html
     pub fn width(mut self, width: Length) -> Self {
         self.width = width;
         self
     }
 
     /// Sets the height of the [`Canvas`].
-    ///
-    /// [`Canvas`]: struct.Canvas.html
     pub fn height(mut self, height: Length) -> Self {
         self.height = height;
         self
diff --git a/graphics/src/widget/canvas/cache.rs b/graphics/src/widget/canvas/cache.rs
index 4b28d164..a469417d 100644
--- a/graphics/src/widget/canvas/cache.rs
+++ b/graphics/src/widget/canvas/cache.rs
@@ -23,10 +23,6 @@ impl Default for State {
 ///
 /// A [`Cache`] will not redraw its geometry unless the dimensions of its layer
 /// change or it is explicitly cleared.
-///
-/// [`Layer`]: ../trait.Layer.html
-/// [`Cache`]: struct.Cache.html
-/// [`Geometry`]: struct.Geometry.html
 #[derive(Debug, Default)]
 pub struct Cache {
     state: RefCell<State>,
@@ -34,8 +30,6 @@ pub struct Cache {
 
 impl Cache {
     /// Creates a new empty [`Cache`].
-    ///
-    /// [`Cache`]: struct.Cache.html
     pub fn new() -> Self {
         Cache {
             state: Default::default(),
@@ -43,8 +37,6 @@ impl Cache {
     }
 
     /// Clears the [`Cache`], forcing a redraw the next time it is used.
-    ///
-    /// [`Cache`]: struct.Cache.html
     pub fn clear(&mut self) {
         *self.state.borrow_mut() = State::Empty;
     }
@@ -59,8 +51,6 @@ impl Cache {
     /// Otherwise, the previously stored [`Geometry`] will be returned. The
     /// [`Cache`] is not cleared in this case. In other words, it will keep
     /// returning the stored [`Geometry`] if needed.
-    ///
-    /// [`Cache`]: struct.Cache.html
     pub fn draw(&self, bounds: Size, draw_fn: impl Fn(&mut Frame)) -> Geometry {
         use std::ops::Deref;
 
diff --git a/graphics/src/widget/canvas/cursor.rs b/graphics/src/widget/canvas/cursor.rs
index 456760ea..9588d129 100644
--- a/graphics/src/widget/canvas/cursor.rs
+++ b/graphics/src/widget/canvas/cursor.rs
@@ -22,8 +22,6 @@ impl Cursor {
     }
 
     /// Returns the absolute position of the [`Cursor`], if available.
-    ///
-    /// [`Cursor`]: enum.Cursor.html
     pub fn position(&self) -> Option<Point> {
         match self {
             Cursor::Available(position) => Some(*position),
@@ -36,8 +34,6 @@ impl Cursor {
     ///
     /// If the [`Cursor`] is not over the provided bounds, this method will
     /// return `None`.
-    ///
-    /// [`Cursor`]: enum.Cursor.html
     pub fn position_in(&self, bounds: &Rectangle) -> Option<Point> {
         if self.is_over(bounds) {
             self.position_from(bounds.position())
@@ -48,8 +44,6 @@ impl Cursor {
 
     /// Returns the relative position of the [`Cursor`] from the given origin,
     /// if available.
-    ///
-    /// [`Cursor`]: enum.Cursor.html
     pub fn position_from(&self, origin: Point) -> Option<Point> {
         match self {
             Cursor::Available(position) => {
@@ -61,8 +55,6 @@ impl Cursor {
 
     /// Returns whether the [`Cursor`] is currently over the provided bounds
     /// or not.
-    ///
-    /// [`Cursor`]: enum.Cursor.html
     pub fn is_over(&self, bounds: &Rectangle) -> bool {
         match self {
             Cursor::Available(position) => bounds.contains(*position),
diff --git a/graphics/src/widget/canvas/event.rs b/graphics/src/widget/canvas/event.rs
index ede2fd73..5bf6f7a6 100644
--- a/graphics/src/widget/canvas/event.rs
+++ b/graphics/src/widget/canvas/event.rs
@@ -6,7 +6,7 @@ pub use iced_native::event::Status;
 
 /// A [`Canvas`] event.
 ///
-/// [`Canvas`]: struct.Event.html
+/// [`Canvas`]: crate::widget::Canvas
 #[derive(Debug, Clone, Copy, PartialEq)]
 pub enum Event {
     /// A mouse event.
diff --git a/graphics/src/widget/canvas/frame.rs b/graphics/src/widget/canvas/frame.rs
index 21e9ec28..b86f9e04 100644
--- a/graphics/src/widget/canvas/frame.rs
+++ b/graphics/src/widget/canvas/frame.rs
@@ -7,7 +7,7 @@ use crate::{
 
 /// The frame of a [`Canvas`].
 ///
-/// [`Canvas`]: struct.Canvas.html
+/// [`Canvas`]: crate::widget::Canvas
 #[derive(Debug)]
 pub struct Frame {
     size: Size,
@@ -33,8 +33,6 @@ impl Frame {
     ///
     /// The default coordinate system of a [`Frame`] has its origin at the
     /// top-left corner of its bounds.
-    ///
-    /// [`Frame`]: struct.Frame.html
     pub fn new(size: Size) -> Frame {
         Frame {
             size,
@@ -51,32 +49,24 @@ impl Frame {
     }
 
     /// Returns the width of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn width(&self) -> f32 {
         self.size.width
     }
 
     /// Returns the width of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn height(&self) -> f32 {
         self.size.height
     }
 
     /// Returns the dimensions of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn size(&self) -> Size {
         self.size
     }
 
     /// Returns the coordinate of the center of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn center(&self) -> Point {
         Point::new(self.size.width / 2.0, self.size.height / 2.0)
@@ -84,9 +74,6 @@ impl Frame {
 
     /// Draws the given [`Path`] on the [`Frame`] by filling it with the
     /// provided style.
-    ///
-    /// [`Path`]: path/struct.Path.html
-    /// [`Frame`]: struct.Frame.html
     pub fn fill(&mut self, path: &Path, fill: impl Into<Fill>) {
         use lyon::tessellation::{
             BuffersBuilder, FillOptions, FillTessellator,
@@ -115,8 +102,6 @@ impl Frame {
 
     /// Draws an axis-aligned rectangle given its top-left corner coordinate and
     /// its `Size` on the [`Frame`] by filling it with the provided style.
-    ///
-    /// [`Frame`]: struct.Frame.html
     pub fn fill_rectangle(
         &mut self,
         top_left: Point,
@@ -152,9 +137,6 @@ impl Frame {
 
     /// Draws the stroke of the given [`Path`] on the [`Frame`] with the
     /// provided style.
-    ///
-    /// [`Path`]: path/struct.Path.html
-    /// [`Frame`]: struct.Frame.html
     pub fn stroke(&mut self, path: &Path, stroke: impl Into<Stroke>) {
         use lyon::tessellation::{
             BuffersBuilder, StrokeOptions, StrokeTessellator,
@@ -200,9 +182,7 @@ impl Frame {
     /// Support for vectorial text is planned, and should address all these
     /// limitations.
     ///
-    /// [`Text`]: struct.Text.html
-    /// [`Frame`]: struct.Frame.html
-    /// [`Canvas`]: struct.Canvas.html
+    /// [`Canvas`]: crate::widget::Canvas
     pub fn fill_text(&mut self, text: impl Into<Text>) {
         use std::f32;
 
@@ -240,8 +220,6 @@ impl Frame {
     ///
     /// This method is useful to compose transforms and perform drawing
     /// operations in different coordinate systems.
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn with_save(&mut self, f: impl FnOnce(&mut Frame)) {
         self.transforms.previous.push(self.transforms.current);
@@ -252,8 +230,6 @@ impl Frame {
     }
 
     /// Applies a translation to the current transform of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn translate(&mut self, translation: Vector) {
         self.transforms.current.raw = self
@@ -268,8 +244,6 @@ impl Frame {
     }
 
     /// Applies a rotation to the current transform of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn rotate(&mut self, angle: f32) {
         self.transforms.current.raw = self
@@ -281,8 +255,6 @@ impl Frame {
     }
 
     /// Applies a scaling to the current transform of the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
     #[inline]
     pub fn scale(&mut self, scale: f32) {
         self.transforms.current.raw =
@@ -291,9 +263,6 @@ impl Frame {
     }
 
     /// Produces the [`Geometry`] representing everything drawn on the [`Frame`].
-    ///
-    /// [`Frame`]: struct.Frame.html
-    /// [`Geometry`]: struct.Geometry.html
     pub fn into_geometry(mut self) -> Geometry {
         if !self.buffers.indices.is_empty() {
             self.primitives.push(Primitive::Mesh2D {
diff --git a/graphics/src/widget/canvas/geometry.rs b/graphics/src/widget/canvas/geometry.rs
index 4cadee39..8915cda1 100644
--- a/graphics/src/widget/canvas/geometry.rs
+++ b/graphics/src/widget/canvas/geometry.rs
@@ -5,9 +5,8 @@ use crate::Primitive;
 /// [`Geometry`] can be easily generated with a [`Frame`] or stored in a
 /// [`Cache`].
 ///
-/// [`Geometry`]: struct.Geometry.html
-/// [`Frame`]: struct.Frame.html
-/// [`Cache`]: struct.Cache.html
+/// [`Frame`]: crate::widget::canvas::Frame
+/// [`Cache`]: crate::widget::canvas::Cache
 #[derive(Debug, Clone)]
 pub struct Geometry(Primitive);
 
@@ -19,9 +18,6 @@ impl Geometry {
     /// Turns the [`Geometry`] into a [`Primitive`].
     ///
     /// This can be useful if you are building a custom widget.
-    ///
-    /// [`Geometry`]: struct.Geometry.html
-    /// [`Primitive`]: ../enum.Primitive.html
     pub fn into_primitive(self) -> Primitive {
         self.0
     }
diff --git a/graphics/src/widget/canvas/path.rs b/graphics/src/widget/canvas/path.rs
index c26bf187..6de19321 100644
--- a/graphics/src/widget/canvas/path.rs
+++ b/graphics/src/widget/canvas/path.rs
@@ -12,8 +12,6 @@ use iced_native::{Point, Size};
 /// An immutable set of points that may or may not be connected.
 ///
 /// A single [`Path`] can represent different kinds of 2D shapes!
-///
-/// [`Path`]: struct.Path.html
 #[derive(Debug, Clone)]
 pub struct Path {
     raw: lyon::path::Path,
@@ -23,9 +21,6 @@ impl Path {
     /// Creates a new [`Path`] with the provided closure.
     ///
     /// Use the [`Builder`] to configure your [`Path`].
-    ///
-    /// [`Path`]: struct.Path.html
-    /// [`Builder`]: struct.Builder.html
     pub fn new(f: impl FnOnce(&mut Builder)) -> Self {
         let mut builder = Builder::new();
 
@@ -37,8 +32,6 @@ impl Path {
 
     /// Creates a new [`Path`] representing a line segment given its starting
     /// and end points.
-    ///
-    /// [`Path`]: struct.Path.html
     pub fn line(from: Point, to: Point) -> Self {
         Self::new(|p| {
             p.move_to(from);
@@ -48,16 +41,12 @@ impl Path {
 
     /// Creates a new [`Path`] representing a rectangle given its top-left
     /// corner coordinate and its `Size`.
-    ///
-    /// [`Path`]: struct.Path.html
     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.
-    ///
-    /// [`Path`]: struct.Path.html
     pub fn circle(center: Point, radius: f32) -> Self {
         Self::new(|p| p.circle(center, radius))
     }
diff --git a/graphics/src/widget/canvas/path/arc.rs b/graphics/src/widget/canvas/path/arc.rs
index 343191f1..b8e72daf 100644
--- a/graphics/src/widget/canvas/path/arc.rs
+++ b/graphics/src/widget/canvas/path/arc.rs
@@ -15,8 +15,6 @@ pub struct Arc {
 }
 
 /// An elliptical [`Arc`].
-///
-/// [`Arc`]: struct.Arc.html
 #[derive(Debug, Clone, Copy)]
 pub struct Elliptical {
     /// The center of the arc.
diff --git a/graphics/src/widget/canvas/path/builder.rs b/graphics/src/widget/canvas/path/builder.rs
index e0e52845..5ce0e02c 100644
--- a/graphics/src/widget/canvas/path/builder.rs
+++ b/graphics/src/widget/canvas/path/builder.rs
@@ -6,8 +6,6 @@ use lyon::path::builder::{Build, FlatPathBuilder, PathBuilder, SvgBuilder};
 /// A [`Path`] builder.
 ///
 /// Once a [`Path`] is built, it can no longer be mutated.
-///
-/// [`Path`]: struct.Path.html
 #[allow(missing_debug_implementations)]
 pub struct Builder {
     raw: lyon::path::builder::SvgPathBuilder<lyon::path::Builder>,
@@ -15,8 +13,6 @@ pub struct Builder {
 
 impl Builder {
     /// Creates a new [`Builder`].
-    ///
-    /// [`Builder`]: struct.Builder.html
     pub fn new() -> Builder {
         Builder {
             raw: lyon::path::Path::builder().with_svg(),
@@ -31,8 +27,6 @@ impl Builder {
 
     /// Connects the last point in the [`Path`] to the given `Point` with a
     /// straight line.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn line_to(&mut self, point: Point) {
         let _ = self.raw.line_to(lyon::math::Point::new(point.x, point.y));
@@ -40,9 +34,6 @@ impl Builder {
 
     /// Adds an [`Arc`] to the [`Path`] from `start_angle` to `end_angle` in
     /// a clockwise direction.
-    ///
-    /// [`Arc`]: struct.Arc.html
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn arc(&mut self, arc: Arc) {
         self.ellipse(arc.into());
@@ -53,8 +44,6 @@ impl Builder {
     ///
     /// The arc is connected to the previous point by a straight line, if
     /// necessary.
-    ///
-    /// [`Path`]: struct.Path.html
     pub fn arc_to(&mut self, a: Point, b: Point, radius: f32) {
         use lyon::{math, path};
 
@@ -72,10 +61,7 @@ impl Builder {
         );
     }
 
-    /// Adds an [`Ellipse`] to the [`Path`] using a clockwise direction.
-    ///
-    /// [`Ellipse`]: struct.Arc.html
-    /// [`Path`]: struct.Path.html
+    /// Adds an ellipse to the [`Path`] using a clockwise direction.
     pub fn ellipse(&mut self, arc: arc::Elliptical) {
         use lyon::{geom, math};
 
@@ -96,8 +82,6 @@ impl Builder {
 
     /// Adds a cubic Bézier curve to the [`Path`] given its two control points
     /// and its end point.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn bezier_curve_to(
         &mut self,
@@ -116,8 +100,6 @@ impl Builder {
 
     /// Adds a quadratic Bézier curve to the [`Path`] given its control point
     /// and its end point.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn quadratic_curve_to(&mut self, control: Point, to: Point) {
         use lyon::math;
@@ -130,8 +112,6 @@ impl Builder {
 
     /// Adds a rectangle to the [`Path`] given its top-left corner coordinate
     /// and its `Size`.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn rectangle(&mut self, top_left: Point, size: Size) {
         self.move_to(top_left);
@@ -146,8 +126,6 @@ impl Builder {
 
     /// Adds a circle to the [`Path`] given its center coordinate and its
     /// radius.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn circle(&mut self, center: Point, radius: f32) {
         self.arc(Arc {
@@ -160,17 +138,12 @@ impl Builder {
 
     /// Closes the current sub-path in the [`Path`] with a straight line to
     /// the starting point.
-    ///
-    /// [`Path`]: struct.Path.html
     #[inline]
     pub fn close(&mut self) {
         self.raw.close()
     }
 
     /// Builds the [`Path`] of this [`Builder`].
-    ///
-    /// [`Path`]: struct.Path.html
-    /// [`Builder`]: struct.Builder.html
     #[inline]
     pub fn build(self) -> Path {
         Path {
diff --git a/graphics/src/widget/canvas/program.rs b/graphics/src/widget/canvas/program.rs
index e8f43380..d703caad 100644
--- a/graphics/src/widget/canvas/program.rs
+++ b/graphics/src/widget/canvas/program.rs
@@ -7,8 +7,7 @@ use iced_native::{mouse, Rectangle};
 /// A [`Program`] can mutate internal state and produce messages for an
 /// application.
 ///
-/// [`Canvas`]: struct.Canvas.html
-/// [`Program`]: trait.Program.html
+/// [`Canvas`]: crate::widget::Canvas
 pub trait Program<Message> {
     /// Updates the state of the [`Program`].
     ///
@@ -20,9 +19,7 @@ pub trait Program<Message> {
     ///
     /// By default, this method does and returns nothing.
     ///
-    /// [`Program`]: trait.Program.html
-    /// [`Canvas`]: struct.Canvas.html
-    /// [`Event`]: enum.Event.html
+    /// [`Canvas`]: crate::widget::Canvas
     fn update(
         &mut self,
         _event: Event,
@@ -37,10 +34,8 @@ pub trait Program<Message> {
     /// [`Geometry`] can be easily generated with a [`Frame`] or stored in a
     /// [`Cache`].
     ///
-    /// [`Program`]: trait.Program.html
-    /// [`Geometry`]: struct.Geometry.html
-    /// [`Frame`]: struct.Frame.html
-    /// [`Cache`]: struct.Cache.html
+    /// [`Frame`]: crate::widget::canvas::Cache
+    /// [`Cache`]: crate::widget::canvas::Cache
     fn draw(&self, bounds: Rectangle, cursor: Cursor) -> Vec<Geometry>;
 
     /// Returns the current mouse interaction of the [`Program`].
@@ -48,8 +43,7 @@ pub trait Program<Message> {
     /// The interaction returned will be in effect even if the cursor position
     /// is out of bounds of the program's [`Canvas`].
     ///
-    /// [`Program`]: trait.Program.html
-    /// [`Canvas`]: struct.Canvas.html
+    /// [`Canvas`]: crate::widget::Canvas
     fn mouse_interaction(
         &self,
         _bounds: Rectangle,
diff --git a/graphics/src/widget/canvas/stroke.rs b/graphics/src/widget/canvas/stroke.rs
index 5b6fc56a..9f0449d0 100644
--- a/graphics/src/widget/canvas/stroke.rs
+++ b/graphics/src/widget/canvas/stroke.rs
@@ -16,31 +16,21 @@ pub struct Stroke {
 
 impl Stroke {
     /// Sets the color of the [`Stroke`].
-    ///
-    /// [`Stroke`]: struct.Stroke.html
     pub fn with_color(self, color: Color) -> Stroke {
         Stroke { color, ..self }
     }
 
     /// Sets the width of the [`Stroke`].
-    ///
-    /// [`Stroke`]: struct.Stroke.html
     pub fn with_width(self, width: f32) -> Stroke {
         Stroke { width, ..self }
     }
 
     /// Sets the [`LineCap`] of the [`Stroke`].
-    ///
-    /// [`LineCap`]: enum.LineCap.html
-    /// [`Stroke`]: struct.Stroke.html
     pub fn with_line_cap(self, line_cap: LineCap) -> Stroke {
         Stroke { line_cap, ..self }
     }
 
     /// Sets the [`LineJoin`] of the [`Stroke`].
-    ///
-    /// [`LineJoin`]: enum.LineJoin.html
-    /// [`Stroke`]: struct.Stroke.html
     pub fn with_line_join(self, line_join: LineJoin) -> Stroke {
         Stroke { line_join, ..self }
     }
diff --git a/graphics/src/widget/pane_grid.rs b/graphics/src/widget/pane_grid.rs
index 72a380e4..a21d4d94 100644
--- a/graphics/src/widget/pane_grid.rs
+++ b/graphics/src/widget/pane_grid.rs
@@ -7,7 +7,6 @@
 //! drag and drop, and hotkey support.
 //!
 //! [`pane_grid` example]: https://github.com/hecrj/iced/tree/0.1/examples/pane_grid
-//! [`PaneGrid`]: type.PaneGrid.html
 use crate::backend::{self, Backend};
 use crate::defaults;
 use crate::{Primitive, Renderer};
diff --git a/graphics/src/widget/progress_bar.rs b/graphics/src/widget/progress_bar.rs
index c1801a41..932f4fc2 100644
--- a/graphics/src/widget/progress_bar.rs
+++ b/graphics/src/widget/progress_bar.rs
@@ -2,8 +2,6 @@
 //!
 //! A [`ProgressBar`] has a range of possible values and a current value,
 //! as well as a length, height and style.
-//!
-//! [`ProgressBar`]: type.ProgressBar.html
 use crate::{Backend, Primitive, Renderer};
 use iced_native::mouse;
 use iced_native::progress_bar;
diff --git a/graphics/src/widget/slider.rs b/graphics/src/widget/slider.rs
index 051e18b8..9a4af9ac 100644
--- a/graphics/src/widget/slider.rs
+++ b/graphics/src/widget/slider.rs
@@ -1,9 +1,6 @@
 //! Display an interactive selector of a single value from a range of values.
 //!
 //! A [`Slider`] has some local [`State`].
-//!
-//! [`Slider`]: struct.Slider.html
-//! [`State`]: struct.State.html
 use crate::{Backend, Primitive, Renderer};
 use iced_native::mouse;
 use iced_native::slider;
diff --git a/graphics/src/widget/text_input.rs b/graphics/src/widget/text_input.rs
index 55eb34e4..c269022b 100644
--- a/graphics/src/widget/text_input.rs
+++ b/graphics/src/widget/text_input.rs
@@ -1,9 +1,6 @@
 //! Display fields that can be filled with text.
 //!
 //! A [`TextInput`] has some local [`State`].
-//!
-//! [`TextInput`]: struct.TextInput.html
-//! [`State`]: struct.State.html
 use crate::backend::{self, Backend};
 use crate::{Primitive, Renderer};
 use iced_native::mouse;