-- Hoogle documentation, generated by Haddock
-- See Hoogle, http://www.haskell.org/hoogle/


-- | Gsk bindings
--   
--   Bindings for Gsk, autogenerated by haskell-gi.
@package gi-gsk
@version 4.0.9


-- | Build time configuration used during code generation.
module GI.Gsk.Config

-- | Overrides used when generating these bindings.
overrides :: Text

-- | Modules in this package
modules :: [Text]


module GI.Gsk.Enums

-- | The blend modes available for render nodes.
--   
--   The implementation of each blend mode is deferred to the rendering
--   pipeline.
--   
--   See
--   &lt;https://www.w3.org/TR/compositing-1/<tt><i>blending</i></tt>&gt;
--   for more information on blending and blend modes.
data BlendMode

-- | The default blend mode, which specifies no blending
BlendModeDefault :: BlendMode

-- | The source color is multiplied by the destination and replaces the
--   destination
BlendModeMultiply :: BlendMode

-- | Multiplies the complements of the destination and source color values,
--   then complements the result.
BlendModeScreen :: BlendMode

-- | Multiplies or screens the colors, depending on the destination color
--   value. This is the inverse of hard-list
BlendModeOverlay :: BlendMode

-- | Selects the darker of the destination and source colors
BlendModeDarken :: BlendMode

-- | Selects the lighter of the destination and source colors
BlendModeLighten :: BlendMode

-- | Brightens the destination color to reflect the source color
BlendModeColorDodge :: BlendMode

-- | Darkens the destination color to reflect the source color
BlendModeColorBurn :: BlendMode

-- | Multiplies or screens the colors, depending on the source color value
BlendModeHardLight :: BlendMode

-- | Darkens or lightens the colors, depending on the source color value
BlendModeSoftLight :: BlendMode

-- | Subtracts the darker of the two constituent colors from the lighter
--   color
BlendModeDifference :: BlendMode

-- | Produces an effect similar to that of the difference mode but lower in
--   contrast
BlendModeExclusion :: BlendMode

-- | Creates a color with the hue and saturation of the source color and
--   the luminosity of the destination color
BlendModeColor :: BlendMode

-- | Creates a color with the hue of the source color and the saturation
--   and luminosity of the destination color
BlendModeHue :: BlendMode

-- | Creates a color with the saturation of the source color and the hue
--   and luminosity of the destination color
BlendModeSaturation :: BlendMode

-- | Creates a color with the luminosity of the source color and the hue
--   and saturation of the destination color
BlendModeLuminosity :: BlendMode

-- | Catch-all for unknown values
AnotherBlendMode :: Int -> BlendMode

-- | The corner indices used by <tt>GskRoundedRect</tt>.
data Corner

-- | The top left corner
CornerTopLeft :: Corner

-- | The top right corner
CornerTopRight :: Corner

-- | The bottom right corner
CornerBottomRight :: Corner

-- | The bottom left corner
CornerBottomLeft :: Corner

-- | Catch-all for unknown values
AnotherCorner :: Int -> Corner

-- | Specifies how paths are filled.
--   
--   Whether or not a point is included in the fill is determined by taking
--   a ray from that point to infinity and looking at intersections with
--   the path. The ray can be in any direction, as long as it doesn't pass
--   through the end point of a segment or have a tricky intersection such
--   as intersecting tangent to the path.
--   
--   (Note that filling is not actually implemented in this way. This is
--   just a description of the rule that is applied.)
--   
--   New entries may be added in future versions.
--   
--   <i>Since: 4.14</i>
data FillRule

-- | If the path crosses the ray from left-to-right, counts +1. If the path
--   crosses the ray from right to left, counts -1. (Left and right are
--   determined from the perspective of looking along the ray from the
--   starting point.) If the total count is non-zero, the point will be
--   filled.
FillRuleWinding :: FillRule

-- | Counts the total number of intersections, without regard to the
--   orientation of the contour. If the total number of intersections is
--   odd, the point will be filled.
FillRuleEvenOdd :: FillRule

-- | Catch-all for unknown values
AnotherFillRule :: Int -> FillRule

-- | Defines the types of the uniforms that <tt>GskGLShaders</tt> declare.
--   
--   It defines both what the type is called in the GLSL shader code, and
--   what the corresponding C type is on the Gtk side.

-- | <i>Deprecated: (Since version 4.16)</i>
data GLUniformType

-- | No type, used for uninitialized or unspecified values.
GLUniformTypeNone :: GLUniformType

-- | A float uniform
GLUniformTypeFloat :: GLUniformType

-- | A GLSL int / gint32 uniform
GLUniformTypeInt :: GLUniformType

-- | A GLSL uint / guint32 uniform
GLUniformTypeUint :: GLUniformType

-- | A GLSL bool / gboolean uniform
GLUniformTypeBool :: GLUniformType

-- | A GLSL vec2 / graphene_vec2_t uniform
GLUniformTypeVec2 :: GLUniformType

-- | A GLSL vec3 / graphene_vec3_t uniform
GLUniformTypeVec3 :: GLUniformType

-- | A GLSL vec4 / graphene_vec4_t uniform
GLUniformTypeVec4 :: GLUniformType

-- | Catch-all for unknown values
AnotherGLUniformType :: Int -> GLUniformType

-- | Specifies how to render the start and end points of contours or dashes
--   when stroking.
--   
--   The default line cap style is <tt>GSK_LINE_CAP_BUTT</tt>.
--   
--   New entries may be added in future versions.
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="caps-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Line Cap Styles"
--   src="caps-light.png"&gt; &lt;/picture&gt;
--   &lt;figcaption&gt;GSK_LINE_CAP_BUTT, GSK_LINE_CAP_ROUND,
--   GSK_LINE_CAP_SQUARE&lt;/figcaption&gt; &lt;/figure&gt;
--   
--   <i>Since: 4.14</i>
data LineCap

-- | Start and stop the line exactly at the start and end point
LineCapButt :: LineCap

-- | Use a round ending, the center of the circle is the start or end point
LineCapRound :: LineCap

-- | use squared ending, the center of the square is the start or end point
LineCapSquare :: LineCap

-- | Catch-all for unknown values
AnotherLineCap :: Int -> LineCap

-- | Specifies how to render the junction of two lines when stroking.
--   
--   The default line join style is <tt>GSK_LINE_JOIN_MITER</tt>.
--   
--   New entries may be added in future versions.
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="join-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Line Join
--   Styles" src="join-light.png"&gt; &lt;/picture&gt;
--   &lt;figcaption&gt;GSK_LINE_JOINT_MITER, GSK_LINE_JOINT_ROUND,
--   GSK_LINE_JOIN_BEVEL&lt;/figcaption&gt; &lt;/figure&gt;
--   
--   <i>Since: 4.14</i>
data LineJoin

-- | Use a sharp angled corner
LineJoinMiter :: LineJoin

-- | Use a round join, the center of the circle is the join point
LineJoinRound :: LineJoin

-- | use a cut-off join, the join is cut off at half the line width from
--   the joint point
LineJoinBevel :: LineJoin

-- | Catch-all for unknown values
AnotherLineJoin :: Int -> LineJoin

-- | The mask modes available for mask nodes.
--   
--   <i>Since: 4.10</i>
data MaskMode

-- | Use the alpha channel of the mask
MaskModeAlpha :: MaskMode

-- | Use the inverted alpha channel of the mask
MaskModeInvertedAlpha :: MaskMode

-- | Use the luminance of the mask, multiplied by mask alpha
MaskModeLuminance :: MaskMode

-- | Use the inverted luminance of the mask, multiplied by mask alpha
MaskModeInvertedLuminance :: MaskMode

-- | Catch-all for unknown values
AnotherMaskMode :: Int -> MaskMode

-- | Used to pick one of the four tangents at a given point on the path.
--   
--   Note that the directions for
--   <i><tt>gSKPATHFROMSTART</tt></i>/<i><tt>gSKPATHTOEND</tt></i> and
--   <i><tt>gSKPATHTOSTART</tt></i>/<i><tt>gSKPATHFROMEND</tt></i> will
--   coincide for smooth points. Only sharp turns will exhibit four
--   different directions.
--   
--   &lt;picture&gt; &lt;source srcset="directions-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Path Tangents"
--   src="directions-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
data PathDirection

-- | The tangent in path direction of the incoming side of the path
PathDirectionFromStart :: PathDirection

-- | The tangent against path direction of the incoming side of the path
PathDirectionToStart :: PathDirection

-- | The tangent in path direction of the outgoing side of the path
PathDirectionToEnd :: PathDirection

-- | The tangent against path direction of the outgoing side of the path
PathDirectionFromEnd :: PathDirection

-- | Catch-all for unknown values
AnotherPathDirection :: Int -> PathDirection

-- | The values of this enumeration classify intersections between paths.
--   
--   <i>Since: 4.20</i>
data PathIntersection

-- | No intersection
PathIntersectionNone :: PathIntersection

-- | A normal intersection, where the two paths cross each other
PathIntersectionNormal :: PathIntersection

-- | The start of a segment where the two paths coincide
PathIntersectionStart :: PathIntersection

-- | The end of a segment where the two paths coincide
PathIntersectionEnd :: PathIntersection

-- | Catch-all for unknown values
AnotherPathIntersection :: Int -> PathIntersection

-- | Describes the segments of a <tt>GskPath</tt>.
--   
--   More values may be added in the future.
--   
--   <i>Since: 4.14</i>
data PathOperation

-- | A move-to operation, with 1 point describing the target point.
PathOperationMove :: PathOperation

-- | A close operation ending the current contour with a line back to the
--   starting point. Two points describe the start and end of the line.
PathOperationClose :: PathOperation

-- | A line-to operation, with 2 points describing the start and end point
--   of a straight line.
PathOperationLine :: PathOperation

-- | A curve-to operation describing a quadratic Bézier curve with 3 points
--   describing the start point, the control point and the end point of the
--   curve.
PathOperationQuad :: PathOperation

-- | A curve-to operation describing a cubic Bézier curve with 4 points
--   describing the start point, the two control points and the end point
--   of the curve.
PathOperationCubic :: PathOperation

-- | A rational quadratic Bézier curve with 3 points describing the start
--   point, control point and end point of the curve. A weight for the
--   curve will be passed, too.
PathOperationConic :: PathOperation

-- | Catch-all for unknown values
AnotherPathOperation :: Int -> PathOperation

-- | GSK_PORTER_DUFF_SOURCE: GSK_PORTER_DUFF_DEST:
--   GSK_PORTER_DUFF_SOURCE_OVER_DEST: GSK_PORTER_DUFF_DEST_OVER_SOURCE:
--   GSK_PORTER_DUFF_SOURCE_IN_DEST: GSK_PORTER_DUFF_DEST_IN_SOURCE:
--   GSK_PORTER_DUFF_SOURCE_OUT_DEST: GSK_PORTER_DUFF_DEST_OUT_SOURCE:
--   GSK_PORTER_DUFF_SOURCE_ATOP_DEST: GSK_PORTER_DUFF_DEST_ATOP_SOURCE:
--   GSK_PORTER_DUFF_XOR: GSK_PORTER_DUFF_CLEAR: The 12 compositing modes
--   defined by the seminal paper by Thomas Porter and Tom Duff.
--   
--   They are used in SVG, PDF and in Cairo with <tt>cairo_operator_t</tt>.
--   
--   <i>Since: 4.22</i>
data PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffSource :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffDest :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffSourceOverDest :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffDestOverSource :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffSourceInDest :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffDestInSource :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffSourceOutDest :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffDestOutSource :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffSourceAtopDest :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffDestAtopSource :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffXor :: PorterDuff

-- | <i>No description available in the introspection data.</i>
PorterDuffClear :: PorterDuff

-- | Catch-all for unknown values
AnotherPorterDuff :: Int -> PorterDuff

-- | The type of a node determines what the node is rendering.
data RenderNodeType

-- | Error type. No node will ever have this type.
RenderNodeTypeNotARenderNode :: RenderNodeType

-- | A node containing a stack of children
RenderNodeTypeContainerNode :: RenderNodeType

-- | A node drawing a <tt>cairo_surface_t</tt>
RenderNodeTypeCairoNode :: RenderNodeType

-- | A node drawing a single color rectangle
RenderNodeTypeColorNode :: RenderNodeType

-- | A node drawing a linear gradient
RenderNodeTypeLinearGradientNode :: RenderNodeType

-- | A node drawing a repeating linear gradient
RenderNodeTypeRepeatingLinearGradientNode :: RenderNodeType

-- | A node drawing a radial gradient
RenderNodeTypeRadialGradientNode :: RenderNodeType

-- | A node drawing a repeating radial gradient
RenderNodeTypeRepeatingRadialGradientNode :: RenderNodeType

-- | A node drawing a conic gradient
RenderNodeTypeConicGradientNode :: RenderNodeType

-- | A node stroking a border around an area
RenderNodeTypeBorderNode :: RenderNodeType

-- | A node drawing a <tt>GdkTexture</tt>
RenderNodeTypeTextureNode :: RenderNodeType

-- | A node drawing an inset shadow
RenderNodeTypeInsetShadowNode :: RenderNodeType

-- | A node drawing an outset shadow
RenderNodeTypeOutsetShadowNode :: RenderNodeType

-- | A node that renders its child after applying a matrix transform
RenderNodeTypeTransformNode :: RenderNodeType

-- | A node that changes the opacity of its child
RenderNodeTypeOpacityNode :: RenderNodeType

-- | A node that applies a color matrix to every pixel
RenderNodeTypeColorMatrixNode :: RenderNodeType

-- | A node that repeats the child's contents
RenderNodeTypeRepeatNode :: RenderNodeType

-- | A node that clips its child to a rectangular area
RenderNodeTypeClipNode :: RenderNodeType

-- | A node that clips its child to a rounded rectangle
RenderNodeTypeRoundedClipNode :: RenderNodeType

-- | A node that draws a shadow below its child
RenderNodeTypeShadowNode :: RenderNodeType

-- | A node that blends two children together
RenderNodeTypeBlendNode :: RenderNodeType

-- | A node that cross-fades between two children
RenderNodeTypeCrossFadeNode :: RenderNodeType

-- | A node containing a glyph string
RenderNodeTypeTextNode :: RenderNodeType

-- | A node that applies a blur
RenderNodeTypeBlurNode :: RenderNodeType

-- | Debug information that does not affect the rendering
RenderNodeTypeDebugNode :: RenderNodeType

-- | A node that uses OpenGL fragment shaders to render
RenderNodeTypeGlShaderNode :: RenderNodeType

-- | A node drawing a <tt>GdkTexture</tt> scaled and filtered.
--   
--   <i>Since: 4.10</i>
RenderNodeTypeTextureScaleNode :: RenderNodeType

-- | A node that masks one child with another.
--   
--   <i>Since: 4.10</i>
RenderNodeTypeMaskNode :: RenderNodeType

-- | A node that fills a path.
--   
--   <i>Since: 4.14</i>
RenderNodeTypeFillNode :: RenderNodeType

-- | A node that strokes a path.
--   
--   <i>Since: 4.14</i>
RenderNodeTypeStrokeNode :: RenderNodeType

-- | A node that possibly redirects part of the scene graph to a
--   subsurface.
--   
--   <i>Since: 4.14</i>
RenderNodeTypeSubsurfaceNode :: RenderNodeType

-- | A node that applies some function to each color component.
--   
--   <i>Since: 4.20</i>
RenderNodeTypeComponentTransferNode :: RenderNodeType

-- | A node that copies the rendering canvas to be pasted later.
--   
--   <i>Since: 4.22</i>
RenderNodeTypeCopyNode :: RenderNodeType

-- | A node that pastes a previously copied canvas.
--   
--   <i>Since: 4.22</i>
RenderNodeTypePasteNode :: RenderNodeType

-- | A node that combines a child with the background using Porter/Duff
--   operations.
--   
--   <i>Since: 4.22</i>
RenderNodeTypeCompositeNode :: RenderNodeType

-- | A node that isolated content of its child from previous content.
--   
--   <i>Since: 4.22</i>
RenderNodeTypeIsolationNode :: RenderNodeType

-- | A node that displaces content according to some mask.
--   
--   <i>Since: 4.22</i>
RenderNodeTypeDisplacementNode :: RenderNodeType

-- | A node that combines two child nodes in an arithmetic way.
--   
--   <i>Since: 4.22</i>
RenderNodeTypeArithmeticNode :: RenderNodeType

-- | Catch-all for unknown values
AnotherRenderNodeType :: Int -> RenderNodeType

-- | The filters used when scaling texture data.
--   
--   The actual implementation of each filter is deferred to the rendering
--   pipeline.
data ScalingFilter

-- | linear interpolation filter
ScalingFilterLinear :: ScalingFilter

-- | nearest neighbor interpolation filter
ScalingFilterNearest :: ScalingFilter

-- | linear interpolation along each axis, plus mipmap generation, with
--   linear interpolation along the mipmap levels
ScalingFilterTrilinear :: ScalingFilter

-- | Catch-all for unknown values
AnotherScalingFilter :: Int -> ScalingFilter

-- | Errors that can happen during (de)serialization.
data SerializationError

-- | The format can not be identified
SerializationErrorUnsupportedFormat :: SerializationError

-- | The version of the data is not understood
SerializationErrorUnsupportedVersion :: SerializationError

-- | The given data may not exist in a proper serialization
SerializationErrorInvalidData :: SerializationError

-- | Catch-all for unknown values
AnotherSerializationError :: Int -> SerializationError

-- | Catch exceptions of type <a>SerializationError</a>. This is a
--   specialized version of <a>catchGErrorJustDomain</a>.
catchSerializationError :: IO a -> (SerializationError -> GErrorMessage -> IO a) -> IO a

-- | Handle exceptions of type <a>SerializationError</a>. This is a
--   specialized version of <a>handleGErrorJustDomain</a>.
handleSerializationError :: (SerializationError -> GErrorMessage -> IO a) -> IO a -> IO a

-- | The categories of matrices relevant for GSK and GTK.
--   
--   Note that any category includes matrices of all later categories. So
--   if you want to for example check if a matrix is a 2D matrix,
--   <tt>category &gt;= GSK_TRANSFORM_CATEGORY_2D</tt> is the way to do
--   this.
--   
--   Also keep in mind that rounding errors may cause matrices to not
--   conform to their categories. Otherwise, matrix operations done via
--   multiplication will not worsen categories. So for the matrix
--   multiplication <tt>C = A * B</tt>, <tt>category(C) = MIN (category(A),
--   category(B))</tt>.
data TransformCategory

-- | The category of the matrix has not been determined.
TransformCategoryUnknown :: TransformCategory

-- | Analyzing the matrix concluded that it does not fit in any other
--   category.
TransformCategoryAny :: TransformCategory

-- | The matrix is a 3D matrix. This means that the w column (the last
--   column) has the values (0, 0, 0, 1).
TransformCategory3d :: TransformCategory

-- | The matrix is a 2D matrix. This is equivalent to <a>matrixIs2d</a>
--   returning <a>True</a>. In particular, this means that Cairo can deal
--   with the matrix.
TransformCategory2d :: TransformCategory

-- | The matrix is a combination of 2D scale and 2D translation operations.
--   In particular, this means that any rectangle can be transformed
--   exactly using this matrix.
TransformCategory2dAffine :: TransformCategory

-- | The matrix is a 2D translation.
TransformCategory2dTranslate :: TransformCategory

-- | The matrix is the identity matrix.
TransformCategoryIdentity :: TransformCategory

-- | Catch-all for unknown values
AnotherTransformCategory :: Int -> TransformCategory
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.BlendMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.Corner
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.FillRule
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.GLUniformType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.LineCap
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.LineJoin
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.MaskMode
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.PathDirection
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.PathIntersection
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.PathOperation
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.PorterDuff
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.RenderNodeType
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.ScalingFilter
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.SerializationError
instance Data.GI.Base.BasicTypes.BoxedEnum GI.Gsk.Enums.TransformCategory
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.BlendMode
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.Corner
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.FillRule
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.GLUniformType
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.LineCap
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.LineJoin
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.MaskMode
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.PathDirection
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.PathIntersection
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.PathOperation
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.PorterDuff
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.RenderNodeType
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.ScalingFilter
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.SerializationError
instance GHC.Internal.Enum.Enum GI.Gsk.Enums.TransformCategory
instance GHC.Classes.Eq GI.Gsk.Enums.BlendMode
instance GHC.Classes.Eq GI.Gsk.Enums.Corner
instance GHC.Classes.Eq GI.Gsk.Enums.FillRule
instance GHC.Classes.Eq GI.Gsk.Enums.GLUniformType
instance GHC.Classes.Eq GI.Gsk.Enums.LineCap
instance GHC.Classes.Eq GI.Gsk.Enums.LineJoin
instance GHC.Classes.Eq GI.Gsk.Enums.MaskMode
instance GHC.Classes.Eq GI.Gsk.Enums.PathDirection
instance GHC.Classes.Eq GI.Gsk.Enums.PathIntersection
instance GHC.Classes.Eq GI.Gsk.Enums.PathOperation
instance GHC.Classes.Eq GI.Gsk.Enums.PorterDuff
instance GHC.Classes.Eq GI.Gsk.Enums.RenderNodeType
instance GHC.Classes.Eq GI.Gsk.Enums.ScalingFilter
instance GHC.Classes.Eq GI.Gsk.Enums.SerializationError
instance GHC.Classes.Eq GI.Gsk.Enums.TransformCategory
instance Data.GI.Base.GError.GErrorClass GI.Gsk.Enums.SerializationError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.BlendMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.Corner
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.FillRule
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.GLUniformType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.LineCap
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.LineJoin
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.MaskMode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.PathDirection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.PathIntersection
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.PathOperation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.PorterDuff
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.RenderNodeType
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.ScalingFilter
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.SerializationError
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Enums.TransformCategory
instance GHC.Classes.Ord GI.Gsk.Enums.BlendMode
instance GHC.Classes.Ord GI.Gsk.Enums.Corner
instance GHC.Classes.Ord GI.Gsk.Enums.FillRule
instance GHC.Classes.Ord GI.Gsk.Enums.GLUniformType
instance GHC.Classes.Ord GI.Gsk.Enums.LineCap
instance GHC.Classes.Ord GI.Gsk.Enums.LineJoin
instance GHC.Classes.Ord GI.Gsk.Enums.MaskMode
instance GHC.Classes.Ord GI.Gsk.Enums.PathDirection
instance GHC.Classes.Ord GI.Gsk.Enums.PathIntersection
instance GHC.Classes.Ord GI.Gsk.Enums.PathOperation
instance GHC.Classes.Ord GI.Gsk.Enums.PorterDuff
instance GHC.Classes.Ord GI.Gsk.Enums.RenderNodeType
instance GHC.Classes.Ord GI.Gsk.Enums.ScalingFilter
instance GHC.Classes.Ord GI.Gsk.Enums.SerializationError
instance GHC.Classes.Ord GI.Gsk.Enums.TransformCategory
instance GHC.Internal.Show.Show GI.Gsk.Enums.BlendMode
instance GHC.Internal.Show.Show GI.Gsk.Enums.Corner
instance GHC.Internal.Show.Show GI.Gsk.Enums.FillRule
instance GHC.Internal.Show.Show GI.Gsk.Enums.GLUniformType
instance GHC.Internal.Show.Show GI.Gsk.Enums.LineCap
instance GHC.Internal.Show.Show GI.Gsk.Enums.LineJoin
instance GHC.Internal.Show.Show GI.Gsk.Enums.MaskMode
instance GHC.Internal.Show.Show GI.Gsk.Enums.PathDirection
instance GHC.Internal.Show.Show GI.Gsk.Enums.PathIntersection
instance GHC.Internal.Show.Show GI.Gsk.Enums.PathOperation
instance GHC.Internal.Show.Show GI.Gsk.Enums.PorterDuff
instance GHC.Internal.Show.Show GI.Gsk.Enums.RenderNodeType
instance GHC.Internal.Show.Show GI.Gsk.Enums.ScalingFilter
instance GHC.Internal.Show.Show GI.Gsk.Enums.SerializationError
instance GHC.Internal.Show.Show GI.Gsk.Enums.TransformCategory
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.BlendMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.Corner
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.FillRule
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.GLUniformType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.LineCap
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.LineJoin
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.MaskMode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.PathDirection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.PathIntersection
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.PathOperation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.PorterDuff
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.RenderNodeType
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.ScalingFilter
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.SerializationError
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Enums.TransformCategory


