Package ch.bailu.gtk.gsk

Klasse Path

java.lang.Object
ch.bailu.gtk.type.Type
ch.bailu.gtk.type.Pointer
ch.bailu.gtk.type.Record
ch.bailu.gtk.gsk.Path
Alle implementierten Schnittstellen:
PointerInterface
public class Path extends Record
Describes lines and curves that are more complex than simple rectangles.

Paths can used for rendering (filling or stroking) and for animations
(e.g. as trajectories).

`GskPath` is an immutable, opaque, reference-counted struct.
After creation, you cannot change the types it represents. Instead,
new `GskPath` objects have to be created. The [struct@Gsk.PathBuilder]
structure is meant to help in this endeavor.

Conceptually, a path consists of zero or more contours (continuous, connected
curves), each of which may or may not be closed. Contours are typically
constructed from Bézier segments.

<picture>
<source srcset="path-dark.png" media="(prefers-color-scheme: dark)">
<img alt="A Path" src="path-light.png">
</picture>

https://docs.gtk.org/gsk4/struct.Path.html

  • Konstruktordetails

  • Methodendetails

    • getClassHandler

      public static ClassHandler getClassHandler()

    • foreach

      public boolean foreach(int flags, Path.OnPathForeachFunc func, @Nullable Pointer user_data)
      Calls @func for every operation of the path.

      Note that this may only approximate @self, because paths can contain
      optimizations for various specialized contours, and depending on the
      @flags, the path may be decomposed into simpler curves than the ones
      that it contained originally.

      This function serves two purposes:

      - When the @flags allow everything, it provides access to the raw,
      unmodified data of the path.
      - When the @flags disallow certain operations, it provides
      an approximation of the path using just the allowed operations.
      Parameter:
      flags - flags to pass to the foreach function
      func - the function to call for operations
      user_data - user data passed to @func
      Gibt zurück:
      false if @func returned false, true otherwise.

    • getBounds

      public boolean getBounds(@Nonnull Rect bounds)
      Computes the bounds of the given path.

      The returned bounds may be larger than necessary, because this
      function aims to be fast, not accurate. The bounds are guaranteed
      to contain the path.

      It is possible that the returned rectangle has 0 width and/or height.
      This can happen when the path only describes a point or an
      axis-aligned line.

      If the path is empty, false is returned and @bounds are set to
      graphene_rect_zero(). This is different from the case where the path
      is a single point at the origin, where the @bounds will also be set to
      the zero rectangle but true will be returned.
      Parameter:
      bounds - return location for the bounds
      Gibt zurück:
      true if the path has bounds, false if the path is known to be empty and have no bounds

    • getClosestPoint

      public boolean getClosestPoint(@Nonnull Point point, float threshold, @Nonnull PathPoint result, @Nullable Flt distance)
      Computes the closest point on the path to the given point.

      If there is no point closer than the given threshold,
      false is returned.
      Parameter:
      point - the point
      threshold - maximum allowed distance
      result - return location for the closest point
      distance - return location for the distance
      Gibt zurück:
      true if @point was set to the closest point on @self, false if no point is closer than @threshold

    • getEndPoint

      public boolean getEndPoint(@Nonnull PathPoint result)
      Gets the end point of the path.

      An empty path has no points, so false
      is returned in this case.
      Parameter:
      result - return location for point
      Gibt zurück:
      true if @result was filled

    • getStartPoint

      public boolean getStartPoint(@Nonnull PathPoint result)
      Gets the start point of the path.

      An empty path has no points, so false
      is returned in this case.
      Parameter:
      result - return location for point
      Gibt zurück:
      true if @result was filled

    • getStrokeBounds

      public boolean getStrokeBounds(@Nonnull Stroke stroke, @Nonnull Rect bounds)
      Computes the bounds for stroking the given path with the
      given parameters.

      The returned bounds may be larger than necessary, because this
      function aims to be fast, not accurate. The bounds are guaranteed
      to contain the area affected by the stroke, including protrusions
      like miters.
      Parameter:
      stroke - stroke parameters
      bounds - the bounds to fill in
      Gibt zurück:
      true if the path has bounds, false if the path is known to be empty and have no bounds.

    • inFill

      public boolean inFill(@Nonnull Point point, int fill_rule)
      Returns whether a point is inside the fill area of a path.

      Note that this function assumes that filling a contour
      implicitly closes it.
      Parameter:
      point - the point to test
      fill_rule - the fill rule to follow
      Gibt zurück:
      true if @point is inside

    • isClosed

      public boolean isClosed()
      Returns if the path represents a single closed contour.
      Gibt zurück:
      true if the path is closed

    • isEmpty

      public boolean isEmpty()
      Checks if the path is empty, i.e. contains no lines or curves.
      Gibt zurück:
      true if the path is empty

    • print

      public void print(@Nonnull GString string)
      Converts the path into a human-readable representation.

      The string is compatible with (a superset of)
      [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
      see [func@Gsk.Path.parse] for a summary of the syntax.
      Parameter:
      string - the string to print into

    • ref

      public Path ref()
      Increases the reference count of a path by one.
      Gibt zurück:
      the passed in `GskPath`

    • toCairo

      public void toCairo(@Nonnull Context cr)
      Appends the path to a cairo context for drawing with Cairo.

      This may cause some suboptimal conversions to be performed as
      Cairo does not support all features of `GskPath`.

      This function does not clear the existing Cairo path. Call
      cairo_new_path() if you want this.
      Parameter:
      cr - a cairo context

    • toStr

      public Str toStr()
      Converts the path into a human-readable string.

      You can use this function in a debugger to get a quick overview
      of the path.

      This is a wrapper around [method@Gsk.Path.print], see that function
      for details.
      Gibt zurück:
      a new string for @self

    • unref

      public void unref()
      Decreases the reference count of a path by one.

      If the resulting reference count is zero, frees the path.

    • parse

      public static Path parse(@Nonnull Str string)
      Constructs a path from a serialized form.

      The string is expected to be in (a superset of)
      [SVG path syntax](https://www.w3.org/TR/SVG11/paths.html#PathData),
      as e.g. produced by [method@Gsk.Path.to_string].

      A high-level summary of the syntax:

      - `M x y` Move to `(x, y)`
      - `L x y` Add a line from the current point to `(x, y)`
      - `Q x1 y1 x2 y2` Add a quadratic Bézier from the current point to `(x2, y2)`, with control point `(x1, y1)`
      - `C x1 y1 x2 y2 x3 y3` Add a cubic Bézier from the current point to `(x3, y3)`, with control points `(x1, y1)` and `(x2, y2)`
      - `Z` Close the contour by drawing a line back to the start point
      - `H x` Add a horizontal line from the current point to the given x value
      - `V y` Add a vertical line from the current point to the given y value
      - `T x2 y2` Add a quadratic Bézier, using the reflection of the previous segments' control point as control point
      - `S x2 y2 x3 y3` Add a cubic Bézier, using the reflection of the previous segments' second control point as first control point
      - `A rx ry r l s x y` Add an elliptical arc from the current point to `(x, y)` with radii rx and ry. See the SVG documentation for how the other parameters influence the arc.
      - `O x1 y1 x2 y2 w` Add a rational quadratic Bézier from the current point to `(x2, y2)` with control point `(x1, y1)` and weight `w`.

      All the commands have lowercase variants that interpret coordinates
      relative to the current point.

      The `O` command is an extension that is not supported in SVG.
      Parameter:
      string - a string
      Gibt zurück:
      a new `GskPath`, or `NULL` if @string could not be parsed

    • getTypeID

      public static long getTypeID()

    • getParentTypeID

      public static long getParentTypeID()

    • getTypeSize

      public static TypeSystem.TypeSize getTypeSize()

    • getParentTypeSize

      public static TypeSystem.TypeSize getParentTypeSize()

    • getInstanceSize

      public static int getInstanceSize()