module GI.Gsk.Flags

-- | These flags describe the types of isolations possible with a
--   <a>IsolationNode</a>.
--   
--   More isolation options may be added in the future.
--   
--   <i>Since: 4.22</i>
data Isolation

-- | No isolation is defined.
IsolationNone :: Isolation

-- | If the background should be made available. If the background is not
--   available, future operations will be rendered to a transparent
--   background and added to the existing background later.
IsolationBackground :: Isolation

-- | If copies should be available to paste nodes. If copies are not
--   available, paste nodes can only paste from copies that are made inside
--   the isolated contents.
IsolationCopyPaste :: Isolation

-- | Isolate everything. This will include features that are added in the
--   future.
IsolationAll :: Isolation

-- | Catch-all for unknown values
AnotherIsolation :: Int -> Isolation

-- | Flags that can be passed to <a>pathForeach</a> to influence what kinds
--   of operations the path is decomposed into.
--   
--   By default, <a>pathForeach</a> will only emit a path with all
--   operations flattened to straight lines to allow for maximum
--   compatibility. The only operations emitted will be
--   <tt>GSK_PATH_MOVE</tt>, <tt>GSK_PATH_LINE</tt> and
--   <tt>GSK_PATH_CLOSE</tt>.
--   
--   <i>Since: 4.14</i>
data PathForeachFlags

-- | The default behavior, only allow lines.
PathForeachFlagsOnlyLines :: PathForeachFlags

-- | Allow emission of <tt>GSK_PATH_QUAD</tt> operations
PathForeachFlagsQuad :: PathForeachFlags

-- | Allow emission of <tt>GSK_PATH_CUBIC</tt> operations.
PathForeachFlagsCubic :: PathForeachFlags

-- | Allow emission of <tt>GSK_PATH_CONIC</tt> operations.
PathForeachFlagsConic :: PathForeachFlags

-- | Catch-all for unknown values
AnotherPathForeachFlags :: Int -> PathForeachFlags
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gsk.Flags.Isolation
instance Data.GI.Base.BasicTypes.BoxedFlags GI.Gsk.Flags.PathForeachFlags
instance GHC.Internal.Enum.Enum GI.Gsk.Flags.Isolation
instance GHC.Internal.Enum.Enum GI.Gsk.Flags.PathForeachFlags
instance GHC.Classes.Eq GI.Gsk.Flags.Isolation
instance GHC.Classes.Eq GI.Gsk.Flags.PathForeachFlags
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Flags.Isolation
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Flags.PathForeachFlags
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gsk.Flags.Isolation
instance Data.GI.Base.BasicTypes.IsGFlag GI.Gsk.Flags.PathForeachFlags
instance GHC.Classes.Ord GI.Gsk.Flags.Isolation
instance GHC.Classes.Ord GI.Gsk.Flags.PathForeachFlags
instance GHC.Internal.Show.Show GI.Gsk.Flags.Isolation
instance GHC.Internal.Show.Show GI.Gsk.Flags.PathForeachFlags
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Flags.Isolation
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Flags.PathForeachFlags


-- | A color stop in a gradient node.
module GI.Gsk.Structs.ColorStop

-- | Memory-managed wrapper type.
newtype ColorStop
ColorStop :: ManagedPtr ColorStop -> ColorStop

-- | Construct a <a>ColorStop</a> struct initialized to zero.
newZeroColorStop :: MonadIO m => m ColorStop

-- | Get the value of the “<tt>color</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorStop #color
--   </pre>
getColorStopColor :: MonadIO m => ColorStop -> m RGBA

-- | Get the value of the “<tt>offset</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> colorStop #offset
--   </pre>
getColorStopOffset :: MonadIO m => ColorStop -> m Float

-- | Set the value of the “<tt>offset</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> colorStop [ #offset <a>:=</a> value ]
--   </pre>
setColorStopOffset :: MonadIO m => ColorStop -> Float -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Structs.ColorStop.ColorStop
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gsk.Structs.ColorStop.ColorStop
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gsk.Structs.ColorStop.ColorStop tag
instance GHC.Classes.Eq GI.Gsk.Structs.ColorStop.ColorStop
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.ColorStop.ColorStop


-- | Specifies a transfer function for a color component to be applied
--   while rendering.
--   
--   The available functions include linear, piecewise-linear, gamma and
--   step functions.
--   
--   Note that the transfer function is applied to un-premultiplied values,
--   and all results are clamped to the [0, 1] range.
--   
--   <i>Since: 4.20</i>
module GI.Gsk.Structs.ComponentTransfer

-- | Memory-managed wrapper type.
newtype ComponentTransfer
ComponentTransfer :: ManagedPtr ComponentTransfer -> ComponentTransfer

-- | Creates a copy of <i><tt>other</tt></i>.
--   
--   <i>Since: 4.20</i>
componentTransferCopy :: (HasCallStack, MonadIO m) => ComponentTransfer -> m ComponentTransfer

-- | Compares two component transfers for equality.
--   
--   <i>Since: 4.20</i>
componentTransferEqual :: (HasCallStack, MonadIO m) => Ptr () -> Ptr () -> m Bool

-- | Frees a component transfer.
--   
--   <i>Since: 4.20</i>
componentTransferFree :: (HasCallStack, MonadIO m) => ComponentTransfer -> m ()

-- | Creates a new component transfer that applies a step function.
--   
--   The new value is computed as
--   
--   C' = values[k]
--   
--   where k is the smallest value such that
--   
--   k / n &lt;= C &lt; (k + 1) / n
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="discrete-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: discrete" src="discrete-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewDiscrete :: (HasCallStack, MonadIO m) => [Float] -> m ComponentTransfer

-- | Creates a new component transfer that applies a gamma transform.
--   
--   The new value is computed as
--   
--   C' = amp * pow (C, exp) + ofs
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="gamma-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: gamma" src="gamma-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewGamma :: (HasCallStack, MonadIO m) => Float -> Float -> Float -> m ComponentTransfer

-- | Creates a new component transfer that doesn't change the component
--   value.
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="identity-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: identity" src="identity-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewIdentity :: (HasCallStack, MonadIO m) => m ComponentTransfer

-- | Creates a new component transfer that limits the values of the
--   component to <tt>n</tt> levels.
--   
--   The new value is computed as
--   
--   C' = (floor (C * n) + 0.5) / n
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="levels-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: levels" src="levels-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewLevels :: (HasCallStack, MonadIO m) => Float -> m ComponentTransfer

-- | Creates a new component transfer that applies a linear transform.
--   
--   The new value is computed as
--   
--   C' = C * m + b
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="linear-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: linear" src="linear-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewLinear :: (HasCallStack, MonadIO m) => Float -> Float -> m ComponentTransfer

-- | Creates a new component transfer that applies a piecewise linear
--   function.
--   
--   The new value is computed as
--   
--   C' = values[k] + (C - k / (n - 1)) * n * (values[k + 1] - values[k])
--   
--   where k is the smallest value such that
--   
--   k / (n - 1) &lt;= C &lt; (k + 1) / (n - 1)
--   
--   &lt;figure&gt; &lt;picture&gt; &lt;source srcset="table-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Component
--   transfer: table" src="table-light.png"&gt; &lt;/picture&gt;
--   &lt;/figure&gt;
--   
--   <i>Since: 4.20</i>
componentTransferNewTable :: (HasCallStack, MonadIO m) => [Float] -> m ComponentTransfer
instance GHC.Classes.Eq GI.Gsk.Structs.ComponentTransfer.ComponentTransfer
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.ComponentTransfer.ComponentTransfer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.ComponentTransfer.ComponentTransfer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.ComponentTransfer.ComponentTransfer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.ComponentTransfer.ComponentTransfer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.ComponentTransfer.ComponentTransfer


-- | A location in a parse buffer.
module GI.Gsk.Structs.ParseLocation

-- | Memory-managed wrapper type.
newtype ParseLocation
ParseLocation :: ManagedPtr ParseLocation -> ParseLocation

-- | Construct a <a>ParseLocation</a> struct initialized to zero.
newZeroParseLocation :: MonadIO m => m ParseLocation

-- | Get the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parseLocation #bytes
--   </pre>
getParseLocationBytes :: MonadIO m => ParseLocation -> m CSize

-- | Set the value of the “<tt>bytes</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parseLocation [ #bytes <a>:=</a> value ]
--   </pre>
setParseLocationBytes :: MonadIO m => ParseLocation -> CSize -> m ()

-- | Get the value of the “<tt>chars</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parseLocation #chars
--   </pre>
getParseLocationChars :: MonadIO m => ParseLocation -> m CSize

-- | Set the value of the “<tt>chars</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parseLocation [ #chars <a>:=</a> value ]
--   </pre>
setParseLocationChars :: MonadIO m => ParseLocation -> CSize -> m ()

-- | Get the value of the “<tt>line_bytes</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parseLocation #lineBytes
--   </pre>
getParseLocationLineBytes :: MonadIO m => ParseLocation -> m CSize

-- | Set the value of the “<tt>line_bytes</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parseLocation [ #lineBytes <a>:=</a> value ]
--   </pre>
setParseLocationLineBytes :: MonadIO m => ParseLocation -> CSize -> m ()

-- | Get the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parseLocation #lineChars
--   </pre>
getParseLocationLineChars :: MonadIO m => ParseLocation -> m CSize

-- | Set the value of the “<tt>line_chars</tt>” field. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parseLocation [ #lineChars <a>:=</a> value ]
--   </pre>
setParseLocationLineChars :: MonadIO m => ParseLocation -> CSize -> m ()

-- | Get the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> parseLocation #lines
--   </pre>
getParseLocationLines :: MonadIO m => ParseLocation -> m CSize

-- | Set the value of the “<tt>lines</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> parseLocation [ #lines <a>:=</a> value ]
--   </pre>
setParseLocationLines :: MonadIO m => ParseLocation -> CSize -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Structs.ParseLocation.ParseLocation
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gsk.Structs.ParseLocation.ParseLocation
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gsk.Structs.ParseLocation.ParseLocation tag
instance GHC.Classes.Eq GI.Gsk.Structs.ParseLocation.ParseLocation
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.ParseLocation.ParseLocation


-- | A rectangular region with rounded corners.
--   
--   Application code should normalize rectangles using
--   <a>roundedRectNormalize</a>; this function will ensure that the bounds
--   of the rectangle are normalized and ensure that the corner values are
--   positive and the corners do not overlap.
--   
--   All functions taking a <tt>GskRoundedRect</tt> as an argument will
--   internally operate on a normalized copy; all functions returning a
--   <tt>GskRoundedRect</tt> will always return a normalized one.
--   
--   The algorithm used for normalizing corner sizes is described in <a>the
--   CSS specification</a>.
module GI.Gsk.Structs.RoundedRect

-- | Memory-managed wrapper type.
newtype RoundedRect
RoundedRect :: ManagedPtr RoundedRect -> RoundedRect

-- | Construct a <a>RoundedRect</a> struct initialized to zero.
newZeroRoundedRect :: MonadIO m => m RoundedRect

-- | Checks if the given point is inside the rounded rectangle.
roundedRectContainsPoint :: (HasCallStack, MonadIO m) => RoundedRect -> Point -> m Bool

-- | Checks if the given rectangle is contained inside the rounded
--   rectangle.
roundedRectContainsRect :: (HasCallStack, MonadIO m) => RoundedRect -> Rect -> m Bool

-- | Initializes a rounded rectangle with the given values.
--   
--   This function will implicitly normalize the rounded rectangle before
--   returning.
roundedRectInit :: (HasCallStack, MonadIO m) => RoundedRect -> Rect -> Size -> Size -> Size -> Size -> m RoundedRect

-- | Initializes a rounded rectangle with a copy.
--   
--   This function will not normalize the rounded rectangle, so make sure
--   the source is normalized.
roundedRectInitCopy :: (HasCallStack, MonadIO m) => RoundedRect -> RoundedRect -> m RoundedRect

-- | Initializes a rounded rectangle to the given bounds and sets the
--   radius of all four corners equally.
roundedRectInitFromRect :: (HasCallStack, MonadIO m) => RoundedRect -> Rect -> Float -> m RoundedRect

-- | Checks if part a rectangle is contained inside the rounded rectangle.
roundedRectIntersectsRect :: (HasCallStack, MonadIO m) => RoundedRect -> Rect -> m Bool

-- | Checks if all corners of a rounded rectangle are right angles and the
--   rectangle covers all of its bounds.
--   
--   This information can be used to decide if <a>clipNodeNew</a> or
--   <a>roundedClipNodeNew</a> should be called.
roundedRectIsRectilinear :: (HasCallStack, MonadIO m) => RoundedRect -> m Bool

-- | Normalizes a rounded rectangle.
--   
--   This function will ensure that the bounds of the rounded rectangle are
--   normalized and ensure that the corner values are positive and the
--   corners do not overlap.
roundedRectNormalize :: (HasCallStack, MonadIO m) => RoundedRect -> m RoundedRect

-- | Offsets the rounded rectangle's origin by <i><tt>dx</tt></i> and
--   <i><tt>dy</tt></i>.
--   
--   The size and corners of the rounded rectangle are unchanged.
roundedRectOffset :: (HasCallStack, MonadIO m) => RoundedRect -> Float -> Float -> m RoundedRect

-- | Shrinks (or grows) a rounded rectangle by moving the 4 sides according
--   to the offsets given.
--   
--   The corner radii will be changed in a way that tries to keep the
--   center of the corner circle intact. This emulates CSS behavior.
--   
--   This function also works for growing rounded rectangles if you pass
--   negative values for the <i><tt>top</tt></i>, <i><tt>right</tt></i>,
--   <i><tt>bottom</tt></i> or <i><tt>left</tt></i>.
roundedRectShrink :: (HasCallStack, MonadIO m) => RoundedRect -> Float -> Float -> Float -> Float -> m RoundedRect

-- | Get the value of the “<tt>bounds</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> roundedRect #bounds
--   </pre>
getRoundedRectBounds :: MonadIO m => RoundedRect -> m Rect
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Structs.RoundedRect.RoundedRect
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gsk.Structs.RoundedRect.RoundedRect
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gsk.Structs.RoundedRect.RoundedRect tag
instance GHC.Classes.Eq GI.Gsk.Structs.RoundedRect.RoundedRect
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.RoundedRect.RoundedRect


-- | The shadow parameters in a shadow node.
module GI.Gsk.Structs.Shadow

-- | Memory-managed wrapper type.
newtype Shadow
Shadow :: ManagedPtr Shadow -> Shadow

-- | Construct a <a>Shadow</a> struct initialized to zero.
newZeroShadow :: MonadIO m => m Shadow

-- | Get the value of the “<tt>color</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shadow #color
--   </pre>
getShadowColor :: MonadIO m => Shadow -> m RGBA

-- | Get the value of the “<tt>dx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shadow #dx
--   </pre>
getShadowDx :: MonadIO m => Shadow -> m Float

-- | Set the value of the “<tt>dx</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shadow [ #dx <a>:=</a> value ]
--   </pre>
setShadowDx :: MonadIO m => Shadow -> Float -> m ()

-- | Get the value of the “<tt>dy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shadow #dy
--   </pre>
getShadowDy :: MonadIO m => Shadow -> m Float

-- | Set the value of the “<tt>dy</tt>” field. When <a>overloading</a> is
--   enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shadow [ #dy <a>:=</a> value ]
--   </pre>
setShadowDy :: MonadIO m => Shadow -> Float -> m ()

-- | Get the value of the “<tt>radius</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> shadow #radius
--   </pre>
getShadowRadius :: MonadIO m => Shadow -> m Float

-- | Set the value of the “<tt>radius</tt>” field. When <a>overloading</a>
--   is enabled, this is equivalent to
--   
--   <pre>
--   <a>set</a> shadow [ #radius <a>:=</a> value ]
--   </pre>
setShadowRadius :: MonadIO m => Shadow -> Float -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Structs.Shadow.Shadow
instance Data.GI.Base.BasicTypes.CallocPtr GI.Gsk.Structs.Shadow.Shadow
instance (tag GHC.Types.~ 'Data.GI.Base.Attributes.AttrSet) => Data.GI.Base.Constructible.Constructible GI.Gsk.Structs.Shadow.Shadow tag
instance GHC.Classes.Eq GI.Gsk.Structs.Shadow.Shadow
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.Shadow.Shadow


-- | Collects the parameters that are needed when stroking a path.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Structs.Stroke

-- | Memory-managed wrapper type.
newtype Stroke
Stroke :: ManagedPtr Stroke -> Stroke

-- | Creates a copy of a <tt>GskStroke</tt>.
--   
--   <i>Since: 4.14</i>
strokeCopy :: (HasCallStack, MonadIO m) => Stroke -> m Stroke

-- | Checks if two strokes are identical.
--   
--   <i>Since: 4.14</i>
strokeEqual :: (HasCallStack, MonadIO m) => Ptr () -> Ptr () -> m Bool

-- | Frees a <tt>GskStroke</tt>.
--   
--   <i>Since: 4.14</i>
strokeFree :: (HasCallStack, MonadIO m) => Stroke -> m ()

-- | Gets the dash array in use.
--   
--   <i>Since: 4.14</i>
strokeGetDash :: (HasCallStack, MonadIO m) => Stroke -> m (Maybe [Float])

-- | Gets the dash offset.
--   
--   <i>Since: 4.14</i>
strokeGetDashOffset :: (HasCallStack, MonadIO m) => Stroke -> m Float

-- | Gets the line cap used.
--   
--   See <a>LineCap</a> for details.
--   
--   <i>Since: 4.14</i>
strokeGetLineCap :: (HasCallStack, MonadIO m) => Stroke -> m LineCap

-- | Gets the line join used.
--   
--   See <a>LineJoin</a> for details.
--   
--   <i>Since: 4.14</i>
strokeGetLineJoin :: (HasCallStack, MonadIO m) => Stroke -> m LineJoin

-- | Gets the line width used.
--   
--   <i>Since: 4.14</i>
strokeGetLineWidth :: (HasCallStack, MonadIO m) => Stroke -> m Float

-- | Gets the miter limit.
--   
--   <i>Since: 4.14</i>
strokeGetMiterLimit :: (HasCallStack, MonadIO m) => Stroke -> m Float

-- | Creates a new <tt>GskStroke</tt> with the given
--   <i><tt>lineWidth</tt></i>.
--   
--   <i>Since: 4.14</i>
strokeNew :: (HasCallStack, MonadIO m) => Float -> m Stroke

-- | Sets the dash pattern to use.
--   
--   A dash pattern is specified by an array of alternating non-negative
--   values. Each value provides the length of alternate "on" and "off"
--   portions of the stroke.
--   
--   Each "on" segment will have caps applied as if the segment were a
--   separate contour. In particular, it is valid to use an "on" length of
--   0 with <a>LineCapRound</a> or <a>LineCapSquare</a> to draw dots or
--   squares along a path.
--   
--   If <i><tt>nDash</tt></i> is 0, if all elements in <i><tt>dash</tt></i>
--   are 0, or if there are negative values in <i><tt>dash</tt></i>, then
--   dashing is disabled.
--   
--   If <i><tt>nDash</tt></i> is 1, an alternating "on" and "off" pattern
--   with the single dash length provided is assumed.
--   
--   If <i><tt>nDash</tt></i> is uneven, the dash array will be used with
--   the first element in <i><tt>dash</tt></i> defining an "on" or "off" in
--   alternating passes through the array.
--   
--   You can specify a starting offset into the dash with
--   <a>strokeSetDashOffset</a>.
--   
--   <i>Since: 4.14</i>
strokeSetDash :: (HasCallStack, MonadIO m) => Stroke -> Maybe [Float] -> m ()

-- | Sets the offset into the dash pattern where dashing should begin.
--   
--   This is an offset into the length of the path, not an index into the
--   array values of the dash array.
--   
--   See <a>strokeSetDash</a> for more details on dashing.
--   
--   <i>Since: 4.14</i>
strokeSetDashOffset :: (HasCallStack, MonadIO m) => Stroke -> Float -> m ()

-- | Sets the line cap to be used when stroking.
--   
--   See <a>LineCap</a> for details.
--   
--   <i>Since: 4.14</i>
strokeSetLineCap :: (HasCallStack, MonadIO m) => Stroke -> LineCap -> m ()

-- | Sets the line join to be used when stroking.
--   
--   See <a>LineJoin</a> for details.
--   
--   <i>Since: 4.14</i>
strokeSetLineJoin :: (HasCallStack, MonadIO m) => Stroke -> LineJoin -> m ()

-- | Sets the line width to be used when stroking.
--   
--   The line width must be &gt;= 0.
--   
--   <i>Since: 4.14</i>
strokeSetLineWidth :: (HasCallStack, MonadIO m) => Stroke -> Float -> m ()

-- | Sets the miter limit to be used when stroking.
--   
--   The miter limit is the distance from the corner where sharp turns of
--   joins get cut off.
--   
--   The limit is specfied in units of line width and must be non-negative.
--   
--   For joins of type <a>LineJoinMiter</a> that exceed the miter limit,
--   the join gets rendered as if it was of type <a>LineJoinBevel</a>.
--   
--   <i>Since: 4.14</i>
strokeSetMiterLimit :: (HasCallStack, MonadIO m) => Stroke -> Float -> m ()

-- | A helper function that sets the stroke parameters of a cairo context
--   from a <tt>GskStroke</tt>.
--   
--   <i>Since: 4.14</i>
strokeToCairo :: (HasCallStack, MonadIO m) => Stroke -> Context -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.Stroke.Stroke
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.Stroke.Stroke
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.Stroke.Stroke
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.Stroke.Stroke)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.Stroke.Stroke
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.Stroke.Stroke


module GI.Gsk.Callbacks

-- | Type for the callback on the (unwrapped) C side.
type C_ParseErrorFunc = Ptr ParseLocation -> Ptr ParseLocation -> Ptr GError -> Ptr () -> IO ()

-- | Type of callback that is called when an error occurs during node
--   deserialization.
type ParseErrorFunc = ParseLocation -> ParseLocation -> GError -> IO ()

-- | Type of callback that is called when an error occurs during node
--   deserialization.
type ParseErrorFunc_WithClosures = ParseLocation -> ParseLocation -> GError -> Ptr () -> IO ()

-- | A simple wrapper that ignores the closure arguments.
drop_closures_ParseErrorFunc :: ParseErrorFunc -> ParseErrorFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_ParseErrorFunc :: (HasCallStack, MonadIO m) => FunPtr C_ParseErrorFunc -> ParseLocation -> ParseLocation -> GError -> Ptr () -> m ()

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_ParseErrorFunc :: MonadIO m => ParseErrorFunc -> m (GClosure C_ParseErrorFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_ParseErrorFunc</a>.
mk_ParseErrorFunc :: C_ParseErrorFunc -> IO (FunPtr C_ParseErrorFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParseErrorFunc</a></tt>.
noParseErrorFunc :: Maybe ParseErrorFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>ParseErrorFunc_WithClosures</a></tt>.
noParseErrorFunc_WithClosures :: Maybe ParseErrorFunc_WithClosures

-- | Wrap a <a>ParseErrorFunc</a> into a <a>C_ParseErrorFunc</a>.
wrap_ParseErrorFunc :: Maybe (Ptr (FunPtr C_ParseErrorFunc)) -> ParseErrorFunc_WithClosures -> C_ParseErrorFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PathForeachFunc = CUInt -> Ptr Point -> CSize -> CFloat -> Ptr () -> IO CInt

-- | Type of the callback to iterate through the operations of a path.
--   
--   For each operation, the callback is given the <i><tt>op</tt></i>
--   itself, the points that the operation is applied to in
--   <i><tt>pts</tt></i>, and a <i><tt>weight</tt></i> for conic curves.
--   The <i><tt>nPts</tt></i> argument is somewhat redundant, since the
--   number of points can be inferred from the operation.
--   
--   Each contour of the path starts with a <i><tt>gSKPATHMOVE</tt></i>
--   operation. Closed contours end with a <i><tt>gSKPATHCLOSE</tt></i>
--   operation.
type PathForeachFunc = PathOperation -> [Point] -> Float -> IO Bool

-- | Type of the callback to iterate through the operations of a path.
--   
--   For each operation, the callback is given the <i><tt>op</tt></i>
--   itself, the points that the operation is applied to in
--   <i><tt>pts</tt></i>, and a <i><tt>weight</tt></i> for conic curves.
--   The <i><tt>nPts</tt></i> argument is somewhat redundant, since the
--   number of points can be inferred from the operation.
--   
--   Each contour of the path starts with a <i><tt>gSKPATHMOVE</tt></i>
--   operation. Closed contours end with a <i><tt>gSKPATHCLOSE</tt></i>
--   operation.
type PathForeachFunc_WithClosures = PathOperation -> [Point] -> Float -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PathForeachFunc :: PathForeachFunc -> PathForeachFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PathForeachFunc :: (HasCallStack, MonadIO m) => FunPtr C_PathForeachFunc -> PathOperation -> [Point] -> Float -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PathForeachFunc :: MonadIO m => PathForeachFunc -> m (GClosure C_PathForeachFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PathForeachFunc</a>.
mk_PathForeachFunc :: C_PathForeachFunc -> IO (FunPtr C_PathForeachFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PathForeachFunc</a></tt>.
noPathForeachFunc :: Maybe PathForeachFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PathForeachFunc_WithClosures</a></tt>.
noPathForeachFunc_WithClosures :: Maybe PathForeachFunc_WithClosures

-- | Wrap a <a>PathForeachFunc</a> into a <a>C_PathForeachFunc</a>.
wrap_PathForeachFunc :: Maybe (Ptr (FunPtr C_PathForeachFunc)) -> PathForeachFunc_WithClosures -> C_PathForeachFunc

-- | Type for the callback on the (unwrapped) C side.
type C_PathIntersectionFunc = Ptr Path -> Ptr PathPoint -> Ptr Path -> Ptr PathPoint -> CUInt -> Ptr () -> IO CInt

-- | Prototype of the callback to iterate through the intersections of two
--   paths.
--   
--   <i>Since: 4.20</i>
type PathIntersectionFunc = Path -> PathPoint -> Path -> PathPoint -> PathIntersection -> IO Bool

-- | Prototype of the callback to iterate through the intersections of two
--   paths.
--   
--   <i>Since: 4.20</i>
type PathIntersectionFunc_WithClosures = Path -> PathPoint -> Path -> PathPoint -> PathIntersection -> Ptr () -> IO Bool

-- | A simple wrapper that ignores the closure arguments.
drop_closures_PathIntersectionFunc :: PathIntersectionFunc -> PathIntersectionFunc_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_PathIntersectionFunc :: (HasCallStack, MonadIO m) => FunPtr C_PathIntersectionFunc -> Path -> PathPoint -> Path -> PathPoint -> PathIntersection -> Ptr () -> m Bool

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_PathIntersectionFunc :: MonadIO m => PathIntersectionFunc -> m (GClosure C_PathIntersectionFunc)

-- | Generate a function pointer callable from C code, from a
--   <a>C_PathIntersectionFunc</a>.
mk_PathIntersectionFunc :: C_PathIntersectionFunc -> IO (FunPtr C_PathIntersectionFunc)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PathIntersectionFunc</a></tt>.
noPathIntersectionFunc :: Maybe PathIntersectionFunc

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>PathIntersectionFunc_WithClosures</a></tt>.
noPathIntersectionFunc_WithClosures :: Maybe PathIntersectionFunc_WithClosures

-- | Wrap a <a>PathIntersectionFunc</a> into a
--   <a>C_PathIntersectionFunc</a>.
wrap_PathIntersectionFunc :: Maybe (Ptr (FunPtr C_PathIntersectionFunc)) -> PathIntersectionFunc_WithClosures -> C_PathIntersectionFunc

-- | Type for the callback on the (unwrapped) C side.
type C_RenderReplayFontFilter = Ptr RenderReplay -> Ptr Font -> Ptr () -> IO Ptr Font

-- | A function that filters fonts.
--   
--   The function will be called by the default replay function for all
--   nodes with fonts. They will then generate a node using the returned
--   font.
--   
--   It is valid for the function to return the passed in font if the font
--   shuld not be modified.
--   
--   <i>Since: 4.22</i>
type RenderReplayFontFilter = RenderReplay -> Font -> IO Font

-- | A function that filters fonts.
--   
--   The function will be called by the default replay function for all
--   nodes with fonts. They will then generate a node using the returned
--   font.
--   
--   It is valid for the function to return the passed in font if the font
--   shuld not be modified.
--   
--   <i>Since: 4.22</i>
type RenderReplayFontFilter_WithClosures = RenderReplay -> Font -> Ptr () -> IO Font

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RenderReplayFontFilter :: RenderReplayFontFilter -> RenderReplayFontFilter_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RenderReplayFontFilter :: (HasCallStack, MonadIO m, IsFont a) => FunPtr C_RenderReplayFontFilter -> RenderReplay -> a -> Ptr () -> m Font

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RenderReplayFontFilter :: MonadIO m => RenderReplayFontFilter -> m (GClosure C_RenderReplayFontFilter)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RenderReplayFontFilter</a>.
mk_RenderReplayFontFilter :: C_RenderReplayFontFilter -> IO (FunPtr C_RenderReplayFontFilter)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayFontFilter</a></tt>.
noRenderReplayFontFilter :: Maybe RenderReplayFontFilter

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayFontFilter_WithClosures</a></tt>.
noRenderReplayFontFilter_WithClosures :: Maybe RenderReplayFontFilter_WithClosures

-- | Wrap a <a>RenderReplayFontFilter</a> into a
--   <a>C_RenderReplayFontFilter</a>.
wrap_RenderReplayFontFilter :: Maybe (Ptr (FunPtr C_RenderReplayFontFilter)) -> RenderReplayFontFilter_WithClosures -> C_RenderReplayFontFilter

-- | Type for the callback on the (unwrapped) C side.
type C_RenderReplayNodeFilter = Ptr RenderReplay -> Ptr RenderNode -> Ptr () -> IO Ptr RenderNode

-- | A function to replay a node.
--   
--   The node may be returned unmodified.
--   
--   The node may be discarded by returning <a>Nothing</a>.
--   
--   If you do not want to do any handling yourself, call
--   <a>renderReplayDefault</a> to use the default handler that calls your
--   function on the children of the node.
--   
--   <i>Since: 4.22</i>
type RenderReplayNodeFilter = RenderReplay -> RenderNode -> IO Maybe RenderNode

-- | A function to replay a node.
--   
--   The node may be returned unmodified.
--   
--   The node may be discarded by returning <a>Nothing</a>.
--   
--   If you do not want to do any handling yourself, call
--   <a>renderReplayDefault</a> to use the default handler that calls your
--   function on the children of the node.
--   
--   <i>Since: 4.22</i>
type RenderReplayNodeFilter_WithClosures = RenderReplay -> RenderNode -> Ptr () -> IO Maybe RenderNode

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RenderReplayNodeFilter :: RenderReplayNodeFilter -> RenderReplayNodeFilter_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RenderReplayNodeFilter :: (HasCallStack, MonadIO m, IsRenderNode a) => FunPtr C_RenderReplayNodeFilter -> RenderReplay -> a -> Ptr () -> m (Maybe RenderNode)

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RenderReplayNodeFilter :: MonadIO m => RenderReplayNodeFilter -> m (GClosure C_RenderReplayNodeFilter)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RenderReplayNodeFilter</a>.
mk_RenderReplayNodeFilter :: C_RenderReplayNodeFilter -> IO (FunPtr C_RenderReplayNodeFilter)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayNodeFilter</a></tt>.
noRenderReplayNodeFilter :: Maybe RenderReplayNodeFilter

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayNodeFilter_WithClosures</a></tt>.
noRenderReplayNodeFilter_WithClosures :: Maybe RenderReplayNodeFilter_WithClosures

-- | Wrap a <a>RenderReplayNodeFilter</a> into a
--   <a>C_RenderReplayNodeFilter</a>.
wrap_RenderReplayNodeFilter :: Maybe (Ptr (FunPtr C_RenderReplayNodeFilter)) -> RenderReplayNodeFilter_WithClosures -> C_RenderReplayNodeFilter

-- | Type for the callback on the (unwrapped) C side.
type C_RenderReplayTextureFilter = Ptr RenderReplay -> Ptr Texture -> Ptr () -> IO Ptr Texture

-- | A function that filters textures.
--   
--   The function will be called by the default replay function for all
--   nodes with textures. They will then generate a node using the returned
--   texture.
--   
--   It is valid for the function to return the passed in texture if the
--   texture shuld not be modified.
--   
--   <i>Since: 4.22</i>
type RenderReplayTextureFilter = RenderReplay -> Texture -> IO Texture

-- | A function that filters textures.
--   
--   The function will be called by the default replay function for all
--   nodes with textures. They will then generate a node using the returned
--   texture.
--   
--   It is valid for the function to return the passed in texture if the
--   texture shuld not be modified.
--   
--   <i>Since: 4.22</i>
type RenderReplayTextureFilter_WithClosures = RenderReplay -> Texture -> Ptr () -> IO Texture

-- | A simple wrapper that ignores the closure arguments.
drop_closures_RenderReplayTextureFilter :: RenderReplayTextureFilter -> RenderReplayTextureFilter_WithClosures

-- | Given a pointer to a foreign C function, wrap it into a function
--   callable from Haskell.
dynamic_RenderReplayTextureFilter :: (HasCallStack, MonadIO m, IsTexture a) => FunPtr C_RenderReplayTextureFilter -> RenderReplay -> a -> Ptr () -> m Texture

-- | Wrap the callback into a <a>GClosure</a>.
genClosure_RenderReplayTextureFilter :: MonadIO m => RenderReplayTextureFilter -> m (GClosure C_RenderReplayTextureFilter)

-- | Generate a function pointer callable from C code, from a
--   <a>C_RenderReplayTextureFilter</a>.
mk_RenderReplayTextureFilter :: C_RenderReplayTextureFilter -> IO (FunPtr C_RenderReplayTextureFilter)

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayTextureFilter</a></tt>.
noRenderReplayTextureFilter :: Maybe RenderReplayTextureFilter

-- | A convenience synonym for <tt><a>Nothing</a> :: <a>Maybe</a>
--   <a>RenderReplayTextureFilter_WithClosures</a></tt>.
noRenderReplayTextureFilter_WithClosures :: Maybe RenderReplayTextureFilter_WithClosures

-- | Wrap a <a>RenderReplayTextureFilter</a> into a
--   <a>C_RenderReplayTextureFilter</a>.
wrap_RenderReplayTextureFilter :: Maybe (Ptr (FunPtr C_RenderReplayTextureFilter)) -> RenderReplayTextureFilter_WithClosures -> C_RenderReplayTextureFilter


-- | Builds the uniforms data for a <tt>GskGLShader</tt>.
module GI.Gsk.Structs.ShaderArgsBuilder

-- | Memory-managed wrapper type.
newtype ShaderArgsBuilder
ShaderArgsBuilder :: ManagedPtr ShaderArgsBuilder -> ShaderArgsBuilder

-- | Allocates a builder that can be used to construct a new uniform data
--   chunk.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderNew :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Maybe Bytes -> m ShaderArgsBuilder

-- | Increases the reference count of a <tt>GskShaderArgsBuilder</tt> by
--   one.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderRef :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> m ShaderArgsBuilder

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of bool type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetBool :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Bool -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of float type.
shaderArgsBuilderSetFloat :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Float -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of int type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetInt :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Int32 -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of uint type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetUint :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Word32 -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of vec2 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetVec2 :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Vec2 -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of vec3 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetVec3 :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Vec3 -> m ()

-- | Sets the value of the uniform <i><tt>idx</tt></i>.
--   
--   The uniform must be of vec4 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderSetVec4 :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> Int32 -> Vec4 -> m ()

-- | Creates a new <tt>GBytes</tt> args from the current state of the given
--   <i><tt>builder</tt></i>.
--   
--   Any uniforms of the shader that have not been explicitly set on the
--   <i><tt>builder</tt></i> are zero-initialized.
--   
--   The given <tt>GskShaderArgsBuilder</tt> is reset once this function
--   returns; you cannot call this function multiple times on the same
--   <i><tt>builder</tt></i> instance.
--   
--   This function is intended primarily for bindings. C code should use
--   <a>ShaderArgsBuilder</a>.<tt><i>free_to_args</i></tt>().

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderToArgs :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> m Bytes

-- | Decreases the reference count of a <tt>GskShaderArgBuilder</tt> by
--   one.
--   
--   If the resulting reference count is zero, frees the builder.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
shaderArgsBuilderUnref :: (HasCallStack, MonadIO m) => ShaderArgsBuilder -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.ShaderArgsBuilder.ShaderArgsBuilder


-- | A facility to replay a <a>RenderNode</a> and its children, potentially
--   modifying them.
--   
--   This is a utility tool to walk a rendernode tree. The most powerful
--   way is to provide a function via <a>renderReplaySetNodeFilter</a> to
--   filter each individual node and then run <a>renderReplayFilterNode</a>
--   on the nodes you want to filter.
--   
--   If you want to just walk the node tree and extract information without
--   any modifications, you can also use <a>renderNodeGetChildren</a>.
--   
--   Here is a little example application that redacts text in a node file:
--   
--   <pre>
--   #include &lt;gtk/gtk.h&gt;
--   
--   static GskRenderNode *
--   redact_nodes (GskRenderReplay *replay,
--                 GskRenderNode   *node,
--                 gpointer         user_data)
--   {
--     GskRenderNode *result;
--   
--     if (gsk_render_node_get_node_type (node) == GSK_TEXT_NODE)
--       {
--         graphene_rect_t bounds;
--         const GdkRGBA *color;
--   
--         gsk_render_node_get_bounds (node, &amp;bounds);
--         color = gsk_text_node_get_color (node);
--   
--         result = gsk_color_node_new (color, &amp;bounds);
--       }
--     else
--       {
--         result = gsk_render_replay_default (replay, node);
--       }
--   
--     return result;
--   }
--   
--   int
--   main (int argc, char *argv[])
--   {
--     GFile *file;
--     GBytes *bytes;
--     GskRenderNode *result, *node;
--     GskRenderReplay *replay;
--   
--     gtk_init ();
--   
--     if (argc != 3)
--       {
--         g_print ("usage: %s INFILE OUTFILE\n", argv[0]);
--         return 0;
--       }
--   
--     file = g_file_new_for_commandline_arg (argv[1]);
--     bytes = g_file_load_bytes (file, NULL, NULL, NULL);
--     g_object_unref (file);
--     if (bytes == NULL)
--       return 1;
--   
--     node = gsk_render_node_deserialize (bytes, NULL, NULL);
--     g_bytes_unref (bytes);
--     if (node == NULL)
--       return 1;
--   
--     replay = gsk_render_replay_new ();
--     gsk_render_replay_set_node_filter (replay, redact_nodes, NULL, NULL);
--     result = gsk_render_replay_filter_node (replay, node);
--     gsk_render_replay_free (replay);
--   
--     if (!gsk_render_node_write_to_file (result, argv[2], NULL))
--       return 1;
--   
--     gsk_render_node_unref (result);
--     gsk_render_node_unref (node);
--   
--     return 0;
--   }
--   </pre>
--   
--   <i>Since: 4.22</i>
module GI.Gsk.Structs.RenderReplay

-- | Memory-managed wrapper type.
newtype RenderReplay
RenderReplay :: ManagedPtr RenderReplay -> RenderReplay

-- | Replays the node using the default method.
--   
--   The default method calls <a>renderReplayFilterNode</a> on all its
--   child nodes and the filter functions for all its properties. If none
--   of them are changed, it returns the passed in node. Otherwise it
--   constructs a new node with the changed children and properties.
--   
--   It may not be possible to construct a new node when any of the
--   callbacks return NULL. In that case, this function will return NULL,
--   too.
--   
--   <i>Since: 4.22</i>
renderReplayDefault :: (HasCallStack, MonadIO m, IsRenderNode a) => RenderReplay -> a -> m (Maybe RenderNode)

-- | Filters a font using the current filter function.
--   
--   <i>Since: 4.22</i>
renderReplayFilterFont :: (HasCallStack, MonadIO m, IsFont a) => RenderReplay -> a -> m Font

-- | Replays a node using the replay's filter function.
--   
--   After the replay the node may be unchanged, or it may be removed,
--   which will result in <a>Nothing</a> being returned.
--   
--   If no filter node is set, <a>renderReplayDefault</a> is called
--   instead.
--   
--   <i>Since: 4.22</i>
renderReplayFilterNode :: (HasCallStack, MonadIO m, IsRenderNode a) => RenderReplay -> a -> m (Maybe RenderNode)

-- | Filters a texture using the current filter function.
--   
--   <i>Since: 4.22</i>
renderReplayFilterTexture :: (HasCallStack, MonadIO m, IsTexture a) => RenderReplay -> a -> m Texture

-- | Frees a <tt>GskRenderReplay</tt>.
--   
--   <i>Since: 4.22</i>
renderReplayFree :: (HasCallStack, MonadIO m) => RenderReplay -> m ()

-- | Creates a new replay object to replay nodes.
--   
--   <i>Since: 4.22</i>
renderReplayNew :: (HasCallStack, MonadIO m) => m RenderReplay

-- | Sets a filter function to be called by <a>renderReplayDefault</a> for
--   nodes that contain fonts.
--   
--   You can call [method<i><tt>gskRenderReplay</tt></i>.filter_font] to
--   filter a font yourself.
--   
--   <i>Since: 4.22</i>
renderReplaySetFontFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayFontFilter -> m ()

-- | Sets the function to use as a node filter.
--   
--   This is the most complex function to use for replaying nodes. It can
--   either:
--   
--   <ul>
--   <li>keep the node and just return it unchanged</li>
--   <li>create a replacement node and return that</li>
--   <li>discard the node by returning <tt>NULL</tt></li>
--   <li>call <a>renderReplayDefault</a> to have the default handler run
--   for this node, which calls your function on its children</li>
--   </ul>
--   
--   <i>Since: 4.22</i>
renderReplaySetNodeFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayNodeFilter -> m ()

-- | Sets a filter function to be called by <a>renderReplayDefault</a> for
--   nodes that contain textures.
--   
--   You can call [method<i><tt>gskRenderReplay</tt></i>.filter_texture] to
--   filter a texture yourself.
--   
--   <i>Since: 4.22</i>
renderReplaySetTextureFilter :: (HasCallStack, MonadIO m) => RenderReplay -> Maybe RenderReplayTextureFilter -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Structs.RenderReplay.RenderReplay
instance GHC.Classes.Eq GI.Gsk.Structs.RenderReplay.RenderReplay
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.RenderReplay.RenderReplay


-- | Represents a point on a path.
--   
--   It can be queried for properties of the path at that point, such as
--   its tangent or its curvature.
--   
--   To obtain a <tt>GskPathPoint</tt>, use <a>pathGetClosestPoint</a>,
--   <a>pathGetStartPoint</a>, <a>pathGetEndPoint</a> or
--   <a>pathMeasureGetPoint</a>.
--   
--   Note that <tt>GskPathPoint</tt> structs are meant to be
--   stack-allocated, and don't hold a reference to the path object they
--   are obtained from. It is the callers responsibility to keep a
--   reference to the path as long as the <tt>GskPathPoint</tt> is used.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Structs.PathPoint

-- | Memory-managed wrapper type.
newtype PathPoint
PathPoint :: ManagedPtr PathPoint -> PathPoint

-- | Returns whether <i><tt>point1</tt></i> is before or after
--   <i><tt>point2</tt></i>.
--   
--   <i>Since: 4.14</i>
pathPointCompare :: (HasCallStack, MonadIO m) => PathPoint -> PathPoint -> m Int32

-- | Copies a path point.
--   
--   <i>Since: 4.14</i>
pathPointCopy :: (HasCallStack, MonadIO m) => PathPoint -> m PathPoint

-- | Returns whether the two path points refer to the same location on all
--   paths.
--   
--   Note that the start- and endpoint of a closed contour will compare
--   nonequal according to this definition. Use <a>pathIsClosed</a> to find
--   out if the start- and endpoint of a concrete path refer to the same
--   location.
--   
--   <i>Since: 4.14</i>
pathPointEqual :: (HasCallStack, MonadIO m) => PathPoint -> PathPoint -> m Bool

-- | Frees a path point copied by <a>pathPointCopy</a>.
--   
--   <i>Since: 4.14</i>
pathPointFree :: (HasCallStack, MonadIO m) => PathPoint -> m ()

-- | Calculates the curvature of the path at the point.
--   
--   Optionally, returns the center of the osculating circle as well. The
--   curvature is the inverse of the radius of the osculating circle.
--   
--   Lines have a curvature of zero (indicating an osculating circle of
--   infinite radius). In this case, the <i><tt>center</tt></i> is not
--   modified.
--   
--   Circles with a radius of zero have <tt>INFINITY</tt> as curvature
--   
--   Note that certain points on a path may not have a single curvature,
--   such as sharp turns. At such points, there are two curvatures — the
--   (limit of) the curvature of the path going into the point, and the
--   (limit of) the curvature of the path coming out of it. The
--   <i><tt>direction</tt></i> argument lets you choose which one to get.
--   
--   &lt;picture&gt; &lt;source srcset="curvature-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Osculating
--   circle" src="curvature-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathPointGetCurvature :: (HasCallStack, MonadIO m) => PathPoint -> Path -> PathDirection -> m (Float, Maybe Point)

-- | Returns the distance from the beginning of the path to the point.
--   
--   <i>Since: 4.14</i>
pathPointGetDistance :: (HasCallStack, MonadIO m) => PathPoint -> PathMeasure -> m Float

-- | Gets the position of the point.
--   
--   <i>Since: 4.14</i>
pathPointGetPosition :: (HasCallStack, MonadIO m) => PathPoint -> Path -> m Point

-- | Gets the direction of the tangent at a given point.
--   
--   This is a convenience variant of <a>pathPointGetTangent</a> that
--   returns the angle between the tangent and the X axis. The angle can
--   e.g. be used in <a>gtk_snapshot_rotate()</a>.
--   
--   <i>Since: 4.14</i>
pathPointGetRotation :: (HasCallStack, MonadIO m) => PathPoint -> Path -> PathDirection -> m Float

-- | Gets the tangent of the path at the point.
--   
--   Note that certain points on a path may not have a single tangent, such
--   as sharp turns. At such points, there are two tangents — the direction
--   of the path going into the point, and the direction coming out of it.
--   The <i><tt>direction</tt></i> argument lets you choose which one to
--   get.
--   
--   If the path is just a single point (e.g. a circle with radius zero),
--   then the tangent is set to <tt>0, 0</tt>.
--   
--   If you want to orient something in the direction of the path,
--   <a>pathPointGetRotation</a> may be more convenient to use.
--   
--   <i>Since: 4.14</i>
pathPointGetTangent :: (HasCallStack, MonadIO m) => PathPoint -> Path -> PathDirection -> m Vec2
instance GHC.Classes.Eq GI.Gsk.Structs.PathPoint.PathPoint
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.PathPoint.PathPoint
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.PathPoint.PathPoint
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.PathPoint.PathPoint)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.PathPoint.PathPoint
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.PathPoint.PathPoint


-- | Performs measurements on paths such as determining the length of the
--   path.
--   
--   Many measuring operations require sampling the path length at
--   intermediate points. Therefore, a <tt>GskPathMeasure</tt> has a
--   tolerance that determines what precision is required for such
--   approximations.
--   
--   A <tt>GskPathMeasure</tt> struct is a reference counted struct and
--   should be treated as opaque.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Structs.PathMeasure

-- | Memory-managed wrapper type.
newtype PathMeasure
PathMeasure :: ManagedPtr PathMeasure -> PathMeasure

-- | Gets the length of the path being measured.
--   
--   The length is cached, so this function does not do any work.
--   
--   <i>Since: 4.14</i>
pathMeasureGetLength :: (HasCallStack, MonadIO m) => PathMeasure -> m Float

-- | Returns the path that the measure was created for.
--   
--   <i>Since: 4.14</i>
pathMeasureGetPath :: (HasCallStack, MonadIO m) => PathMeasure -> m Path

-- | Returns the tolerance that the measure was created with.
--   
--   <i>Since: 4.14</i>
pathMeasureGetTolerance :: (HasCallStack, MonadIO m) => PathMeasure -> m Float

-- | Creates a measure object for the given <i><tt>path</tt></i> with the
--   default tolerance.
--   
--   <i>Since: 4.14</i>
pathMeasureNew :: (HasCallStack, MonadIO m) => Path -> m PathMeasure

-- | Creates a measure object for the given <i><tt>path</tt></i> and
--   <i><tt>tolerance</tt></i>.
--   
--   <i>Since: 4.14</i>
pathMeasureNewWithTolerance :: (HasCallStack, MonadIO m) => Path -> Float -> m PathMeasure

-- | Increases the reference count of a <tt>GskPathMeasure</tt> by one.
--   
--   <i>Since: 4.14</i>
pathMeasureRef :: (HasCallStack, MonadIO m) => PathMeasure -> m PathMeasure

-- | Decreases the reference count of a <tt>GskPathMeasure</tt> by one.
--   
--   If the resulting reference count is zero, frees the object.
--   
--   <i>Since: 4.14</i>
pathMeasureUnref :: (HasCallStack, MonadIO m) => PathMeasure -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.PathMeasure.PathMeasure
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.PathMeasure.PathMeasure
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.PathMeasure.PathMeasure
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.PathMeasure.PathMeasure)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.PathMeasure.PathMeasure
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.PathMeasure.PathMeasure


-- | Constructs <tt>GskPath</tt> objects.
--   
--   A path is constructed like this:
--   
--   <h3><i>c code</i></h3>
--   
--   <pre>
--   GskPath *
--   construct_path (void)
--   {
--     GskPathBuilder *builder;
--   
--     builder = gsk_path_builder_new ();
--   
--     // add contours to the path here
--   
--     return gsk_path_builder_free_to_path (builder);
--   </pre>
--   
--   Adding contours to the path can be done in two ways. The easiest
--   option is to use the <tt>gsk_path_builder_add_*</tt> group of
--   functions that add predefined contours to the current path, either
--   common shapes like <a>pathBuilderAddCircle</a> or by adding from other
--   paths like <a>pathBuilderAddPath</a>.
--   
--   The <tt>gsk_path_builder_add_*</tt> methods always add complete
--   contours, and do not use or modify the current point.
--   
--   The other option is to define each line and curve manually with the
--   <tt>gsk_path_builder_*_to</tt> group of functions. You start with a
--   call to <a>pathBuilderMoveTo</a> to set the starting point and then
--   use multiple calls to any of the drawing functions to move the pen
--   along the plane. Once you are done, you can call
--   <a>pathBuilderClose</a> to close the path by connecting it back with a
--   line to the starting point.
--   
--   This is similar to how paths are drawn in Cairo.
--   
--   Note that <tt>GskPathBuilder</tt> will reduce the degree of added
--   Bézier curves as much as possible, to simplify rendering.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Structs.PathBuilder

-- | Memory-managed wrapper type.
newtype PathBuilder
PathBuilder :: ManagedPtr PathBuilder -> PathBuilder

-- | Adds a Cairo path to the builder.
--   
--   You can use <tt><i>cairo_copy_path()</i></tt> to access the path from
--   a Cairo context.
--   
--   <i>Since: 4.14</i>
pathBuilderAddCairoPath :: (HasCallStack, MonadIO m) => PathBuilder -> Path -> m ()

-- | Adds a circle as a new contour.
--   
--   The path is going around the circle in clockwise direction.
--   
--   If <i><tt>radius</tt></i> is zero, the contour will be a closed point.
--   
--   <i>Since: 4.14</i>
pathBuilderAddCircle :: (HasCallStack, MonadIO m) => PathBuilder -> Point -> Float -> m ()

-- | Adds the outlines for the glyphs in <i><tt>layout</tt></i> to the
--   builder.
--   
--   <i>Since: 4.14</i>
pathBuilderAddLayout :: (HasCallStack, MonadIO m, IsLayout a) => PathBuilder -> a -> m ()

-- | Appends all of <i><tt>path</tt></i> to the builder.
--   
--   <i>Since: 4.14</i>
pathBuilderAddPath :: (HasCallStack, MonadIO m) => PathBuilder -> Path -> m ()

-- | Adds a rectangle as a new contour.
--   
--   The path is going around the rectangle in clockwise direction.
--   
--   If the the width or height are 0, the path will be a closed horizontal
--   or vertical line. If both are 0, it'll be a closed dot.
--   
--   <i>Since: 4.14</i>
pathBuilderAddRect :: (HasCallStack, MonadIO m) => PathBuilder -> Rect -> m ()

-- | Appends all of <i><tt>path</tt></i> to the builder, in reverse order.
--   
--   <i>Since: 4.14</i>
pathBuilderAddReversePath :: (HasCallStack, MonadIO m) => PathBuilder -> Path -> m ()

-- | Adds a rounded rectangle as a new contour.
--   
--   The path is going around the rectangle in clockwise direction.
--   
--   <i>Since: 4.14</i>
pathBuilderAddRoundedRect :: (HasCallStack, MonadIO m) => PathBuilder -> RoundedRect -> m ()

-- | Adds a segment of a path to the builder.
--   
--   If <i><tt>start</tt></i> is equal to or after <i><tt>end</tt></i>, the
--   path will first add the segment from <i><tt>start</tt></i> to the end
--   of the path, and then add the segment from the beginning to
--   <i><tt>end</tt></i>. If the path is closed, these segments will be
--   connected.
--   
--   Note that this method always adds a path with the given start point
--   and end point. To add a closed path, use <a>pathBuilderAddPath</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderAddSegment :: (HasCallStack, MonadIO m) => PathBuilder -> Path -> PathPoint -> PathPoint -> m ()

-- | Adds an elliptical arc from the current point to <i><tt>x2</tt></i>,
--   <i><tt>y2</tt></i> with <i><tt>x1</tt></i>, <i><tt>y1</tt></i>
--   determining the tangent directions.
--   
--   After this, <i><tt>x2</tt></i>, <i><tt>y2</tt></i> will be the new
--   current point.
--   
--   Note: Two points and their tangents do not determine a unique ellipse,
--   so GSK just picks one. If you need more precise control, use
--   <a>pathBuilderConicTo</a> or <a>pathBuilderSvgArcTo</a>.
--   
--   &lt;picture&gt; &lt;source srcset="arc-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Arc To"
--   src="arc-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathBuilderArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> m ()

-- | Ends the current contour with a line back to the start point.
--   
--   Note that this is different from calling <a>pathBuilderLineTo</a> with
--   the start point in that the contour will be closed. A closed contour
--   behaves differently from an open one. When stroking, its start and end
--   point are considered connected, so they will be joined via the line
--   join, and not ended with line caps.
--   
--   <i>Since: 4.14</i>
pathBuilderClose :: (HasCallStack, MonadIO m) => PathBuilder -> m ()

-- | Adds a <a>conic curve</a> from the current point to
--   <i><tt>x2</tt></i>, <i><tt>y2</tt></i> with the given
--   <i><tt>weight</tt></i> and <i><tt>x1</tt></i>, <i><tt>y1</tt></i> as
--   the control point.
--   
--   The weight determines how strongly the curve is pulled towards the
--   control point. A conic with weight 1 is identical to a quadratic
--   Bézier curve with the same points.
--   
--   Conic curves can be used to draw ellipses and circles. They are also
--   known as rational quadratic Bézier curves.
--   
--   After this, <i><tt>x2</tt></i>, <i><tt>y2</tt></i> will be the new
--   current point.
--   
--   &lt;picture&gt; &lt;source srcset="conic-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Conic To"
--   src="conic-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathBuilderConicTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Adds a <a>cubic Bézier curve</a> from the current point to
--   <i><tt>x3</tt></i>, <i><tt>y3</tt></i> with <i><tt>x1</tt></i>,
--   <i><tt>y1</tt></i> and <i><tt>x2</tt></i>, <i><tt>y2</tt></i> as the
--   control points.
--   
--   After this, <i><tt>x3</tt></i>, <i><tt>y3</tt></i> will be the new
--   current point.
--   
--   &lt;picture&gt; &lt;source srcset="cubic-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Cubic To"
--   src="cubic-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathBuilderCubicTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Gets the current point.
--   
--   The current point is used for relative drawing commands and updated
--   after every operation.
--   
--   When the builder is created, the default current point is set to
--   <tt>0, 0</tt>. Note that this is different from cairo, which starts
--   out without a current point.
--   
--   <i>Since: 4.14</i>
pathBuilderGetCurrentPoint :: (HasCallStack, MonadIO m) => PathBuilder -> m Point

-- | Implements arc-to according to the HTML Canvas spec.
--   
--   A convenience function that implements the <a>HTML arc_to</a>
--   functionality.
--   
--   After this, the current point will be the point where the circle with
--   the given radius touches the line from <i><tt>x1</tt></i>,
--   <i><tt>y1</tt></i> to <i><tt>x2</tt></i>, <i><tt>y2</tt></i>.
--   
--   <i>Since: 4.14</i>
pathBuilderHtmlArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Draws a line from the current point to <i><tt>x</tt></i>,
--   <i><tt>y</tt></i> and makes it the new current point.
--   
--   &lt;picture&gt; &lt;source srcset="line-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Line To"
--   src="line-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathBuilderLineTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> m ()

-- | Starts a new contour by placing the pen at <i><tt>x</tt></i>,
--   <i><tt>y</tt></i>.
--   
--   If this function is called twice in succession, the first call will
--   result in a contour made up of a single point. The second call will
--   start a new contour.
--   
--   <i>Since: 4.14</i>
pathBuilderMoveTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> m ()

-- | Create a new <tt>GskPathBuilder</tt> object.
--   
--   The resulting builder would create an empty <tt>GskPath</tt>. Use
--   addition functions to add types to it.
--   
--   <i>Since: 4.14</i>
pathBuilderNew :: (HasCallStack, MonadIO m) => m PathBuilder

-- | Adds a <a>quadratic Bézier curve</a> from the current point to
--   <i><tt>x2</tt></i>, <i><tt>y2</tt></i> with <i><tt>x1</tt></i>,
--   <i><tt>y1</tt></i> as the control point.
--   
--   After this, <i><tt>x2</tt></i>, <i><tt>y2</tt></i> will be the new
--   current point.
--   
--   &lt;picture&gt; &lt;source srcset="quad-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="Quad To"
--   src="quad-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
pathBuilderQuadTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> m ()

-- | Acquires a reference on the given builder.
--   
--   This function is intended primarily for language bindings.
--   <tt>GskPathBuilder</tt> objects should not be kept around.
--   
--   <i>Since: 4.14</i>
pathBuilderRef :: (HasCallStack, MonadIO m) => PathBuilder -> m PathBuilder

-- | Adds an elliptical arc from the current point to <i><tt>x2</tt></i>,
--   <i><tt>y2</tt></i> with <i><tt>x1</tt></i>, <i><tt>y1</tt></i>
--   determining the tangent directions.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderArcTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> m ()

-- | Adds a <a>conic curve</a> from the current point to
--   <i><tt>x2</tt></i>, <i><tt>y2</tt></i> with the given
--   <i><tt>weight</tt></i> and <i><tt>x1</tt></i>, <i><tt>y1</tt></i> as
--   the control point.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderConicTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelConicTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Adds a <a>cubic Bézier curve</a> from the current point to
--   <i><tt>x3</tt></i>, <i><tt>y3</tt></i> with <i><tt>x1</tt></i>,
--   <i><tt>y1</tt></i> and <i><tt>x2</tt></i>, <i><tt>y2</tt></i> as the
--   control points.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderCubicTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelCubicTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Implements arc-to according to the HTML Canvas spec.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderHtmlArcTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelHtmlArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> Float -> m ()

-- | Draws a line from the current point to a point offset from it by
--   <i><tt>x</tt></i>, <i><tt>y</tt></i> and makes it the new current
--   point.
--   
--   This is the relative version of <a>pathBuilderLineTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelLineTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> m ()

-- | Starts a new contour by placing the pen at <i><tt>x</tt></i>,
--   <i><tt>y</tt></i> relative to the current point.
--   
--   This is the relative version of <a>pathBuilderMoveTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelMoveTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> m ()

-- | Adds a <a>quadratic Bézier curve</a> from the current point to
--   <i><tt>x2</tt></i>, <i><tt>y2</tt></i> with <i><tt>x1</tt></i>,
--   <i><tt>y1</tt></i> the control point.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderQuadTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelQuadTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Float -> m ()

-- | Implements arc-to according to the SVG spec.
--   
--   All coordinates are given relative to the current point.
--   
--   This is the relative version of <a>pathBuilderSvgArcTo</a>.
--   
--   <i>Since: 4.14</i>
pathBuilderRelSvgArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Bool -> Bool -> Float -> Float -> m ()

-- | Implements arc-to according to the SVG spec.
--   
--   A convenience function that implements the <a>SVG arc_to</a>
--   functionality.
--   
--   After this, <i><tt>x</tt></i>, <i><tt>y</tt></i> will be the new
--   current point.
--   
--   <i>Since: 4.14</i>
pathBuilderSvgArcTo :: (HasCallStack, MonadIO m) => PathBuilder -> Float -> Float -> Float -> Bool -> Bool -> Float -> Float -> m ()

-- | Creates a new path from the given builder.
--   
--   The given <tt>GskPathBuilder</tt> is reset to the initial state once
--   this function returns. Calling this function again on the same builder
--   instance will therefore produce an empty path, not a copy of the same
--   path.
--   
--   This function is intended primarily for language bindings. C code
--   should use <a>PathBuilder</a>.<tt><i>free_to_path</i></tt>().
--   
--   <i>Since: 4.14</i>
pathBuilderToPath :: (HasCallStack, MonadIO m) => PathBuilder -> m Path

-- | Releases a reference on the given builder.
--   
--   <i>Since: 4.14</i>
pathBuilderUnref :: (HasCallStack, MonadIO m) => PathBuilder -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.PathBuilder.PathBuilder
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.PathBuilder.PathBuilder
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.PathBuilder.PathBuilder
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.PathBuilder.PathBuilder)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.PathBuilder.PathBuilder
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.PathBuilder.PathBuilder


-- | 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).
--   
--   <tt>GskPath</tt> is an immutable, opaque, reference-counted struct.
--   After creation, you cannot change the types it represents. Instead,
--   new <tt>GskPath</tt> objects have to be created. The
--   <a>PathBuilder</a> 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.
--   
--   &lt;picture&gt; &lt;source srcset="path-dark.png"
--   media="(prefers-color-scheme: dark)"&gt; &lt;img alt="A Path"
--   src="path-light.png"&gt; &lt;/picture&gt;
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Structs.Path

-- | Memory-managed wrapper type.
newtype Path
Path :: ManagedPtr Path -> Path

-- | Returns whether two paths have identical structure.
--   
--   Note that it is possible to construct paths that render identical even
--   though they don't have the same structure.
--   
--   <i>Since: 4.22</i>
pathEqual :: (HasCallStack, MonadIO m) => Path -> Path -> m Bool

-- | Calls <i><tt>func</tt></i> for every operation of the path.
--   
--   Note that this may only approximate <i><tt>self</tt></i>, because
--   paths can contain optimizations for various specialized contours, and
--   depending on the <i><tt>flags</tt></i>, the path may be decomposed
--   into simpler curves than the ones that it contained originally.
--   
--   This function serves two purposes:
--   
--   <ul>
--   <li>When the <i><tt>flags</tt></i> allow everything, it provides
--   access to the raw, unmodified data of the path.</li>
--   <li>When the <i><tt>flags</tt></i> disallow certain operations, it
--   provides an approximation of the path using just the allowed
--   operations.</li>
--   </ul>
--   
--   <i>Since: 4.14</i>
pathForeach :: (HasCallStack, MonadIO m) => Path -> [PathForeachFlags] -> PathForeachFunc -> m Bool

-- | Finds intersections between two paths.
--   
--   This function finds intersections between <i><tt>path1</tt></i> and
--   <i><tt>path2</tt></i>, and calls <i><tt>func</tt></i> for each of
--   them, in increasing order for <i><tt>path1</tt></i>.
--   
--   If <i><tt>path2</tt></i> is not provided or equal to
--   <i><tt>path1</tt></i>, the function finds non-trivial
--   self-intersections of <i><tt>path1</tt></i>.
--   
--   When segments of the paths coincide, the callback is called once for
--   the start of the segment, with
--   <i><tt>gSKPATHINTERSECTIONSTART</tt></i>, and once for the end of the
--   segment, with <i><tt>gSKPATHINTERSECTIONEND</tt></i>. Note that other
--   intersections may occur between the start and end of such a segment.
--   
--   If <i><tt>func</tt></i> returns <tt>FALSE</tt>, the iteration is
--   stopped.
--   
--   <i>Since: 4.20</i>
pathForeachIntersection :: (HasCallStack, MonadIO m) => Path -> Maybe Path -> PathIntersectionFunc -> m Bool

-- | 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. For accurate bounds, use <a>pathGetTightBounds</a>.
--   
--   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 <i><tt>bounds</tt></i> are
--   set to <a>rectZero</a>. This is different from the case where the path
--   is a single point at the origin, where the <i><tt>bounds</tt></i> will
--   also be set to the zero rectangle but true will be returned.
--   
--   <i>Since: 4.14</i>
pathGetBounds :: (HasCallStack, MonadIO m) => Path -> m (Bool, Rect)

-- | 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.
--   
--   <i>Since: 4.14</i>
pathGetStrokeBounds :: (HasCallStack, MonadIO m) => Path -> Stroke -> m (Bool, Rect)

-- | Computes the tight bounds of the given path.
--   
--   This function works harder than <a>pathGetBounds</a> to produce the
--   smallest possible bounds.
--   
--   <i>Since: 4.22</i>
pathGetTightBounds :: (HasCallStack, MonadIO m) => Path -> m (Bool, Rect)

-- | Returns whether a point is inside the fill area of a path.
--   
--   Note that this function assumes that filling a contour implicitly
--   closes it.
--   
--   <i>Since: 4.14</i>
pathInFill :: (HasCallStack, MonadIO m) => Path -> Point -> FillRule -> m Bool

-- | Returns if the path represents a single closed contour.
--   
--   <i>Since: 4.14</i>
pathIsClosed :: (HasCallStack, MonadIO m) => Path -> m Bool

-- | Checks if the path is empty, i.e. contains no lines or curves.
--   
--   <i>Since: 4.14</i>
pathIsEmpty :: (HasCallStack, MonadIO m) => Path -> m Bool

-- | Constructs a path from a serialized form.
--   
--   The string is expected to be in (a superset of) <a>SVG path
--   syntax</a>, as e.g. produced by <a>pathToString</a>.
--   
--   A high-level summary of the syntax:
--   
--   <ul>
--   <li><tt>M x y</tt> Move to <tt>(x, y)</tt></li>
--   <li><tt>L x y</tt> Add a line from the current point to <tt>(x,
--   y)</tt></li>
--   <li><tt>Q x1 y1 x2 y2</tt> Add a quadratic Bézier from the current
--   point to <tt>(x2, y2)</tt>, with control point <tt>(x1, y1)</tt></li>
--   <li><tt>C x1 y1 x2 y2 x3 y3</tt> Add a cubic Bézier from the current
--   point to <tt>(x3, y3)</tt>, with control points <tt>(x1, y1)</tt> and
--   <tt>(x2, y2)</tt></li>
--   <li><tt>Z</tt> Close the contour by drawing a line back to the start
--   point</li>
--   <li><tt>H x</tt> Add a horizontal line from the current point to the
--   given x value</li>
--   <li><tt>V y</tt> Add a vertical line from the current point to the
--   given y value</li>
--   <li><tt>T x2 y2</tt> Add a quadratic Bézier, using the reflection of
--   the previous segments' control point as control point</li>
--   <li><tt>S x2 y2 x3 y3</tt> Add a cubic Bézier, using the reflection of
--   the previous segments' second control point as first control
--   point</li>
--   <li><tt>A rx ry r l s x y</tt> Add an elliptical arc from the current
--   point to <tt>(x, y)</tt> with radii rx and ry. See the SVG
--   documentation for how the other parameters influence the arc.</li>
--   <li><tt>O x1 y1 x2 y2 w</tt> Add a rational quadratic Bézier from the
--   current point to <tt>(x2, y2)</tt> with control point <tt>(x1,
--   y1)</tt> and weight <tt>w</tt>.</li>
--   </ul>
--   
--   All the commands have lowercase variants that interpret coordinates
--   relative to the current point.
--   
--   The <tt>O</tt> command is an extension that is not supported in SVG.
--   
--   <i>Since: 4.14</i>
pathParse :: (HasCallStack, MonadIO m) => Text -> m (Maybe Path)

-- | Converts the path into a human-readable representation.
--   
--   The string is compatible with (a superset of) <a>SVG path syntax</a>,
--   see <a>pathParse</a> for a summary of the syntax.
--   
--   <i>Since: 4.14</i>
pathPrint :: (HasCallStack, MonadIO m) => Path -> String -> m ()

-- | Increases the reference count of a path by one.
--   
--   <i>Since: 4.14</i>
pathRef :: (HasCallStack, MonadIO m) => Path -> m Path

-- | 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 <tt>GskPath</tt>.
--   
--   This function does not clear the existing Cairo path. Call
--   <tt><i>cairo_new_path()</i></tt> if you want this.
--   
--   <i>Since: 4.14</i>
pathToCairo :: (HasCallStack, MonadIO m) => Path -> Context -> m ()

-- | 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 <a>pathPrint</a>, see that function for
--   details.
--   
--   <i>Since: 4.14</i>
pathToString :: (HasCallStack, MonadIO m) => Path -> m Text

-- | Decreases the reference count of a path by one.
--   
--   If the resulting reference count is zero, frees the path.
--   
--   <i>Since: 4.14</i>
pathUnref :: (HasCallStack, MonadIO m) => Path -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.Path.Path
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.Path.Path
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.Path.Path
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.Path.Path)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.Path.Path
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.Path.Path


-- | Renders a GSK rendernode tree with Vulkan.
--   
--   This renderer will fail to realize if Vulkan is not supported.
module GI.Gsk.Objects.VulkanRenderer

-- | Memory-managed wrapper type.
newtype VulkanRenderer
VulkanRenderer :: ManagedPtr VulkanRenderer -> VulkanRenderer

-- | Type class for types which can be safely cast to
--   <a>VulkanRenderer</a>, for instance with <a>toVulkanRenderer</a>.
class (GObject o, IsDescendantOf VulkanRenderer o) => IsVulkanRenderer o

-- | Cast to <a>VulkanRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toVulkanRenderer :: (MonadIO m, IsVulkanRenderer o) => o -> m VulkanRenderer

-- | Creates a new Vulkan renderer.
--   
--   The Vulkan renderer is a renderer that uses the Vulkan library for
--   rendering.
--   
--   This renderer will fail to realize when GTK was not compiled with
--   Vulkan support.
vulkanRendererNew :: (HasCallStack, MonadIO m) => m VulkanRenderer
instance GHC.Classes.Eq GI.Gsk.Objects.VulkanRenderer.VulkanRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.VulkanRenderer.VulkanRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.VulkanRenderer.VulkanRenderer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.VulkanRenderer.VulkanRenderer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.VulkanRenderer.VulkanRenderer o) => GI.Gsk.Objects.VulkanRenderer.IsVulkanRenderer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.VulkanRenderer.VulkanRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.VulkanRenderer.VulkanRenderer


-- | A render node for a <tt>GdkTexture</tt>, with control over scaling.
--   
--   <i>Since: 4.10</i>
module GI.Gsk.Objects.TextureScaleNode

-- | Memory-managed wrapper type.
newtype TextureScaleNode
TextureScaleNode :: ManagedPtr TextureScaleNode -> TextureScaleNode

-- | Type class for types which can be safely cast to
--   <a>TextureScaleNode</a>, for instance with <a>toTextureScaleNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf TextureScaleNode o) => IsTextureScaleNode o

-- | Cast to <a>TextureScaleNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toTextureScaleNode :: (MonadIO m, IsTextureScaleNode o) => o -> m TextureScaleNode

-- | Retrieves the <tt>GskScalingFilter</tt> used when creating this
--   <tt>GskRenderNode</tt>.
--   
--   <i>Since: 4.10</i>
textureScaleNodeGetFilter :: (HasCallStack, MonadIO m, IsTextureScaleNode a) => a -> m ScalingFilter

-- | Retrieves the <tt>GdkTexture</tt> used when creating this
--   <tt>GskRenderNode</tt>.
--   
--   <i>Since: 4.10</i>
textureScaleNodeGetTexture :: (HasCallStack, MonadIO m, IsTextureScaleNode a) => a -> m Texture

-- | Creates a node that scales the texture to the size given by the bounds
--   using the filter and then places it at the bounds' position.
--   
--   Note that further scaling and other transformations which are applied
--   to the node will apply linear filtering to the resulting texture, as
--   usual.
--   
--   This node is intended for tight control over scaling applied to a
--   texture, such as in image editors and requires the application to be
--   aware of the whole render tree as further transforms may be applied
--   that conflict with the desired effect of this node.
--   
--   <i>Since: 4.10</i>
textureScaleNodeNew :: (HasCallStack, MonadIO m, IsTexture a) => a -> Rect -> ScalingFilter -> m TextureScaleNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.TextureScaleNode.TextureScaleNode
instance GHC.Classes.Eq GI.Gsk.Objects.TextureScaleNode.TextureScaleNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.TextureScaleNode.TextureScaleNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.TextureScaleNode.TextureScaleNode o) => GI.Gsk.Objects.TextureScaleNode.IsTextureScaleNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.TextureScaleNode.TextureScaleNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.TextureScaleNode.TextureScaleNode


-- | A render node for a <tt>GdkTexture</tt>.
module GI.Gsk.Objects.TextureNode

-- | Memory-managed wrapper type.
newtype TextureNode
TextureNode :: ManagedPtr TextureNode -> TextureNode

-- | Type class for types which can be safely cast to <a>TextureNode</a>,
--   for instance with <a>toTextureNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf TextureNode o) => IsTextureNode o

-- | Cast to <a>TextureNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTextureNode :: (MonadIO m, IsTextureNode o) => o -> m TextureNode

-- | Retrieves the <tt>GdkTexture</tt> used when creating this
--   <tt>GskRenderNode</tt>.
textureNodeGetTexture :: (HasCallStack, MonadIO m, IsTextureNode a) => a -> m Texture

-- | Creates a <tt>GskRenderNode</tt> that will render the given
--   <i><tt>texture</tt></i> into the area given by <i><tt>bounds</tt></i>.
--   
--   Note that GSK applies linear filtering when textures are scaled and
--   transformed. See <a>TextureScaleNode</a> for a way to influence
--   filtering.
textureNodeNew :: (HasCallStack, MonadIO m, IsTexture a) => a -> Rect -> m TextureNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.TextureNode.TextureNode
instance GHC.Classes.Eq GI.Gsk.Objects.TextureNode.TextureNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.TextureNode.TextureNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.TextureNode.TextureNode o) => GI.Gsk.Objects.TextureNode.IsTextureNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.TextureNode.TextureNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.TextureNode.TextureNode


-- | A render node drawing a set of glyphs.
module GI.Gsk.Objects.TextNode

-- | Memory-managed wrapper type.
newtype TextNode
TextNode :: ManagedPtr TextNode -> TextNode

-- | Type class for types which can be safely cast to <a>TextNode</a>, for
--   instance with <a>toTextNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf TextNode o) => IsTextNode o

-- | Cast to <a>TextNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toTextNode :: (MonadIO m, IsTextNode o) => o -> m TextNode

-- | Retrieves the color used by the text <i><tt>node</tt></i>.
--   
--   The value returned by this function will not be correct if the render
--   node was created for a non-sRGB color.
textNodeGetColor :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m RGBA

-- | Returns the font used by the text <i><tt>node</tt></i>.
textNodeGetFont :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m Font

-- | Retrieves the glyph information in the <i><tt>node</tt></i>.
textNodeGetGlyphs :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m [GlyphInfo]

-- | Retrieves the number of glyphs in the text node.
textNodeGetNumGlyphs :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m Word32

-- | Retrieves the offset applied to the text.
textNodeGetOffset :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m Point

-- | Checks whether the text <i><tt>node</tt></i> has color glyphs.
--   
--   <i>Since: 4.2</i>
textNodeHasColorGlyphs :: (HasCallStack, MonadIO m, IsTextNode a) => a -> m Bool

-- | Creates a render node that renders the given glyphs.
--   
--   Note that <i><tt>color</tt></i> may not be used if the font contains
--   color glyphs.
textNodeNew :: (HasCallStack, MonadIO m, IsFont a) => a -> GlyphString -> RGBA -> Point -> m (Maybe TextNode)
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.TextNode.TextNode
instance GHC.Classes.Eq GI.Gsk.Objects.TextNode.TextNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.TextNode.TextNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.TextNode.TextNode o) => GI.Gsk.Objects.TextNode.IsTextNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.TextNode.TextNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.TextNode.TextNode


-- | A render node that potentially diverts a part of the scene graph to a
--   subsurface.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Objects.SubsurfaceNode

-- | Memory-managed wrapper type.
newtype SubsurfaceNode
SubsurfaceNode :: ManagedPtr SubsurfaceNode -> SubsurfaceNode

-- | Type class for types which can be safely cast to
--   <a>SubsurfaceNode</a>, for instance with <a>toSubsurfaceNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf SubsurfaceNode o) => IsSubsurfaceNode o

-- | Cast to <a>SubsurfaceNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toSubsurfaceNode :: (MonadIO m, IsSubsurfaceNode o) => o -> m SubsurfaceNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
subsurfaceNodeGetChild :: (HasCallStack, MonadIO m, IsSubsurfaceNode a) => a -> m RenderNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode
instance GHC.Classes.Eq GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode o) => GI.Gsk.Objects.SubsurfaceNode.IsSubsurfaceNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.SubsurfaceNode.SubsurfaceNode


-- | A render node that will fill the area determined by stroking the the
--   given <a>Path</a> using the <a>Stroke</a> attributes.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Objects.StrokeNode

-- | Memory-managed wrapper type.
newtype StrokeNode
StrokeNode :: ManagedPtr StrokeNode -> StrokeNode

-- | Type class for types which can be safely cast to <a>StrokeNode</a>,
--   for instance with <a>toStrokeNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf StrokeNode o) => IsStrokeNode o

-- | Cast to <a>StrokeNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toStrokeNode :: (MonadIO m, IsStrokeNode o) => o -> m StrokeNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
strokeNodeGetChild :: (HasCallStack, MonadIO m, IsStrokeNode a) => a -> m RenderNode

-- | Retrieves the path that will be stroked with the contents of the
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
strokeNodeGetPath :: (HasCallStack, MonadIO m, IsStrokeNode a) => a -> m Path

-- | Retrieves the stroke attributes used in this <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
strokeNodeGetStroke :: (HasCallStack, MonadIO m, IsStrokeNode a) => a -> m Stroke

-- | Creates a <a>RenderNode</a> that will fill the outline generated by
--   stroking the given <i><tt>path</tt></i> using the attributes defined
--   in <i><tt>stroke</tt></i>.
--   
--   The area is filled with <i><tt>child</tt></i>.
--   
--   GSK aims to follow the SVG semantics for stroking paths. E.g.
--   zero-length contours will get round or square line caps drawn,
--   regardless whether they are closed or not.
--   
--   <i>Since: 4.14</i>
strokeNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Path -> Stroke -> m StrokeNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.StrokeNode.StrokeNode
instance GHC.Classes.Eq GI.Gsk.Objects.StrokeNode.StrokeNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.StrokeNode.StrokeNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.StrokeNode.StrokeNode o) => GI.Gsk.Objects.StrokeNode.IsStrokeNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.StrokeNode.StrokeNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.StrokeNode.StrokeNode


-- | A render node drawing one or more shadows behind its single child
--   node.
module GI.Gsk.Objects.ShadowNode

-- | Memory-managed wrapper type.
newtype ShadowNode
ShadowNode :: ManagedPtr ShadowNode -> ShadowNode

-- | Type class for types which can be safely cast to <a>ShadowNode</a>,
--   for instance with <a>toShadowNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ShadowNode o) => IsShadowNode o

-- | Cast to <a>ShadowNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toShadowNode :: (MonadIO m, IsShadowNode o) => o -> m ShadowNode

-- | Retrieves the child <tt>GskRenderNode</tt> of the shadow
--   <i><tt>node</tt></i>.
shadowNodeGetChild :: (HasCallStack, MonadIO m, IsShadowNode a) => a -> m RenderNode

-- | Retrieves the number of shadows in the <i><tt>node</tt></i>.
shadowNodeGetNShadows :: (HasCallStack, MonadIO m, IsShadowNode a) => a -> m CSize

-- | Retrieves the shadow data at the given index <i><tt>i</tt></i>.
shadowNodeGetShadow :: (HasCallStack, MonadIO m, IsShadowNode a) => a -> CSize -> m Shadow

-- | Creates a <tt>GskRenderNode</tt> that will draw a
--   <i><tt>child</tt></i> with the given <i><tt>shadows</tt></i> below it.
shadowNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> [Shadow] -> m ShadowNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ShadowNode.ShadowNode
instance GHC.Classes.Eq GI.Gsk.Objects.ShadowNode.ShadowNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ShadowNode.ShadowNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ShadowNode.ShadowNode o) => GI.Gsk.Objects.ShadowNode.IsShadowNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ShadowNode.ShadowNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ShadowNode.ShadowNode


-- | A render node applying a rounded rectangle clip to its single child.
module GI.Gsk.Objects.RoundedClipNode

-- | Memory-managed wrapper type.
newtype RoundedClipNode
RoundedClipNode :: ManagedPtr RoundedClipNode -> RoundedClipNode

-- | Type class for types which can be safely cast to
--   <a>RoundedClipNode</a>, for instance with <a>toRoundedClipNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RoundedClipNode o) => IsRoundedClipNode o

-- | Cast to <a>RoundedClipNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toRoundedClipNode :: (MonadIO m, IsRoundedClipNode o) => o -> m RoundedClipNode

-- | Gets the child node that is getting clipped by the given
--   <i><tt>node</tt></i>.
roundedClipNodeGetChild :: (HasCallStack, MonadIO m, IsRoundedClipNode a) => a -> m RenderNode

-- | Retrieves the rounded rectangle used to clip the contents of the
--   <i><tt>node</tt></i>.
roundedClipNodeGetClip :: (HasCallStack, MonadIO m, IsRoundedClipNode a) => a -> m RoundedRect

-- | Creates a <tt>GskRenderNode</tt> that will clip the
--   <i><tt>child</tt></i> to the area given by <i><tt>clip</tt></i>.
roundedClipNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> RoundedRect -> m RoundedClipNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RoundedClipNode.RoundedClipNode
instance GHC.Classes.Eq GI.Gsk.Objects.RoundedClipNode.RoundedClipNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RoundedClipNode.RoundedClipNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RoundedClipNode.RoundedClipNode o) => GI.Gsk.Objects.RoundedClipNode.IsRoundedClipNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RoundedClipNode.RoundedClipNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RoundedClipNode.RoundedClipNode


-- | A render node for a repeating radial gradient.
module GI.Gsk.Objects.RepeatingRadialGradientNode

-- | Memory-managed wrapper type.
newtype RepeatingRadialGradientNode
RepeatingRadialGradientNode :: ManagedPtr RepeatingRadialGradientNode -> RepeatingRadialGradientNode

-- | Type class for types which can be safely cast to
--   <a>RepeatingRadialGradientNode</a>, for instance with
--   <a>toRepeatingRadialGradientNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RepeatingRadialGradientNode o) => IsRepeatingRadialGradientNode o

-- | Cast to <a>RepeatingRadialGradientNode</a>, for types for which this
--   is known to be safe. For general casts, use <a>castTo</a>.
toRepeatingRadialGradientNode :: (MonadIO m, IsRepeatingRadialGradientNode o) => o -> m RepeatingRadialGradientNode

-- | Creates a <tt>GskRenderNode</tt> that draws a repeating radial
--   gradient.
--   
--   The radial gradient starts around <i><tt>center</tt></i>. The size of
--   the gradient is dictated by <i><tt>hradius</tt></i> in horizontal
--   orientation and by <i><tt>vradius</tt></i> in vertical orientation.
repeatingRadialGradientNodeNew :: (HasCallStack, MonadIO m) => Rect -> Point -> Float -> Float -> Float -> Float -> [ColorStop] -> m RepeatingRadialGradientNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode
instance GHC.Classes.Eq GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode o) => GI.Gsk.Objects.RepeatingRadialGradientNode.IsRepeatingRadialGradientNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RepeatingRadialGradientNode.RepeatingRadialGradientNode


-- | A render node for a repeating linear gradient.
module GI.Gsk.Objects.RepeatingLinearGradientNode

-- | Memory-managed wrapper type.
newtype RepeatingLinearGradientNode
RepeatingLinearGradientNode :: ManagedPtr RepeatingLinearGradientNode -> RepeatingLinearGradientNode

-- | Type class for types which can be safely cast to
--   <a>RepeatingLinearGradientNode</a>, for instance with
--   <a>toRepeatingLinearGradientNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RepeatingLinearGradientNode o) => IsRepeatingLinearGradientNode o

-- | Cast to <a>RepeatingLinearGradientNode</a>, for types for which this
--   is known to be safe. For general casts, use <a>castTo</a>.
toRepeatingLinearGradientNode :: (MonadIO m, IsRepeatingLinearGradientNode o) => o -> m RepeatingLinearGradientNode

-- | Creates a <tt>GskRenderNode</tt> that will create a repeating linear
--   gradient from the given points and color stops, and render that into
--   the area given by <i><tt>bounds</tt></i>.
repeatingLinearGradientNodeNew :: (HasCallStack, MonadIO m) => Rect -> Point -> Point -> [ColorStop] -> m RepeatingLinearGradientNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode
instance GHC.Classes.Eq GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode o) => GI.Gsk.Objects.RepeatingLinearGradientNode.IsRepeatingLinearGradientNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RepeatingLinearGradientNode.RepeatingLinearGradientNode


-- | A render node repeating its single child node.
module GI.Gsk.Objects.RepeatNode

-- | Memory-managed wrapper type.
newtype RepeatNode
RepeatNode :: ManagedPtr RepeatNode -> RepeatNode

-- | Type class for types which can be safely cast to <a>RepeatNode</a>,
--   for instance with <a>toRepeatNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RepeatNode o) => IsRepeatNode o

-- | Cast to <a>RepeatNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRepeatNode :: (MonadIO m, IsRepeatNode o) => o -> m RepeatNode

-- | Retrieves the child of <i><tt>node</tt></i>.
repeatNodeGetChild :: (HasCallStack, MonadIO m, IsRepeatNode a) => a -> m RenderNode

-- | Retrieves the bounding rectangle of the child of <i><tt>node</tt></i>.
repeatNodeGetChildBounds :: (HasCallStack, MonadIO m, IsRepeatNode a) => a -> m Rect

-- | Creates a <tt>GskRenderNode</tt> that will repeat the drawing of
--   <i><tt>child</tt></i> across the given <i><tt>bounds</tt></i>.
repeatNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => Rect -> a -> Maybe Rect -> m RepeatNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RepeatNode.RepeatNode
instance GHC.Classes.Eq GI.Gsk.Objects.RepeatNode.RepeatNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RepeatNode.RepeatNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RepeatNode.RepeatNode o) => GI.Gsk.Objects.RepeatNode.IsRepeatNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RepeatNode.RepeatNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RepeatNode.RepeatNode


-- | Renders a scene graph defined via a tree of <a>RenderNode</a>
--   instances.
--   
--   Typically you will use a <tt>GskRenderer</tt> instance to repeatedly
--   call <a>rendererRender</a> to update the contents of its associated
--   <a>Surface</a>.
--   
--   It is necessary to realize a <tt>GskRenderer</tt> instance using
--   <a>rendererRealize</a> before calling <a>rendererRender</a>, in order
--   to create the appropriate windowing system resources needed to render
--   the scene.
module GI.Gsk.Objects.Renderer

-- | Memory-managed wrapper type.
newtype Renderer
Renderer :: ManagedPtr Renderer -> Renderer

-- | Type class for types which can be safely cast to <a>Renderer</a>, for
--   instance with <a>toRenderer</a>.
class (GObject o, IsDescendantOf Renderer o) => IsRenderer o

-- | Cast to <a>Renderer</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toRenderer :: (MonadIO m, IsRenderer o) => o -> m Renderer

-- | Retrieves the surface that the renderer is associated with.
--   
--   If the renderer has not been realized yet, <tt>NULL</tt> will be
--   returned.
rendererGetSurface :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m (Maybe Surface)

-- | Checks whether the renderer is realized or not.
rendererIsRealized :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m Bool

-- | Creates an appropriate <tt>GskRenderer</tt> instance for the given
--   surface.
--   
--   If the <tt>GSK_RENDERER</tt> environment variable is set, GSK will try
--   that renderer first, before trying the backend-specific default. The
--   ultimate fallback is the cairo renderer.
--   
--   The renderer will be realized before it is returned.
rendererNewForSurface :: (HasCallStack, MonadIO m, IsSurface a) => a -> m (Maybe Renderer)

-- | Creates the resources needed by the renderer.
--   
--   Since GTK 4.6, the surface may be <tt>NULL</tt>, which allows using
--   renderers without having to create a surface. Since GTK 4.14, it is
--   recommended to use <a>rendererRealizeForDisplay</a> for this case.
--   
--   Note that it is mandatory to call <a>rendererUnrealize</a> before
--   destroying the renderer.
rendererRealize :: (HasCallStack, MonadIO m, IsRenderer a, IsSurface b) => a -> Maybe b -> m ()

-- | Creates the resources needed by the renderer.
--   
--   Note that it is mandatory to call <a>rendererUnrealize</a> before
--   destroying the renderer.
--   
--   <i>Since: 4.14</i>
rendererRealizeForDisplay :: (HasCallStack, MonadIO m, IsRenderer a, IsDisplay b) => a -> b -> m ()

-- | Renders the scene graph, described by a tree of <tt>GskRenderNode</tt>
--   instances to the renderer's surface, ensuring that the given region
--   gets redrawn.
--   
--   If the renderer has no associated surface, this function does nothing.
--   
--   Renderers must ensure that changes of the contents given by the
--   <i><tt>root</tt></i> node as well as the area given by
--   <i><tt>region</tt></i> are redrawn. They are however free to not
--   redraw any pixel outside of <i><tt>region</tt></i> if they can
--   guarantee that it didn't change.
--   
--   The renderer will acquire a reference on the <tt>GskRenderNode</tt>
--   tree while the rendering is in progress.
rendererRender :: (HasCallStack, MonadIO m, IsRenderer a, IsRenderNode b) => a -> b -> Maybe Region -> m ()

-- | Renders a scene graph, described by a tree of <tt>GskRenderNode</tt>
--   instances, to a texture.
--   
--   The renderer will acquire a reference on the <tt>GskRenderNode</tt>
--   tree while the rendering is in progress.
--   
--   If you want to apply any transformations to <i><tt>root</tt></i>, you
--   should put it into a transform node and pass that node instead.
rendererRenderTexture :: (HasCallStack, MonadIO m, IsRenderer a, IsRenderNode b) => a -> b -> Maybe Rect -> m Texture

-- | Releases all the resources created by <a>rendererRealize</a>.
rendererUnrealize :: (HasCallStack, MonadIO m, IsRenderer a) => a -> m ()

-- | Get the value of the “<tt>realized</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> renderer #realized
--   </pre>
getRendererRealized :: (MonadIO m, IsRenderer o) => o -> m Bool

-- | Get the value of the “<tt>surface</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> renderer #surface
--   </pre>
getRendererSurface :: (MonadIO m, IsRenderer o) => o -> m (Maybe Surface)
instance GHC.Classes.Eq GI.Gsk.Objects.Renderer.Renderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.Renderer.Renderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.Renderer.Renderer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.Renderer.Renderer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.Renderer.Renderer o) => GI.Gsk.Objects.Renderer.IsRenderer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.Renderer.Renderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.Renderer.Renderer


-- | The basic block in a scene graph to be rendered using <a>Renderer</a>.
--   
--   Each node has a parent, except the top-level node; each node may have
--   children nodes.
--   
--   Each node has an associated drawing surface, which has the size of the
--   rectangle set when creating it.
--   
--   Render nodes are meant to be transient; once they have been associated
--   to a <a>Renderer</a> it's safe to release any reference you have on
--   them. All <a>RenderNode</a>s are immutable, you can only specify their
--   properties during construction.
module GI.Gsk.Objects.RenderNode

-- | Memory-managed wrapper type.
newtype RenderNode
RenderNode :: ManagedPtr RenderNode -> RenderNode

-- | Type class for types which can be safely cast to <a>RenderNode</a>,
--   for instance with <a>toRenderNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RenderNode o) => IsRenderNode o

-- | Cast to <a>RenderNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toRenderNode :: (MonadIO m, IsRenderNode o) => o -> m RenderNode

-- | Loads data previously created via <a>renderNodeSerialize</a>.
--   
--   For a discussion of the supported format, see that function.
renderNodeDeserialize :: (HasCallStack, MonadIO m) => Bytes -> Maybe ParseErrorFunc -> m (Maybe RenderNode)

-- | Draws the contents of a render node on a cairo context.
--   
--   Typically, you'll use this function to implement fallback rendering of
--   render nodes on an intermediate Cairo context, instead of using the
--   drawing context associated to a <a>Surface</a>'s rendering buffer.
--   
--   For advanced nodes that cannot be supported using Cairo, in particular
--   for nodes doing 3D operations, this function may fail.
renderNodeDraw :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Context -> m ()

-- | Retrieves the boundaries of the <i><tt>node</tt></i>.
--   
--   The node will not draw outside of its boundaries.
renderNodeGetBounds :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m Rect

-- | Gets a list of all children nodes of the rendernode.
--   
--   Keep in mind that for various rendernodes, their children have
--   different semantics, like the mask vs the source of a mask node. If
--   you care about thse semantics, don't use this function, use the
--   specific getters instead.
--   
--   <i>Since: 4.22</i>
renderNodeGetChildren :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m (Maybe [RenderNode])

-- | Returns the type of the render node.
renderNodeGetNodeType :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m RenderNodeType

-- | Gets an opaque rectangle inside the node that GTK can determine to be
--   fully opaque.
--   
--   There is no guarantee that this is indeed the largest opaque rectangle
--   or that regions outside the rectangle are not opaque. This function is
--   a best effort with that goal.
--   
--   The rectangle will be fully contained in the bounds of the node.
--   
--   <i>Since: 4.16</i>
renderNodeGetOpaqueRect :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m (Bool, Rect)

-- | Acquires a reference on the given <tt>GskRenderNode</tt>.
renderNodeRef :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m RenderNode

-- | Serializes the <i><tt>node</tt></i> for later deserialization via
--   <a>renderNodeDeserialize</a>. No guarantees are made about the format
--   used other than that the same version of GTK will be able to
--   deserialize the result of a call to <a>renderNodeSerialize</a> and
--   <a>renderNodeDeserialize</a> will correctly reject files it cannot
--   open that were created with previous versions of GTK.
--   
--   The intended use of this functions is testing, benchmarking and
--   debugging. The format is not meant as a permanent storage format.
renderNodeSerialize :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m Bytes

-- | Releases a reference on the given <tt>GskRenderNode</tt>.
--   
--   If the reference was the last, the resources associated to the
--   <i><tt>node</tt></i> are freed.
renderNodeUnref :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m ()

-- | This function is equivalent to calling <a>renderNodeSerialize</a>
--   followed by <a>fileSetContents</a>.
--   
--   See those two functions for details on the arguments.
--   
--   It is mostly intended for use inside a debugger to quickly dump a
--   render node to a file for later inspection.
renderNodeWriteToFile :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> [Char] -> m ()
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RenderNode.RenderNode
instance GHC.Classes.Eq GI.Gsk.Objects.RenderNode.RenderNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RenderNode.RenderNode
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.RenderNode.RenderNode)
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RenderNode.RenderNode o) => GI.Gsk.Objects.RenderNode.IsRenderNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RenderNode.RenderNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RenderNode.RenderNode


-- | A render node for a radial gradient.
module GI.Gsk.Objects.RadialGradientNode

-- | Memory-managed wrapper type.
newtype RadialGradientNode
RadialGradientNode :: ManagedPtr RadialGradientNode -> RadialGradientNode

-- | Type class for types which can be safely cast to
--   <a>RadialGradientNode</a>, for instance with
--   <a>toRadialGradientNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf RadialGradientNode o) => IsRadialGradientNode o

-- | Cast to <a>RadialGradientNode</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toRadialGradientNode :: (MonadIO m, IsRadialGradientNode o) => o -> m RadialGradientNode

-- | Retrieves the center pointer for the gradient.
radialGradientNodeGetCenter :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m Point

-- | Retrieves the color stops in the gradient.
radialGradientNodeGetColorStops :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m [ColorStop]

-- | Retrieves the end value for the gradient.
radialGradientNodeGetEnd :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m Float

-- | Retrieves the horizontal radius for the gradient.
radialGradientNodeGetHradius :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m Float

-- | Retrieves the number of color stops in the gradient.
radialGradientNodeGetNColorStops :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m CSize

-- | Retrieves the start value for the gradient.
radialGradientNodeGetStart :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m Float

-- | Retrieves the vertical radius for the gradient.
radialGradientNodeGetVradius :: (HasCallStack, MonadIO m, IsRadialGradientNode a) => a -> m Float

-- | Creates a <tt>GskRenderNode</tt> that draws a radial gradient.
--   
--   The radial gradient starts around <i><tt>center</tt></i>. The size of
--   the gradient is dictated by <i><tt>hradius</tt></i> in horizontal
--   orientation and by <i><tt>vradius</tt></i> in vertical orientation.
radialGradientNodeNew :: (HasCallStack, MonadIO m) => Rect -> Point -> Float -> Float -> Float -> Float -> [ColorStop] -> m RadialGradientNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.RadialGradientNode.RadialGradientNode
instance GHC.Classes.Eq GI.Gsk.Objects.RadialGradientNode.RadialGradientNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.RadialGradientNode.RadialGradientNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.RadialGradientNode.RadialGradientNode o) => GI.Gsk.Objects.RadialGradientNode.IsRadialGradientNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.RadialGradientNode.RadialGradientNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.RadialGradientNode.RadialGradientNode


-- | A render node for a paste.
--   
--   <i>Since: 4.22</i>
module GI.Gsk.Objects.PasteNode

-- | Memory-managed wrapper type.
newtype PasteNode
PasteNode :: ManagedPtr PasteNode -> PasteNode

-- | Type class for types which can be safely cast to <a>PasteNode</a>, for
--   instance with <a>toPasteNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf PasteNode o) => IsPasteNode o

-- | Cast to <a>PasteNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toPasteNode :: (MonadIO m, IsPasteNode o) => o -> m PasteNode

-- | Retrieves the index of the copy that should be pasted.
--   
--   <i>Since: 4.22</i>
pasteNodeGetDepth :: (HasCallStack, MonadIO m, IsPasteNode a) => a -> m CSize

-- | Creates a <tt>GskRenderNode</tt> that will paste copied contents.
--   
--   <i>Since: 4.22</i>
pasteNodeNew :: (HasCallStack, MonadIO m) => Rect -> CSize -> m PasteNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.PasteNode.PasteNode
instance GHC.Classes.Eq GI.Gsk.Objects.PasteNode.PasteNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.PasteNode.PasteNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.PasteNode.PasteNode o) => GI.Gsk.Objects.PasteNode.IsPasteNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.PasteNode.PasteNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.PasteNode.PasteNode


-- | A render node for an outset shadow.
module GI.Gsk.Objects.OutsetShadowNode

-- | Memory-managed wrapper type.
newtype OutsetShadowNode
OutsetShadowNode :: ManagedPtr OutsetShadowNode -> OutsetShadowNode

-- | Type class for types which can be safely cast to
--   <a>OutsetShadowNode</a>, for instance with <a>toOutsetShadowNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf OutsetShadowNode o) => IsOutsetShadowNode o

-- | Cast to <a>OutsetShadowNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toOutsetShadowNode :: (MonadIO m, IsOutsetShadowNode o) => o -> m OutsetShadowNode

-- | Retrieves the blur radius of the shadow.
outsetShadowNodeGetBlurRadius :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m Float

-- | Retrieves the color of the outset shadow.
--   
--   The value returned by this function will not be correct if the render
--   node was created for a non-sRGB color.
outsetShadowNodeGetColor :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m RGBA

-- | Retrieves the horizontal offset of the outset shadow.
outsetShadowNodeGetDx :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m Float

-- | Retrieves the vertical offset of the outset shadow.
outsetShadowNodeGetDy :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m Float

-- | Retrieves the outline rectangle of the outset shadow.
outsetShadowNodeGetOutline :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m RoundedRect

-- | Retrieves how much the shadow spreads outwards.
outsetShadowNodeGetSpread :: (HasCallStack, MonadIO m, IsOutsetShadowNode a) => a -> m Float

-- | Creates a <tt>GskRenderNode</tt> that will render an outset shadow
--   around the box given by <i><tt>outline</tt></i>.
outsetShadowNodeNew :: (HasCallStack, MonadIO m) => RoundedRect -> RGBA -> Float -> Float -> Float -> Float -> m OutsetShadowNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode
instance GHC.Classes.Eq GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode o) => GI.Gsk.Objects.OutsetShadowNode.IsOutsetShadowNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.OutsetShadowNode.OutsetShadowNode


-- | A render node controlling the opacity of its single child node.
module GI.Gsk.Objects.OpacityNode

-- | Memory-managed wrapper type.
newtype OpacityNode
OpacityNode :: ManagedPtr OpacityNode -> OpacityNode

-- | Type class for types which can be safely cast to <a>OpacityNode</a>,
--   for instance with <a>toOpacityNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf OpacityNode o) => IsOpacityNode o

-- | Cast to <a>OpacityNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toOpacityNode :: (MonadIO m, IsOpacityNode o) => o -> m OpacityNode

-- | Gets the child node that is getting opacityed by the given
--   <i><tt>node</tt></i>.
opacityNodeGetChild :: (HasCallStack, MonadIO m, IsOpacityNode a) => a -> m RenderNode

-- | Gets the transparency factor for an opacity node.
opacityNodeGetOpacity :: (HasCallStack, MonadIO m, IsOpacityNode a) => a -> m Float

-- | Creates a <tt>GskRenderNode</tt> that will drawn the
--   <i><tt>child</tt></i> with reduced <i><tt>opacity</tt></i>.
opacityNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Float -> m OpacityNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.OpacityNode.OpacityNode
instance GHC.Classes.Eq GI.Gsk.Objects.OpacityNode.OpacityNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.OpacityNode.OpacityNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.OpacityNode.OpacityNode o) => GI.Gsk.Objects.OpacityNode.IsOpacityNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.OpacityNode.OpacityNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.OpacityNode.OpacityNode


-- | A GL based renderer.
--   
--   See <a>Renderer</a>.
module GI.Gsk.Objects.NglRenderer

-- | Memory-managed wrapper type.
newtype NglRenderer
NglRenderer :: ManagedPtr NglRenderer -> NglRenderer

-- | Type class for types which can be safely cast to <a>NglRenderer</a>,
--   for instance with <a>toNglRenderer</a>.
class (GObject o, IsDescendantOf NglRenderer o) => IsNglRenderer o

-- | Cast to <a>NglRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toNglRenderer :: (MonadIO m, IsNglRenderer o) => o -> m NglRenderer

-- | Same as <a>gLRendererNew</a>.

-- | <i>Deprecated: (Since version 4.18)Use <a>gLRendererNew</a></i>
nglRendererNew :: (HasCallStack, MonadIO m) => m NglRenderer
instance GHC.Classes.Eq GI.Gsk.Objects.NglRenderer.NglRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.NglRenderer.NglRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.NglRenderer.NglRenderer
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.NglRenderer.NglRenderer)
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.NglRenderer.NglRenderer o) => GI.Gsk.Objects.NglRenderer.IsNglRenderer o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.NglRenderer.NglRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.NglRenderer.NglRenderer


-- | A render node masking one child node with another.
--   
--   <i>Since: 4.10</i>
module GI.Gsk.Objects.MaskNode

-- | Memory-managed wrapper type.
newtype MaskNode
MaskNode :: ManagedPtr MaskNode -> MaskNode

-- | Type class for types which can be safely cast to <a>MaskNode</a>, for
--   instance with <a>toMaskNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf MaskNode o) => IsMaskNode o

-- | Cast to <a>MaskNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toMaskNode :: (MonadIO m, IsMaskNode o) => o -> m MaskNode

-- | Retrieves the mask <tt>GskRenderNode</tt> child of the
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.10</i>
maskNodeGetMask :: (HasCallStack, MonadIO m, IsMaskNode a) => a -> m RenderNode

-- | Retrieves the mask mode used by <i><tt>node</tt></i>.
--   
--   <i>Since: 4.10</i>
maskNodeGetMaskMode :: (HasCallStack, MonadIO m, IsMaskNode a) => a -> m MaskMode

-- | Retrieves the source <tt>GskRenderNode</tt> child of the
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.10</i>
maskNodeGetSource :: (HasCallStack, MonadIO m, IsMaskNode a) => a -> m RenderNode

-- | Creates a <tt>GskRenderNode</tt> that will mask a given node by
--   another.
--   
--   The <i><tt>maskMode</tt></i> determines how the 'mask values' are
--   derived from the colors of the <i><tt>mask</tt></i>. Applying the mask
--   consists of multiplying the 'mask value' with the alpha of the source.
--   
--   <i>Since: 4.10</i>
maskNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a, IsRenderNode b) => a -> b -> MaskMode -> m MaskNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.MaskNode.MaskNode
instance GHC.Classes.Eq GI.Gsk.Objects.MaskNode.MaskNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.MaskNode.MaskNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.MaskNode.MaskNode o) => GI.Gsk.Objects.MaskNode.IsMaskNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.MaskNode.MaskNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.MaskNode.MaskNode


-- | A render node for a linear gradient.
module GI.Gsk.Objects.LinearGradientNode

-- | Memory-managed wrapper type.
newtype LinearGradientNode
LinearGradientNode :: ManagedPtr LinearGradientNode -> LinearGradientNode

-- | Type class for types which can be safely cast to
--   <a>LinearGradientNode</a>, for instance with
--   <a>toLinearGradientNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf LinearGradientNode o) => IsLinearGradientNode o

-- | Cast to <a>LinearGradientNode</a>, for types for which this is known
--   to be safe. For general casts, use <a>castTo</a>.
toLinearGradientNode :: (MonadIO m, IsLinearGradientNode o) => o -> m LinearGradientNode

-- | Retrieves the color stops in the gradient.
linearGradientNodeGetColorStops :: (HasCallStack, MonadIO m, IsLinearGradientNode a) => a -> m [ColorStop]

-- | Retrieves the final point of the linear gradient.
linearGradientNodeGetEnd :: (HasCallStack, MonadIO m, IsLinearGradientNode a) => a -> m Point

-- | Retrieves the number of color stops in the gradient.
linearGradientNodeGetNColorStops :: (HasCallStack, MonadIO m, IsLinearGradientNode a) => a -> m CSize

-- | Retrieves the initial point of the linear gradient.
linearGradientNodeGetStart :: (HasCallStack, MonadIO m, IsLinearGradientNode a) => a -> m Point

-- | Creates a <tt>GskRenderNode</tt> that will create a linear gradient
--   from the given points and color stops, and render that into the area
--   given by <i><tt>bounds</tt></i>.
linearGradientNodeNew :: (HasCallStack, MonadIO m) => Rect -> Point -> Point -> [ColorStop] -> m LinearGradientNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.LinearGradientNode.LinearGradientNode
instance GHC.Classes.Eq GI.Gsk.Objects.LinearGradientNode.LinearGradientNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.LinearGradientNode.LinearGradientNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.LinearGradientNode.LinearGradientNode o) => GI.Gsk.Objects.LinearGradientNode.IsLinearGradientNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.LinearGradientNode.LinearGradientNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.LinearGradientNode.LinearGradientNode


-- | A render node that isolates its child from surrounding rendernodes.
--   
--   <i>Since: 4.22</i>
module GI.Gsk.Objects.IsolationNode

-- | Memory-managed wrapper type.
newtype IsolationNode
IsolationNode :: ManagedPtr IsolationNode -> IsolationNode

-- | Type class for types which can be safely cast to <a>IsolationNode</a>,
--   for instance with <a>toIsolationNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf IsolationNode o) => IsIsolationNode o

-- | Cast to <a>IsolationNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toIsolationNode :: (MonadIO m, IsIsolationNode o) => o -> m IsolationNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.22</i>
isolationNodeGetChild :: (HasCallStack, MonadIO m, IsIsolationNode a) => a -> m RenderNode

-- | Gets the isolation features that are enforced by this node.
--   
--   <i>Since: 4.22</i>
isolationNodeGetIsolations :: (HasCallStack, MonadIO m, IsIsolationNode a) => a -> m [Isolation]

-- | Creates a <tt>GskRenderNode</tt> that isolates the drawing operations
--   of the child from surrounding ones.
--   
--   You can express "everything but these flags" in a forward compatible
--   way by using bit math: <tt>GSK_ISOLATION_ALL &amp;
--   ~(GSK_ISOLATION_BACKGROUND | GSK_ISOLATION_COPY_PASTE)</tt> will
--   isolate everything but background and copy/paste.
--   
--   For the available isolations, see
--   [flags<i><tt>gsk</tt></i>.Isolation].
--   
--   <i>Since: 4.22</i>
isolationNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> [Isolation] -> m IsolationNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.IsolationNode.IsolationNode
instance GHC.Classes.Eq GI.Gsk.Objects.IsolationNode.IsolationNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.IsolationNode.IsolationNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.IsolationNode.IsolationNode o) => GI.Gsk.Objects.IsolationNode.IsIsolationNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.IsolationNode.IsolationNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.IsolationNode.IsolationNode


-- | A render node for an inset shadow.
module GI.Gsk.Objects.InsetShadowNode

-- | Memory-managed wrapper type.
newtype InsetShadowNode
InsetShadowNode :: ManagedPtr InsetShadowNode -> InsetShadowNode

-- | Type class for types which can be safely cast to
--   <a>InsetShadowNode</a>, for instance with <a>toInsetShadowNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf InsetShadowNode o) => IsInsetShadowNode o

-- | Cast to <a>InsetShadowNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toInsetShadowNode :: (MonadIO m, IsInsetShadowNode o) => o -> m InsetShadowNode

-- | Retrieves the blur radius to apply to the shadow.
insetShadowNodeGetBlurRadius :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m Float

-- | Retrieves the color of the inset shadow.
--   
--   The value returned by this function will not be correct if the render
--   node was created for a non-sRGB color.
insetShadowNodeGetColor :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m RGBA

-- | Retrieves the horizontal offset of the inset shadow.
insetShadowNodeGetDx :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m Float

-- | Retrieves the vertical offset of the inset shadow.
insetShadowNodeGetDy :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m Float

-- | Retrieves the outline rectangle of the inset shadow.
insetShadowNodeGetOutline :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m RoundedRect

-- | Retrieves how much the shadow spreads inwards.
insetShadowNodeGetSpread :: (HasCallStack, MonadIO m, IsInsetShadowNode a) => a -> m Float

-- | Creates a <tt>GskRenderNode</tt> that will render an inset shadow into
--   the box given by <i><tt>outline</tt></i>.
insetShadowNodeNew :: (HasCallStack, MonadIO m) => RoundedRect -> RGBA -> Float -> Float -> Float -> Float -> m InsetShadowNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.InsetShadowNode.InsetShadowNode
instance GHC.Classes.Eq GI.Gsk.Objects.InsetShadowNode.InsetShadowNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.InsetShadowNode.InsetShadowNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.InsetShadowNode.InsetShadowNode o) => GI.Gsk.Objects.InsetShadowNode.IsInsetShadowNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.InsetShadowNode.InsetShadowNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.InsetShadowNode.InsetShadowNode


-- | A render node using a GL shader when drawing its children nodes.
module GI.Gsk.Objects.GLShaderNode

-- | Memory-managed wrapper type.
newtype GLShaderNode
GLShaderNode :: ManagedPtr GLShaderNode -> GLShaderNode

-- | Type class for types which can be safely cast to <a>GLShaderNode</a>,
--   for instance with <a>toGLShaderNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf GLShaderNode o) => IsGLShaderNode o

-- | Cast to <a>GLShaderNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGLShaderNode :: (MonadIO m, IsGLShaderNode o) => o -> m GLShaderNode

-- | Gets args for the node.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNodeGetArgs :: (HasCallStack, MonadIO m, IsGLShaderNode a) => a -> m Bytes

-- | Gets one of the children.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNodeGetChild :: (HasCallStack, MonadIO m, IsGLShaderNode a) => a -> Word32 -> m RenderNode

-- | Returns the number of children

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNodeGetNChildren :: (HasCallStack, MonadIO m, IsGLShaderNode a) => a -> m Word32

-- | Gets shader code for the node.
gLShaderNodeGetShader :: (HasCallStack, MonadIO m, IsGLShaderNode a) => a -> m GLShader

-- | Creates a <tt>GskRenderNode</tt> that will render the given
--   <i><tt>shader</tt></i> into the area given by <i><tt>bounds</tt></i>.
--   
--   The <i><tt>args</tt></i> is a block of data to use for uniform input,
--   as per types and offsets defined by the <i><tt>shader</tt></i>.
--   Normally this is generated by
--   <a>GLShader</a>.<tt><i>format_args</i></tt>() or
--   <a>ShaderArgsBuilder</a>.
--   
--   See <a>GLShader</a> for details about how the shader should be
--   written.
--   
--   All the children will be rendered into textures (if they aren't
--   already <tt>GskTextureNodes</tt>, which will be used directly). These
--   textures will be sent as input to the shader.
--   
--   If the renderer doesn't support GL shaders, or if there is any problem
--   when compiling the shader, then the node will draw pink. You should
--   use <a>gLShaderCompile</a> to ensure the <i><tt>shader</tt></i> will
--   work for the renderer before using it.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNodeNew :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Rect -> Bytes -> Maybe [RenderNode] -> m GLShaderNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.GLShaderNode.GLShaderNode
instance GHC.Classes.Eq GI.Gsk.Objects.GLShaderNode.GLShaderNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.GLShaderNode.GLShaderNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.GLShaderNode.GLShaderNode o) => GI.Gsk.Objects.GLShaderNode.IsGLShaderNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.GLShaderNode.GLShaderNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.GLShaderNode.GLShaderNode


-- | Implements a fragment shader using GLSL.
--   
--   A fragment shader gets the coordinates being rendered as input and
--   produces the pixel values for that particular pixel. Additionally, the
--   shader can declare a set of other input arguments, called uniforms (as
--   they are uniform over all the calls to your shader in each instance of
--   use). A shader can also receive up to 4 textures that it can use as
--   input when producing the pixel data.
--   
--   <tt>GskGLShader</tt> is usually used with
--   <tt><i>gtk_snapshot_push_gl_shader()</i></tt> to produce a
--   <a>GLShaderNode</a> in the rendering hierarchy, and then its input
--   textures are constructed by rendering the child nodes to textures
--   before rendering the shader node itself. (You can pass texture nodes
--   as children if you want to directly use a texture as input).
--   
--   The actual shader code is GLSL code that gets combined with some other
--   code into the fragment shader. Since the exact capabilities of the GPU
--   driver differs between different OpenGL drivers and hardware, GTK adds
--   some defines that you can use to ensure your GLSL code runs on as many
--   drivers as it can.
--   
--   If the OpenGL driver is GLES, then the shader language version is set
--   to 100, and GSK_GLES will be defined in the shader.
--   
--   Otherwise, if the OpenGL driver does not support the 3.2 core profile,
--   then the shader will run with language version 110 for GL2 and 130 for
--   GL3, and GSK_LEGACY will be defined in the shader.
--   
--   If the OpenGL driver supports the 3.2 code profile, it will be used,
--   the shader language version is set to 150, and GSK_GL3 will be defined
--   in the shader.
--   
--   The main function the shader must implement is:
--   
--   <h3><i>glsl code</i></h3>
--   
--   <pre>
--   void mainImage(out vec4 fragColor,
--                  in vec2 fragCoord,
--                  in vec2 resolution,
--                  in vec2 uv)
--   </pre>
--   
--   Where the input <i><tt>fragCoord</tt></i> is the coordinate of the
--   pixel we're currently rendering, relative to the boundary rectangle
--   that was specified in the <tt>GskGLShaderNode</tt>, and
--   <i><tt>resolution</tt></i> is the width and height of that rectangle.
--   This is in the typical GTK coordinate system with the origin in the
--   top left. <i><tt>uv</tt></i> contains the u and v coordinates that can
--   be used to index a texture at the corresponding point. These
--   coordinates are in the [0..1]x[0..1] region, with 0, 0 being in the
--   lower left corder (which is typical for OpenGL).
--   
--   The output <i><tt>fragColor</tt></i> should be a RGBA color (with
--   premultiplied alpha) that will be used as the output for the specified
--   pixel location. Note that this output will be automatically clipped to
--   the clip region of the glshader node.
--   
--   In addition to the function arguments the shader can define up to 4
--   uniforms for textures which must be called u_textureN (i.e. u_texture1
--   to u_texture4) as well as any custom uniforms you want of types int,
--   uint, bool, float, vec2, vec3 or vec4.
--   
--   All textures sources contain premultiplied alpha colors, but if some
--   there are outer sources of colors there is a
--   <tt><i>gsk_premultiply()</i></tt> helper to compute premultiplication
--   when needed.
--   
--   Note that GTK parses the uniform declarations, so each uniform has to
--   be on a line by itself with no other code, like so:
--   
--   <h3><i>glsl code</i></h3>
--   
--   <pre>
--   uniform float u_time;
--   uniform vec3 u_color;
--   uniform sampler2D u_texture1;
--   uniform sampler2D u_texture2;
--   </pre>
--   
--   GTK uses the "gsk" namespace in the symbols it uses in the shader, so
--   your code should not use any symbols with the prefix gsk or GSK. There
--   are some helper functions declared that you can use:
--   
--   <h3><i>glsl code</i></h3>
--   
--   <pre>
--   vec4 GskTexture(sampler2D sampler, vec2 texCoords);
--   </pre>
--   
--   This samples a texture (e.g. u_texture1) at the specified coordinates,
--   and contains some helper ifdefs to ensure that it works on all OpenGL
--   versions.
--   
--   You can compile the shader yourself using <a>gLShaderCompile</a>,
--   otherwise the GSK renderer will do it when it handling the glshader
--   node. If errors occurs, the returned <i><tt>error</tt></i> will
--   include the glsl sources, so you can see what GSK was passing to the
--   compiler. You can also set GSK_DEBUG=shaders in the environment to see
--   the sources and other relevant information about all shaders that GSK
--   is handling.
--   
--   <h1>An example shader</h1>
--   
--   <h3><i>glsl code</i></h3>
--   
--   <pre>
--   uniform float position;
--   uniform sampler2D u_texture1;
--   uniform sampler2D u_texture2;
--   
--   void mainImage(out vec4 fragColor,
--                  in vec2 fragCoord,
--                  in vec2 resolution,
--                  in vec2 uv) {
--     vec4 source1 = GskTexture(u_texture1, uv);
--     vec4 source2 = GskTexture(u_texture2, uv);
--   
--     fragColor = position * source1 + (1.0 - position) * source2;
--   }
--   </pre>
module GI.Gsk.Objects.GLShader

-- | Memory-managed wrapper type.
newtype GLShader
GLShader :: ManagedPtr GLShader -> GLShader

-- | Type class for types which can be safely cast to <a>GLShader</a>, for
--   instance with <a>toGLShader</a>.
class (GObject o, IsDescendantOf GLShader o) => IsGLShader o

-- | Cast to <a>GLShader</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toGLShader :: (MonadIO m, IsGLShader o) => o -> m GLShader

-- | Tries to compile the <i><tt>shader</tt></i> for the given
--   <i><tt>renderer</tt></i>.
--   
--   If there is a problem, this function returns <a>False</a> and reports
--   an error. You should use this function before relying on the shader
--   for rendering and use a fallback with a simpler shader or without
--   shaders if it fails.
--   
--   Note that this will modify the rendering state (for example change the
--   current GL context) and requires the renderer to be set up. This means
--   that the widget has to be realized. Commonly you want to call this
--   from the realize signal of a widget, or during widget snapshot.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderCompile :: (HasCallStack, MonadIO m, IsGLShader a, IsRenderer b) => a -> b -> m ()

-- | Looks for a uniform by the name <i><tt>name</tt></i>, and returns the
--   index of the uniform, or -1 if it was not found.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderFindUniformByName :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Text -> m Int32

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of bool type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgBool :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> m Bool

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of float type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgFloat :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> m Float

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of int type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgInt :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> m Int32

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of uint type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgUint :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> m Word32

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of vec2 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgVec2 :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> Vec2 -> m ()

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of vec3 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgVec3 :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> Vec3 -> m ()

-- | Gets the value of the uniform <i><tt>idx</tt></i> in the
--   <i><tt>args</tt></i> block.
--   
--   The uniform must be of vec4 type.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgVec4 :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Bytes -> Int32 -> Vec4 -> m ()

-- | Get the size of the data block used to specify arguments for this
--   shader.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetArgsSize :: (HasCallStack, MonadIO m, IsGLShader a) => a -> m CSize

-- | Returns the number of textures that the shader requires.
--   
--   This can be used to check that the a passed shader works in your
--   usecase. It is determined by looking at the highest u_textureN value
--   that the shader defines.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetNTextures :: (HasCallStack, MonadIO m, IsGLShader a) => a -> m Int32

-- | Get the number of declared uniforms for this shader.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetNUniforms :: (HasCallStack, MonadIO m, IsGLShader a) => a -> m Int32

-- | Gets the resource path for the GLSL sourcecode being used to render
--   this shader.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetResource :: (HasCallStack, MonadIO m, IsGLShader a) => a -> m (Maybe Text)

-- | Gets the GLSL sourcecode being used to render this shader.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetSource :: (HasCallStack, MonadIO m, IsGLShader a) => a -> m Bytes

-- | Get the name of the declared uniform for this shader at index
--   <i><tt>idx</tt></i>.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetUniformName :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Int32 -> m Text

-- | Get the offset into the data block where data for this uniforms is
--   stored.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetUniformOffset :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Int32 -> m Int32

-- | Get the type of the declared uniform for this shader at index
--   <i><tt>idx</tt></i>.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderGetUniformType :: (HasCallStack, MonadIO m, IsGLShader a) => a -> Int32 -> m GLUniformType

-- | Creates a <tt>GskGLShader</tt> that will render pixels using the
--   specified code.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNewFromBytes :: (HasCallStack, MonadIO m) => Bytes -> m GLShader

-- | Creates a <tt>GskGLShader</tt> that will render pixels using the
--   specified code.

-- | <i>Deprecated: (Since version 4.16)GTK's new Vulkan-focused
--   renderingdoes not support this feature. Use <a>GtkGLArea</a>for OpenGL
--   rendering.</i>
gLShaderNewFromResource :: (HasCallStack, MonadIO m) => Text -> m GLShader

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>resource</tt>” property. This is rarely needed directly, but it
--   is used by <a>new</a>.
constructGLShaderResource :: (IsGLShader o, MonadIO m) => Text -> m (GValueConstruct o)

-- | Get the value of the “<tt>resource</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLShader #resource
--   </pre>
getGLShaderResource :: (MonadIO m, IsGLShader o) => o -> m (Maybe Text)

-- | Construct a <a>GValueConstruct</a> with valid value for the
--   “<tt>source</tt>” property. This is rarely needed directly, but it is
--   used by <a>new</a>.
constructGLShaderSource :: (IsGLShader o, MonadIO m) => Bytes -> m (GValueConstruct o)

-- | Get the value of the “<tt>source</tt>” property. When
--   <a>overloading</a> is enabled, this is equivalent to
--   
--   <pre>
--   <a>get</a> gLShader #source
--   </pre>
getGLShaderSource :: (MonadIO m, IsGLShader o) => o -> m Bytes
instance GHC.Classes.Eq GI.Gsk.Objects.GLShader.GLShader
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.GLShader.GLShader
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.GLShader.GLShader
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.GLShader.GLShader o) => GI.Gsk.Objects.GLShader.IsGLShader o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.GLShader.GLShader)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.GLShader.GLShader
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.GLShader.GLShader


-- | Renders a GSK rendernode tree with OpenGL.
--   
--   See <a>Renderer</a>.
--   
--   <i>Since: 4.2</i>
module GI.Gsk.Objects.GLRenderer

-- | Memory-managed wrapper type.
newtype GLRenderer
GLRenderer :: ManagedPtr GLRenderer -> GLRenderer

-- | Type class for types which can be safely cast to <a>GLRenderer</a>,
--   for instance with <a>toGLRenderer</a>.
class (GObject o, IsDescendantOf GLRenderer o) => IsGLRenderer o

-- | Cast to <a>GLRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toGLRenderer :: (MonadIO m, IsGLRenderer o) => o -> m GLRenderer

-- | Creates an instance of the GL renderer.
gLRendererNew :: (HasCallStack, MonadIO m) => m GLRenderer
instance GHC.Classes.Eq GI.Gsk.Objects.GLRenderer.GLRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.GLRenderer.GLRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.GLRenderer.GLRenderer
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.GLRenderer.GLRenderer o) => GI.Gsk.Objects.GLRenderer.IsGLRenderer o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.GLRenderer.GLRenderer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.GLRenderer.GLRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.GLRenderer.GLRenderer


-- | A render node filling the area given by <a>Path</a> and
--   <a>FillRule</a> with the child node.
--   
--   <i>Since: 4.14</i>
module GI.Gsk.Objects.FillNode

-- | Memory-managed wrapper type.
newtype FillNode
FillNode :: ManagedPtr FillNode -> FillNode

-- | Type class for types which can be safely cast to <a>FillNode</a>, for
--   instance with <a>toFillNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf FillNode o) => IsFillNode o

-- | Cast to <a>FillNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toFillNode :: (MonadIO m, IsFillNode o) => o -> m FillNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
fillNodeGetChild :: (HasCallStack, MonadIO m, IsFillNode a) => a -> m RenderNode

-- | Retrieves the fill rule used to determine how the path is filled.
--   
--   <i>Since: 4.14</i>
fillNodeGetFillRule :: (HasCallStack, MonadIO m, IsFillNode a) => a -> m FillRule

-- | Retrieves the path used to describe the area filled with the contents
--   of the <i><tt>node</tt></i>.
--   
--   <i>Since: 4.14</i>
fillNodeGetPath :: (HasCallStack, MonadIO m, IsFillNode a) => a -> m Path

-- | Creates a <tt>GskRenderNode</tt> that will fill the
--   <i><tt>child</tt></i> in the area given by <i><tt>path</tt></i> and
--   <i><tt>fillRule</tt></i>.
--   
--   <i>Since: 4.14</i>
fillNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Path -> FillRule -> m FillNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.FillNode.FillNode
instance GHC.Classes.Eq GI.Gsk.Objects.FillNode.FillNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.FillNode.FillNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.FillNode.FillNode o) => GI.Gsk.Objects.FillNode.IsFillNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.FillNode.FillNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.FillNode.FillNode


-- | A render node that emits a debugging message when drawing its child
--   node.
module GI.Gsk.Objects.DebugNode

-- | Memory-managed wrapper type.
newtype DebugNode
DebugNode :: ManagedPtr DebugNode -> DebugNode

-- | Type class for types which can be safely cast to <a>DebugNode</a>, for
--   instance with <a>toDebugNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf DebugNode o) => IsDebugNode o

-- | Cast to <a>DebugNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toDebugNode :: (MonadIO m, IsDebugNode o) => o -> m DebugNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
debugNodeGetChild :: (HasCallStack, MonadIO m, IsDebugNode a) => a -> m RenderNode

-- | Gets the debug message that was set on this node
debugNodeGetMessage :: (HasCallStack, MonadIO m, IsDebugNode a) => a -> m Text

-- | Creates a <tt>GskRenderNode</tt> that will add debug information about
--   the given <i><tt>child</tt></i>.
--   
--   Adding this node has no visual effect.
debugNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Text -> m DebugNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.DebugNode.DebugNode
instance GHC.Classes.Eq GI.Gsk.Objects.DebugNode.DebugNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.DebugNode.DebugNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.DebugNode.DebugNode o) => GI.Gsk.Objects.DebugNode.IsDebugNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.DebugNode.DebugNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.DebugNode.DebugNode


-- | A render node cross fading between two child nodes.
module GI.Gsk.Objects.CrossFadeNode

-- | Memory-managed wrapper type.
newtype CrossFadeNode
CrossFadeNode :: ManagedPtr CrossFadeNode -> CrossFadeNode

-- | Type class for types which can be safely cast to <a>CrossFadeNode</a>,
--   for instance with <a>toCrossFadeNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf CrossFadeNode o) => IsCrossFadeNode o

-- | Cast to <a>CrossFadeNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCrossFadeNode :: (MonadIO m, IsCrossFadeNode o) => o -> m CrossFadeNode

-- | Retrieves the child <tt>GskRenderNode</tt> at the end of the
--   cross-fade.
crossFadeNodeGetEndChild :: (HasCallStack, MonadIO m, IsCrossFadeNode a) => a -> m RenderNode

-- | Retrieves the progress value of the cross fade.
crossFadeNodeGetProgress :: (HasCallStack, MonadIO m, IsCrossFadeNode a) => a -> m Float

-- | Retrieves the child <tt>GskRenderNode</tt> at the beginning of the
--   cross-fade.
crossFadeNodeGetStartChild :: (HasCallStack, MonadIO m, IsCrossFadeNode a) => a -> m RenderNode

-- | Creates a <tt>GskRenderNode</tt> that will do a cross-fade between
--   <i><tt>start</tt></i> and <i><tt>end</tt></i>.
crossFadeNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a, IsRenderNode b) => a -> b -> Float -> m CrossFadeNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.CrossFadeNode.CrossFadeNode
instance GHC.Classes.Eq GI.Gsk.Objects.CrossFadeNode.CrossFadeNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.CrossFadeNode.CrossFadeNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.CrossFadeNode.CrossFadeNode o) => GI.Gsk.Objects.CrossFadeNode.IsCrossFadeNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.CrossFadeNode.CrossFadeNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.CrossFadeNode.CrossFadeNode


-- | A render node that copies the current state of the rendering canvas so
--   a <a>PasteNode</a> can draw it.
--   
--   <i>Since: 4.22</i>
module GI.Gsk.Objects.CopyNode

-- | Memory-managed wrapper type.
newtype CopyNode
CopyNode :: ManagedPtr CopyNode -> CopyNode

-- | Type class for types which can be safely cast to <a>CopyNode</a>, for
--   instance with <a>toCopyNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf CopyNode o) => IsCopyNode o

-- | Cast to <a>CopyNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toCopyNode :: (MonadIO m, IsCopyNode o) => o -> m CopyNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.22</i>
copyNodeGetChild :: (HasCallStack, MonadIO m, IsCopyNode a) => a -> m RenderNode

-- | Creates a <tt>GskRenderNode</tt> that copies the current rendering
--   canvas for playback by paste nodes that are part of the child.
--   
--   <i>Since: 4.22</i>
copyNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> m CopyNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.CopyNode.CopyNode
instance GHC.Classes.Eq GI.Gsk.Objects.CopyNode.CopyNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.CopyNode.CopyNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.CopyNode.CopyNode o) => GI.Gsk.Objects.CopyNode.IsCopyNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.CopyNode.CopyNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.CopyNode.CopyNode


-- | A render node that can contain other render nodes.
module GI.Gsk.Objects.ContainerNode

-- | Memory-managed wrapper type.
newtype ContainerNode
ContainerNode :: ManagedPtr ContainerNode -> ContainerNode

-- | Type class for types which can be safely cast to <a>ContainerNode</a>,
--   for instance with <a>toContainerNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ContainerNode o) => IsContainerNode o

-- | Cast to <a>ContainerNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toContainerNode :: (MonadIO m, IsContainerNode o) => o -> m ContainerNode

-- | Gets one of the children of <i><tt>container</tt></i>.
containerNodeGetChild :: (HasCallStack, MonadIO m, IsContainerNode a) => a -> Word32 -> m RenderNode

-- | Retrieves the number of direct children of <i><tt>node</tt></i>.
containerNodeGetNChildren :: (HasCallStack, MonadIO m, IsContainerNode a) => a -> m Word32

-- | Creates a new <tt>GskRenderNode</tt> instance for holding the given
--   <i><tt>children</tt></i>.
--   
--   The new node will acquire a reference to each of the children.
containerNodeNew :: (HasCallStack, MonadIO m) => [RenderNode] -> m ContainerNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ContainerNode.ContainerNode
instance GHC.Classes.Eq GI.Gsk.Objects.ContainerNode.ContainerNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ContainerNode.ContainerNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ContainerNode.ContainerNode o) => GI.Gsk.Objects.ContainerNode.IsContainerNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ContainerNode.ContainerNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ContainerNode.ContainerNode


-- | A render node for a conic gradient.
module GI.Gsk.Objects.ConicGradientNode

-- | Memory-managed wrapper type.
newtype ConicGradientNode
ConicGradientNode :: ManagedPtr ConicGradientNode -> ConicGradientNode

-- | Type class for types which can be safely cast to
--   <a>ConicGradientNode</a>, for instance with
--   <a>toConicGradientNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ConicGradientNode o) => IsConicGradientNode o

-- | Cast to <a>ConicGradientNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toConicGradientNode :: (MonadIO m, IsConicGradientNode o) => o -> m ConicGradientNode

-- | Retrieves the angle for the gradient in radians, normalized in [0, 2 *
--   PI].
--   
--   The angle is starting at the top and going clockwise, as expressed in
--   the css specification:
--   
--   angle = 90 - <a>conicGradientNodeGetRotation</a>
--   
--   <i>Since: 4.2</i>
conicGradientNodeGetAngle :: (HasCallStack, MonadIO m, IsConicGradientNode a) => a -> m Float

-- | Retrieves the center pointer for the gradient.
conicGradientNodeGetCenter :: (HasCallStack, MonadIO m, IsConicGradientNode a) => a -> m Point

-- | Retrieves the color stops in the gradient.
conicGradientNodeGetColorStops :: (HasCallStack, MonadIO m, IsConicGradientNode a) => a -> m [ColorStop]

-- | Retrieves the number of color stops in the gradient.
conicGradientNodeGetNColorStops :: (HasCallStack, MonadIO m, IsConicGradientNode a) => a -> m CSize

-- | Retrieves the rotation for the gradient in degrees.
conicGradientNodeGetRotation :: (HasCallStack, MonadIO m, IsConicGradientNode a) => a -> m Float

-- | Creates a <tt>GskRenderNode</tt> that draws a conic gradient.
--   
--   The conic gradient starts around <i><tt>center</tt></i> in the
--   direction of <i><tt>rotation</tt></i>. A rotation of 0 means that the
--   gradient points up. Color stops are then added clockwise.
conicGradientNodeNew :: (HasCallStack, MonadIO m) => Rect -> Point -> Float -> [ColorStop] -> m ConicGradientNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ConicGradientNode.ConicGradientNode
instance GHC.Classes.Eq GI.Gsk.Objects.ConicGradientNode.ConicGradientNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ConicGradientNode.ConicGradientNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ConicGradientNode.ConicGradientNode o) => GI.Gsk.Objects.ConicGradientNode.IsConicGradientNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ConicGradientNode.ConicGradientNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ConicGradientNode.ConicGradientNode


-- | A render node that uses Porter/Duff compositing operators to combine
--   its child with the background.
--   
--   <i>Since: 4.22</i>
module GI.Gsk.Objects.CompositeNode

-- | Memory-managed wrapper type.
newtype CompositeNode
CompositeNode :: ManagedPtr CompositeNode -> CompositeNode

-- | Type class for types which can be safely cast to <a>CompositeNode</a>,
--   for instance with <a>toCompositeNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf CompositeNode o) => IsCompositeNode o

-- | Cast to <a>CompositeNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCompositeNode :: (MonadIO m, IsCompositeNode o) => o -> m CompositeNode

-- | Gets the child node that is getting composited by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.22</i>
compositeNodeGetChild :: (HasCallStack, MonadIO m, IsCompositeNode a) => a -> m RenderNode

-- | Gets the mask node that describes the region where the compositing
--   applies.
--   
--   <i>Since: 4.22</i>
compositeNodeGetMask :: (HasCallStack, MonadIO m, IsCompositeNode a) => a -> m RenderNode

-- | Gets the compositing operator used by this node.
--   
--   <i>Since: 4.22</i>
compositeNodeGetOperator :: (HasCallStack, MonadIO m, IsCompositeNode a) => a -> m PorterDuff

-- | Creates a <tt>GskRenderNode</tt> that will composite the child onto
--   the background with the given operator wherever the mask is set.
--   
--   Note that various operations can modify the background outside of the
--   child's bounds, so the mask may cause visual changes outside of the
--   child.
--   
--   <i>Since: 4.22</i>
compositeNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a, IsRenderNode b) => a -> b -> PorterDuff -> m CompositeNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.CompositeNode.CompositeNode
instance GHC.Classes.Eq GI.Gsk.Objects.CompositeNode.CompositeNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.CompositeNode.CompositeNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.CompositeNode.CompositeNode o) => GI.Gsk.Objects.CompositeNode.IsCompositeNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.CompositeNode.CompositeNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.CompositeNode.CompositeNode


-- | A render node for applying a <tt>GskComponentTransfer</tt> for each
--   color component of the child node.
--   
--   <i>Since: 4.20</i>
module GI.Gsk.Objects.ComponentTransferNode

-- | Memory-managed wrapper type.
newtype ComponentTransferNode
ComponentTransferNode :: ManagedPtr ComponentTransferNode -> ComponentTransferNode

-- | Type class for types which can be safely cast to
--   <a>ComponentTransferNode</a>, for instance with
--   <a>toComponentTransferNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ComponentTransferNode o) => IsComponentTransferNode o

-- | Cast to <a>ComponentTransferNode</a>, for types for which this is
--   known to be safe. For general casts, use <a>castTo</a>.
toComponentTransferNode :: (MonadIO m, IsComponentTransferNode o) => o -> m ComponentTransferNode

-- | Gets the child node that is getting drawn by the given
--   <i><tt>node</tt></i>.
--   
--   <i>Since: 4.20</i>
componentTransferNodeGetChild :: (HasCallStack, MonadIO m, IsComponentTransferNode a) => a -> m RenderNode

-- | Gets the component transfer for one of the components.
--   
--   <i>Since: 4.20</i>
componentTransferNodeGetTransfer :: (HasCallStack, MonadIO m, IsComponentTransferNode a) => a -> ColorChannel -> m ComponentTransfer

-- | Creates a render node that will apply component transfers to a child
--   node.
--   
--   <i>Since: 4.20</i>
componentTransferNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> ComponentTransfer -> ComponentTransfer -> ComponentTransfer -> ComponentTransfer -> m ComponentTransferNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode
instance GHC.Classes.Eq GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode o) => GI.Gsk.Objects.ComponentTransferNode.IsComponentTransferNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ComponentTransferNode.ComponentTransferNode


-- | A render node for a solid color.
module GI.Gsk.Objects.ColorNode

-- | Memory-managed wrapper type.
newtype ColorNode
ColorNode :: ManagedPtr ColorNode -> ColorNode

-- | Type class for types which can be safely cast to <a>ColorNode</a>, for
--   instance with <a>toColorNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ColorNode o) => IsColorNode o

-- | Cast to <a>ColorNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toColorNode :: (MonadIO m, IsColorNode o) => o -> m ColorNode

-- | Retrieves the color of the given <i><tt>node</tt></i>.
--   
--   The value returned by this function will not be correct if the render
--   node was created for a non-sRGB color.
colorNodeGetColor :: (HasCallStack, MonadIO m, IsColorNode a) => a -> m RGBA

-- | Creates a <tt>GskRenderNode</tt> that will render the color specified
--   by <i><tt>rgba</tt></i> into the area given by <i><tt>bounds</tt></i>.
colorNodeNew :: (HasCallStack, MonadIO m) => RGBA -> Rect -> m ColorNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ColorNode.ColorNode
instance GHC.Classes.Eq GI.Gsk.Objects.ColorNode.ColorNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ColorNode.ColorNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ColorNode.ColorNode o) => GI.Gsk.Objects.ColorNode.IsColorNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ColorNode.ColorNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ColorNode.ColorNode


-- | A render node controlling the color matrix of its single child node.
module GI.Gsk.Objects.ColorMatrixNode

-- | Memory-managed wrapper type.
newtype ColorMatrixNode
ColorMatrixNode :: ManagedPtr ColorMatrixNode -> ColorMatrixNode

-- | Type class for types which can be safely cast to
--   <a>ColorMatrixNode</a>, for instance with <a>toColorMatrixNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ColorMatrixNode o) => IsColorMatrixNode o

-- | Cast to <a>ColorMatrixNode</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toColorMatrixNode :: (MonadIO m, IsColorMatrixNode o) => o -> m ColorMatrixNode

-- | Gets the child node that is getting its colors modified by the given
--   <i><tt>node</tt></i>.
colorMatrixNodeGetChild :: (HasCallStack, MonadIO m, IsColorMatrixNode a) => a -> m RenderNode

-- | Retrieves the color matrix used by the <i><tt>node</tt></i>.
colorMatrixNodeGetColorMatrix :: (HasCallStack, MonadIO m, IsColorMatrixNode a) => a -> m Matrix

-- | Retrieves the color offset used by the <i><tt>node</tt></i>.
colorMatrixNodeGetColorOffset :: (HasCallStack, MonadIO m, IsColorMatrixNode a) => a -> m Vec4

-- | Creates a <tt>GskRenderNode</tt> that will drawn the
--   <i><tt>child</tt></i> with <i><tt>colorMatrix</tt></i>.
--   
--   In particular, the node will transform colors by applying
--   
--   pixel = transpose(color_matrix) * pixel + color_offset
--   
--   for every pixel. The transformation operates on unpremultiplied
--   colors, with color components ordered R, G, B, A.
colorMatrixNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Matrix -> Vec4 -> m ColorMatrixNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode
instance GHC.Classes.Eq GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode o) => GI.Gsk.Objects.ColorMatrixNode.IsColorMatrixNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ColorMatrixNode.ColorMatrixNode


-- | A render node applying a rectangular clip to its single child node.
module GI.Gsk.Objects.ClipNode

-- | Memory-managed wrapper type.
newtype ClipNode
ClipNode :: ManagedPtr ClipNode -> ClipNode

-- | Type class for types which can be safely cast to <a>ClipNode</a>, for
--   instance with <a>toClipNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf ClipNode o) => IsClipNode o

-- | Cast to <a>ClipNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toClipNode :: (MonadIO m, IsClipNode o) => o -> m ClipNode

-- | Gets the child node that is getting clipped by the given
--   <i><tt>node</tt></i>.
clipNodeGetChild :: (HasCallStack, MonadIO m, IsClipNode a) => a -> m RenderNode

-- | Retrieves the clip rectangle for <i><tt>node</tt></i>.
clipNodeGetClip :: (HasCallStack, MonadIO m, IsClipNode a) => a -> m Rect

-- | Creates a <tt>GskRenderNode</tt> that will clip the
--   <i><tt>child</tt></i> to the area given by <i><tt>clip</tt></i>.
clipNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Rect -> m ClipNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.ClipNode.ClipNode
instance GHC.Classes.Eq GI.Gsk.Objects.ClipNode.ClipNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.ClipNode.ClipNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.ClipNode.ClipNode o) => GI.Gsk.Objects.ClipNode.IsClipNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.ClipNode.ClipNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.ClipNode.ClipNode


-- | Renders a GSK rendernode tree with cairo.
--   
--   Since it is using cairo, this renderer cannot support 3D
--   transformations.
module GI.Gsk.Objects.CairoRenderer

-- | Memory-managed wrapper type.
newtype CairoRenderer
CairoRenderer :: ManagedPtr CairoRenderer -> CairoRenderer

-- | Type class for types which can be safely cast to <a>CairoRenderer</a>,
--   for instance with <a>toCairoRenderer</a>.
class (GObject o, IsDescendantOf CairoRenderer o) => IsCairoRenderer o

-- | Cast to <a>CairoRenderer</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCairoRenderer :: (MonadIO m, IsCairoRenderer o) => o -> m CairoRenderer

-- | Creates a new Cairo renderer.
--   
--   The Cairo renderer is the fallback renderer drawing in ways similar to
--   how GTK 3 drew its content. Its primary use is as comparison tool.
--   
--   The Cairo renderer is incomplete. It cannot render 3D transformed
--   content and will instead render an error marker. Its usage should be
--   avoided.
cairoRendererNew :: (HasCallStack, MonadIO m) => m CairoRenderer
instance GHC.Classes.Eq GI.Gsk.Objects.CairoRenderer.CairoRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.CairoRenderer.CairoRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.CairoRenderer.CairoRenderer
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.CairoRenderer.CairoRenderer o) => GI.Gsk.Objects.CairoRenderer.IsCairoRenderer o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.CairoRenderer.CairoRenderer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.CairoRenderer.CairoRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.CairoRenderer.CairoRenderer


-- | A render node for a Cairo surface.
module GI.Gsk.Objects.CairoNode

-- | Memory-managed wrapper type.
newtype CairoNode
CairoNode :: ManagedPtr CairoNode -> CairoNode

-- | Type class for types which can be safely cast to <a>CairoNode</a>, for
--   instance with <a>toCairoNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf CairoNode o) => IsCairoNode o

-- | Cast to <a>CairoNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toCairoNode :: (MonadIO m, IsCairoNode o) => o -> m CairoNode

-- | Creates a Cairo context for drawing using the surface associated to
--   the render node.
--   
--   If no surface exists yet, a surface will be created optimized for
--   rendering to <i><tt>renderer</tt></i>.
cairoNodeGetDrawContext :: (HasCallStack, MonadIO m, IsCairoNode a) => a -> m Context

-- | Retrieves the Cairo surface used by the render node.
cairoNodeGetSurface :: (HasCallStack, MonadIO m, IsCairoNode a) => a -> m Surface

-- | Creates a <tt>GskRenderNode</tt> that will render a cairo surface into
--   the area given by <i><tt>bounds</tt></i>.
--   
--   You can draw to the cairo surface using
--   <a>cairoNodeGetDrawContext</a>.
cairoNodeNew :: (HasCallStack, MonadIO m) => Rect -> m CairoNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.CairoNode.CairoNode
instance GHC.Classes.Eq GI.Gsk.Objects.CairoNode.CairoNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.CairoNode.CairoNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.CairoNode.CairoNode o) => GI.Gsk.Objects.CairoNode.IsCairoNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.CairoNode.CairoNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.CairoNode.CairoNode


-- | A Broadway based renderer.
--   
--   See <a>Renderer</a>.
module GI.Gsk.Objects.BroadwayRenderer

-- | Memory-managed wrapper type.
newtype BroadwayRenderer
BroadwayRenderer :: ManagedPtr BroadwayRenderer -> BroadwayRenderer

-- | Type class for types which can be safely cast to
--   <a>BroadwayRenderer</a>, for instance with <a>toBroadwayRenderer</a>.
class (GObject o, IsDescendantOf BroadwayRenderer o) => IsBroadwayRenderer o

-- | Cast to <a>BroadwayRenderer</a>, for types for which this is known to
--   be safe. For general casts, use <a>castTo</a>.
toBroadwayRenderer :: (MonadIO m, IsBroadwayRenderer o) => o -> m BroadwayRenderer

-- | Creates a new Broadway renderer.
--   
--   The Broadway renderer is the default renderer for the broadway
--   backend. It will only work with broadway surfaces, otherwise it will
--   fail the call to <a>rendererRealize</a>.
--   
--   This function is only available when GTK was compiled with Broadway
--   support.

-- | <i>Deprecated: (Since version 4.20)Broadway will be retired in GTK
--   5</i>
broadwayRendererNew :: (HasCallStack, MonadIO m) => m BroadwayRenderer
instance GHC.Classes.Eq GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer
instance Data.GI.Base.BasicTypes.GObject GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer
instance (Data.GI.Base.BasicTypes.GObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer o) => GI.Gsk.Objects.BroadwayRenderer.IsBroadwayRenderer o
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.BroadwayRenderer.BroadwayRenderer


-- | A render node for a border.
module GI.Gsk.Objects.BorderNode

-- | Memory-managed wrapper type.
newtype BorderNode
BorderNode :: ManagedPtr BorderNode -> BorderNode

-- | Type class for types which can be safely cast to <a>BorderNode</a>,
--   for instance with <a>toBorderNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf BorderNode o) => IsBorderNode o

-- | Cast to <a>BorderNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBorderNode :: (MonadIO m, IsBorderNode o) => o -> m BorderNode

-- | Retrieves the colors of the border.
borderNodeGetColors :: (HasCallStack, MonadIO m, IsBorderNode a) => a -> m [RGBA]

-- | Retrieves the outline of the border.
borderNodeGetOutline :: (HasCallStack, MonadIO m, IsBorderNode a) => a -> m RoundedRect

-- | Retrieves the stroke widths of the border.
borderNodeGetWidths :: (HasCallStack, MonadIO m, IsBorderNode a) => a -> m [Float]

-- | Creates a <tt>GskRenderNode</tt> that will stroke a border rectangle
--   inside the given <i><tt>outline</tt></i>.
--   
--   The 4 sides of the border can have different widths and colors.
borderNodeNew :: (HasCallStack, MonadIO m) => RoundedRect -> [Float] -> [RGBA] -> m BorderNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.BorderNode.BorderNode
instance GHC.Classes.Eq GI.Gsk.Objects.BorderNode.BorderNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.BorderNode.BorderNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.BorderNode.BorderNode o) => GI.Gsk.Objects.BorderNode.IsBorderNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.BorderNode.BorderNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.BorderNode.BorderNode


-- | A render node applying a blur effect to its single child.
module GI.Gsk.Objects.BlurNode

-- | Memory-managed wrapper type.
newtype BlurNode
BlurNode :: ManagedPtr BlurNode -> BlurNode

-- | Type class for types which can be safely cast to <a>BlurNode</a>, for
--   instance with <a>toBlurNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf BlurNode o) => IsBlurNode o

-- | Cast to <a>BlurNode</a>, for types for which this is known to be safe.
--   For general casts, use <a>castTo</a>.
toBlurNode :: (MonadIO m, IsBlurNode o) => o -> m BlurNode

-- | Retrieves the child <tt>GskRenderNode</tt> of the blur
--   <i><tt>node</tt></i>.
blurNodeGetChild :: (HasCallStack, MonadIO m, IsBlurNode a) => a -> m RenderNode

-- | Retrieves the blur radius of the <i><tt>node</tt></i>.
blurNodeGetRadius :: (HasCallStack, MonadIO m, IsBlurNode a) => a -> m Float

-- | Creates a render node that blurs the child.
blurNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Float -> m BlurNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.BlurNode.BlurNode
instance GHC.Classes.Eq GI.Gsk.Objects.BlurNode.BlurNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.BlurNode.BlurNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.BlurNode.BlurNode o) => GI.Gsk.Objects.BlurNode.IsBlurNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.BlurNode.BlurNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.BlurNode.BlurNode


-- | A render node applying a blending function between its two child
--   nodes.
module GI.Gsk.Objects.BlendNode

-- | Memory-managed wrapper type.
newtype BlendNode
BlendNode :: ManagedPtr BlendNode -> BlendNode

-- | Type class for types which can be safely cast to <a>BlendNode</a>, for
--   instance with <a>toBlendNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf BlendNode o) => IsBlendNode o

-- | Cast to <a>BlendNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toBlendNode :: (MonadIO m, IsBlendNode o) => o -> m BlendNode

-- | Retrieves the blend mode used by <i><tt>node</tt></i>.
blendNodeGetBlendMode :: (HasCallStack, MonadIO m, IsBlendNode a) => a -> m BlendMode

-- | Retrieves the bottom <tt>GskRenderNode</tt> child of the
--   <i><tt>node</tt></i>.
blendNodeGetBottomChild :: (HasCallStack, MonadIO m, IsBlendNode a) => a -> m RenderNode

-- | Retrieves the top <tt>GskRenderNode</tt> child of the
--   <i><tt>node</tt></i>.
blendNodeGetTopChild :: (HasCallStack, MonadIO m, IsBlendNode a) => a -> m RenderNode

-- | Creates a <tt>GskRenderNode</tt> that will use
--   <i><tt>blendMode</tt></i> to blend the <i><tt>top</tt></i> node onto
--   the <i><tt>bottom</tt></i> node.
blendNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a, IsRenderNode b) => a -> b -> BlendMode -> m BlendNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.BlendNode.BlendNode
instance GHC.Classes.Eq GI.Gsk.Objects.BlendNode.BlendNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.BlendNode.BlendNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.BlendNode.BlendNode o) => GI.Gsk.Objects.BlendNode.IsBlendNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.BlendNode.BlendNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.BlendNode.BlendNode


module GI.Gsk.Functions

-- | Retrieves the render node stored inside a <tt>GValue</tt>, and
--   acquires a reference to it.
--   
--   <i>Since: 4.6</i>
valueDupRenderNode :: (HasCallStack, MonadIO m) => GValue -> m (Maybe RenderNode)

-- | Retrieves the render node stored inside a <tt>GValue</tt>.
--   
--   <i>Since: 4.6</i>
valueGetRenderNode :: (HasCallStack, MonadIO m) => GValue -> m (Maybe RenderNode)

-- | Stores the given render node inside a <tt>GValue</tt>.
--   
--   The <a>Value</a> will acquire a reference to the render node.
--   
--   <i>Since: 4.6</i>
valueSetRenderNode :: (HasCallStack, MonadIO m, IsRenderNode a) => GValue -> a -> m ()

-- | Stores the given render node inside a <tt>GValue</tt>.
--   
--   This function transfers the ownership of the render node to the
--   <tt>GValue</tt>.
--   
--   <i>Since: 4.6</i>
valueTakeRenderNode :: (HasCallStack, MonadIO m, IsRenderNode a) => GValue -> Maybe a -> m ()


-- | Describes a 3D transform.
--   
--   Unlike <tt>graphene_matrix_t</tt>, <tt>GskTransform</tt> retains the
--   steps in how a transform was constructed, and allows inspecting them.
--   It is modeled after the way CSS describes transforms.
--   
--   <tt>GskTransform</tt> objects are immutable and cannot be changed
--   after creation. This means code can safely expose them as properties
--   of objects without having to worry about others changing them.
module GI.Gsk.Structs.Transform

-- | Memory-managed wrapper type.
newtype Transform
Transform :: ManagedPtr Transform -> Transform

-- | Checks two transforms for equality.
transformEqual :: (HasCallStack, MonadIO m) => Maybe Transform -> Maybe Transform -> m Bool

-- | Returns the category this transform belongs to.
transformGetCategory :: (HasCallStack, MonadIO m) => Maybe Transform -> m TransformCategory

-- | Inverts the given transform.
--   
--   If <i><tt>self</tt></i> is not invertible, <tt>NULL</tt> is returned.
--   Note that inverting <tt>NULL</tt> also returns <tt>NULL</tt>, which is
--   the correct inverse of <tt>NULL</tt>. If you need to differentiate
--   between those cases, you should check <i><tt>self</tt></i> is not
--   <tt>NULL</tt> before calling this function.
--   
--   This function consumes <i><tt>self</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformInvert :: (HasCallStack, MonadIO m) => Maybe Transform -> m (Maybe Transform)

-- | Multiplies <i><tt>next</tt></i> with the given <i><tt>matrix</tt></i>.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformMatrix :: (HasCallStack, MonadIO m) => Maybe Transform -> Matrix -> m Transform

-- | Multiplies <i><tt>next</tt></i> with the matrix [ xx yx x0; xy yy y0;
--   0 0 1 ].
--   
--   The result of calling <a>transformTo2d</a> on the returned
--   <a>Transform</a> should match the input passed to this function.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
--   
--   <i>Since: 4.20</i>
transformMatrix2d :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> Float -> Float -> Float -> Float -> Float -> m (Maybe Transform)

-- | Creates a new identity transform.
--   
--   This function is meant to be used by language bindings. For C code,
--   this is equivalent to using <tt>NULL</tt>.
transformNew :: (HasCallStack, MonadIO m) => m Transform

-- | Parses a given into a transform.
--   
--   Strings printed via <a>transformToString</a> can be read in again
--   successfully using this function.
--   
--   If <i><tt>string</tt></i> does not describe a valid transform, false
--   is returned and <tt>NULL</tt> is put in <i><tt>outTransform</tt></i>.
transformParse :: (HasCallStack, MonadIO m) => Text -> m (Bool, Transform)

-- | Applies a perspective projection transform.
--   
--   This transform scales points in X and Y based on their Z value,
--   scaling points with positive Z values away from the origin, and those
--   with negative Z values towards the origin. Points on the z=0 plane are
--   unchanged.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformPerspective :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> m Transform

-- | Converts the transform into a human-readable representation.
--   
--   The result of this function can later be parsed with
--   <a>transformParse</a>.
transformPrint :: (HasCallStack, MonadIO m) => Maybe Transform -> String -> m ()

-- | Acquires a reference on the given transform.
transformRef :: (HasCallStack, MonadIO m) => Maybe Transform -> m (Maybe Transform)

-- | Rotates <i><tt>next</tt></i> by an angle around the Z axis.
--   
--   The rotation happens around the origin point of (0, 0).
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformRotate :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> m (Maybe Transform)

-- | Rotates <i><tt>next</tt></i> <i><tt>angle</tt></i> degrees around
--   <i><tt>axis</tt></i>.
--   
--   For a rotation in 2D space, use <a>transformRotate</a>
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformRotate3d :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> Vec3 -> m (Maybe Transform)

-- | Scales <i><tt>next</tt></i> in 2-dimensional space by the given
--   factors.
--   
--   Use <a>transformScale3d</a> to scale in all 3 dimensions.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformScale :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> Float -> m (Maybe Transform)

-- | Scales <i><tt>next</tt></i> by the given factors.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformScale3d :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> Float -> Float -> m (Maybe Transform)

-- | Applies a skew transform.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
--   
--   <i>Since: 4.6</i>
transformSkew :: (HasCallStack, MonadIO m) => Maybe Transform -> Float -> Float -> m (Maybe Transform)

-- | Converts a transform to a 2D transformation matrix.
--   
--   <i><tt>self</tt></i> must be a 2D transformation. If you are not sure,
--   use
--   
--   <a>transformGetCategory</a> &gt;= GSK_TRANSFORM_CATEGORY_2D
--   
--   to check.
--   
--   The returned values are a subset of the full 4x4 matrix that is
--   computed by <a>transformToMatrix</a> and have the following layout:
--   
--   <pre>
--   | xx yx |   |  a  b  0 |
--   | xy yy | = |  c  d  0 |
--   | dx dy |   | tx ty  1 |
--   </pre>
--   
--   This function can be used to convert between a <tt>GskTransform</tt>
--   and a matrix type from other 2D drawing libraries, in particular
--   Cairo.
transformTo2d :: (HasCallStack, MonadIO m) => Transform -> m (Float, Float, Float, Float, Float, Float)

-- | Converts a transform to 2D transformation factors.
--   
--   To recreate an equivalent transform from the factors returned by this
--   function, use
--   
--   gsk_transform_skew ( gsk_transform_scale ( gsk_transform_rotate (
--   gsk_transform_translate (NULL, &amp;GRAPHENE_POINT_INIT (dx, dy)),
--   angle), scale_x, scale_y), skew_x, skew_y)
--   
--   <i><tt>self</tt></i> must be a 2D transformation. If you are not sure,
--   use
--   
--   <a>transformGetCategory</a> &gt;= GSK_TRANSFORM_CATEGORY_2D
--   
--   to check.
--   
--   <i>Since: 4.6</i>
transformTo2dComponents :: (HasCallStack, MonadIO m) => Transform -> m (Float, Float, Float, Float, Float, Float, Float)

-- | Converts a transform to 2D affine transformation factors.
--   
--   To recreate an equivalent transform from the factors returned by this
--   function, use
--   
--   gsk_transform_scale ( gsk_transform_translate ( NULL,
--   &amp;GRAPHENE_POINT_T (dx, dy)), sx, sy)
--   
--   <i><tt>self</tt></i> must be a 2D affine transformation. If you are
--   not sure, use
--   
--   <a>transformGetCategory</a> &gt;= GSK_TRANSFORM_CATEGORY_2D_AFFINE
--   
--   to check.
transformToAffine :: (HasCallStack, MonadIO m) => Transform -> m (Float, Float, Float, Float)

-- | Computes the 4x4 matrix for the transform.
--   
--   The previous value of <i><tt>outMatrix</tt></i> will be ignored.
transformToMatrix :: (HasCallStack, MonadIO m) => Maybe Transform -> m Matrix

-- | Converts the transform into a human-readable string.
--   
--   The resulting string can be parsed with <a>transformParse</a>.
--   
--   This is a wrapper around <a>transformPrint</a>.
transformToString :: (HasCallStack, MonadIO m) => Maybe Transform -> m Text

-- | Converts a transform to a translation operation.
--   
--   <i><tt>self</tt></i> must be a 2D transformation. If you are not sure,
--   use
--   
--   <a>transformGetCategory</a> &gt;= GSK_TRANSFORM_CATEGORY_2D_TRANSLATE
--   
--   to check.
transformToTranslate :: (HasCallStack, MonadIO m) => Transform -> m (Float, Float)

-- | Applies all the operations from <i><tt>other</tt></i> to
--   <i><tt>next</tt></i>.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformTransform :: (HasCallStack, MonadIO m) => Maybe Transform -> Maybe Transform -> m (Maybe Transform)

-- | Transforms a rectangle using the given transform.
--   
--   The result is the bounding box containing the coplanar quad.
--   
--   The input and output rect may point to the same rectangle.
transformTransformBounds :: (HasCallStack, MonadIO m) => Transform -> Rect -> m Rect

-- | Transforms a point using the given transform.
transformTransformPoint :: (HasCallStack, MonadIO m) => Transform -> Point -> m Point

-- | Translates <i><tt>next</tt></i> in 2-dimensional space by
--   <i><tt>point</tt></i>.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformTranslate :: (HasCallStack, MonadIO m) => Maybe Transform -> Point -> m (Maybe Transform)

-- | Translates <i><tt>next</tt></i> by <i><tt>point</tt></i>.
--   
--   This function consumes <i><tt>next</tt></i>. Use <a>transformRef</a>
--   first if you want to keep it around.
transformTranslate3d :: (HasCallStack, MonadIO m) => Maybe Transform -> Point3D -> m (Maybe Transform)

-- | Releases a reference on the given transform.
--   
--   If the reference was the last, the resources associated to the
--   <i><tt>self</tt></i> are freed.
transformUnref :: (HasCallStack, MonadIO m) => Maybe Transform -> m ()
instance GHC.Classes.Eq GI.Gsk.Structs.Transform.Transform
instance Data.GI.Base.BasicTypes.GBoxed GI.Gsk.Structs.Transform.Transform
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Structs.Transform.Transform
instance Data.GI.Base.GValue.IsGValue (GHC.Internal.Maybe.Maybe GI.Gsk.Structs.Transform.Transform)
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Structs.Transform.Transform
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Structs.Transform.Transform


module GI.Gsk.Structs


-- | A render node applying a <tt>GskTransform</tt> to its single child
--   node.
module GI.Gsk.Objects.TransformNode

-- | Memory-managed wrapper type.
newtype TransformNode
TransformNode :: ManagedPtr TransformNode -> TransformNode

-- | Type class for types which can be safely cast to <a>TransformNode</a>,
--   for instance with <a>toTransformNode</a>.
class (BoxedPtr o, TypedObject o, IsDescendantOf TransformNode o) => IsTransformNode o

-- | Cast to <a>TransformNode</a>, for types for which this is known to be
--   safe. For general casts, use <a>castTo</a>.
toTransformNode :: (MonadIO m, IsTransformNode o) => o -> m TransformNode

-- | Gets the child node that is getting transformed by the given
--   <i><tt>node</tt></i>.
transformNodeGetChild :: (HasCallStack, MonadIO m, IsTransformNode a) => a -> m RenderNode

-- | Retrieves the <tt>GskTransform</tt> used by the <i><tt>node</tt></i>.
transformNodeGetTransform :: (HasCallStack, MonadIO m, IsTransformNode a) => a -> m Transform

-- | Creates a <tt>GskRenderNode</tt> that will transform the given
--   <i><tt>child</tt></i> with the given <i><tt>transform</tt></i>.
transformNodeNew :: (HasCallStack, MonadIO m, IsRenderNode a) => a -> Maybe Transform -> m TransformNode
instance Data.GI.Base.BasicTypes.BoxedPtr GI.Gsk.Objects.TransformNode.TransformNode
instance GHC.Classes.Eq GI.Gsk.Objects.TransformNode.TransformNode
instance Data.GI.Base.Overloading.HasParentTypes GI.Gsk.Objects.TransformNode.TransformNode
instance (Data.GI.Base.BasicTypes.BoxedPtr o, Data.GI.Base.BasicTypes.TypedObject o, Data.GI.Base.Overloading.IsDescendantOf GI.Gsk.Objects.TransformNode.TransformNode o) => GI.Gsk.Objects.TransformNode.IsTransformNode o
instance Data.GI.Base.BasicTypes.ManagedPtrNewtype GI.Gsk.Objects.TransformNode.TransformNode
instance Data.GI.Base.BasicTypes.TypedObject GI.Gsk.Objects.TransformNode.TransformNode


module GI.Gsk.Objects


module GI.Gsk
