gsk4-0.3.1/.cargo_vcs_info.json0000644000000001120000000000100116770ustar { "git": { "sha1": "55b67a928dad6cfca8e0caaa360953833bd3a0d7" } } gsk4-0.3.1/COPYRIGHT000064400000000000000000000012130072674642500120150ustar 00000000000000The gtk-rs Project is licensed under the MIT license, see the LICENSE file or . Copyrights in the gtk-rs Project project are retained by their contributors. No copyright assignment is required to contribute to the gtk-rs Project project. For full authorship information, see the version control history. This project provides interoperability with various GNOME libraries but doesn't distribute any parts of them. Distributing compiled libraries and executables that link to those libraries may be subject to terms of the GNU LGPL or other licenses. For more information check the license of each GNOME library. gsk4-0.3.1/Cargo.toml0000644000000030760000000000100077110ustar # THIS FILE IS AUTOMATICALLY GENERATED BY CARGO # # When uploading crates to the registry Cargo will automatically # "normalize" Cargo.toml files for maximal compatibility # with all versions of Cargo and also rewrite `path` dependencies # to registry (e.g., crates.io) dependencies # # If you believe there's an error in this file please file an # issue against the rust-lang/cargo repository. If you're # editing this file be aware that the upstream Cargo.toml # will likely look very different (and much more reasonable) [package] edition = "2018" name = "gsk4" version = "0.3.1" authors = ["The gtk-rs Project Developers"] description = "Rust bindings of the GSK 4 library" homepage = "https://gtk-rs.org/" documentation = "https://gtk-rs.org/gtk4-rs/stable/latest/docs/gsk4" readme = "README.md" keywords = ["gsk", "gsk4", "gtk-rs", "gnome", "GUI"] license = "MIT" repository = "https://github.com/gtk-rs/gtk4-rs" [package.metadata.docs.rs] features = ["dox"] [lib] name = "gsk4" [dependencies.bitflags] version = "1.0" [dependencies.cairo-rs] version = "0.14" [dependencies.ffi] version = "0.3" package = "gsk4-sys" [dependencies.gdk] version = "0.3" package = "gdk4" [dependencies.glib] version = "0.14" features = ["v2_66"] [dependencies.graphene] version = "0.14" package = "graphene-rs" [dependencies.libc] version = "0.2" [dependencies.pango] version = "0.14" features = ["v1_46"] [dev-dependencies.gir-format-check] version = "^0.1" [features] broadway = [] dox = ["ffi/dox", "gdk/dox", "graphene/dox", "glib/dox", "cairo-rs/dox", "pango/dox"] v4_2 = ["ffi/v4_2", "gdk/v4_2"] gsk4-0.3.1/Cargo.toml.orig000064400000000000000000000017530072674642500134220ustar 00000000000000[package] authors = ["The gtk-rs Project Developers"] description = "Rust bindings of the GSK 4 library" documentation = "https://gtk-rs.org/gtk4-rs/stable/latest/docs/gsk4" edition = "2018" homepage = "https://gtk-rs.org/" keywords = ["gsk", "gsk4", "gtk-rs", "gnome", "GUI"] license = "MIT" name = "gsk4" readme = "README.md" repository = "https://github.com/gtk-rs/gtk4-rs" version = "0.3.1" [lib] name = "gsk4" [features] broadway = [] dox = ["ffi/dox", "gdk/dox", "graphene/dox", "glib/dox", "cairo-rs/dox", "pango/dox"] v4_2 = ["ffi/v4_2", "gdk/v4_2"] [package.metadata.docs.rs] features = ["dox"] [dependencies] bitflags = "1.0" cairo-rs = {version = "0.14"} ffi = {package = "gsk4-sys", path = "./sys", version = "0.3"} gdk = {package = "gdk4", path = "../gdk4", version = "0.3"} glib = {version = "0.14", features = ["v2_66"]} graphene = {package = "graphene-rs", version = "0.14"} libc = "0.2" pango = {version = "0.14", features = ["v1_46"]} [dev-dependencies] gir-format-check = "^0.1" gsk4-0.3.1/Gir.toml000064400000000000000000000071210072674642500121440ustar 00000000000000[options] girs_directories = ["../gir-files"] library = "Gsk" version = "4.0" min_cfg_version = "4.0.0" target_path = "." work_mode = "normal" generate_safety_asserts = true single_version_file = true deprecate_by_min_version = true generate = [ "Gsk.BlendMode", "Gsk.CairoRenderer", "Gsk.Corner", "Gsk.GLRenderer", "Gsk.GLUniformType", "Gsk.RenderNodeType", "Gsk.ScalingFilter", "Gsk.SerializationError", "Gsk.ShaderArgsBuilder", "Gsk.TransformCategory", ] manual = [ "cairo.Context", "cairo.Region", "cairo.Surface", "Gdk.RGBA", "Gdk.Surface", "Gdk.Texture", "Gio.File", # docs specific "GLib.Bytes", "GLib.Error", "GLib.Quark", "GLib.String", "Graphene.Matrix", "Graphene.Point", "Graphene.Point3D", "Graphene.Rect", "Graphene.Size", "Graphene.Vec2", "Graphene.Vec3", "Graphene.Vec4", "Gsk.BlendNode", "Gsk.BlurNode", "Gsk.BorderNode", "Gsk.CairoNode", "Gsk.ClipNode", "Gsk.ColorMatrixNode", "Gsk.ColorNode", "Gsk.ColorStop", "Gsk.ConicGradientNode", "Gsk.ContainerNode", "Gsk.CrossFadeNode", "Gsk.DebugNode", "Gsk.GLShaderNode", "Gsk.InsetShadowNode", "Gsk.LinearGradientNode", "Gsk.OpacityNode", "Gsk.OutsetShadowNode", "Gsk.ParseLocation", "Gsk.RadialGradientNode", "Gsk.RepeatingLinearGradientNode", "Gsk.RepeatingRadialGradientNode", "Gsk.RepeatNode", "Gsk.RoundedClipNode", "Gsk.RoundedRect", "Gsk.Shadow", "Gsk.ShadowNode", "Gsk.TextNode", "Gsk.TextureNode", "Gsk.TransformNode", "Gtk.Snapshot", # docs specific "Pango.Font", "Pango.GlyphInfo", "Pango.GlyphString", ] [[object]] name = "Gsk.*" status = "generate" [[object]] name = "Gsk.BroadwayRenderer" status = "generate" cfg_condition = "feature = \"broadway\"" [[object]] name = "Gsk.GLShader" status = "generate" generate_builder = true [[object.function]] name = "get_arg_bool" # Retrieves the boolean value of an arg rename = "arg_bool" [[object.function]] name = "format_args_va" ignore = true # not useful for bindings [[object.function]] name = "format_args" ignore = true # TODO: fix me once varargs are supported [[object.function]] name = "get_arg_vec2" manual = true # TODO: fix me once (https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/3744) is merged [[object.function]] name = "get_arg_vec3" manual = true # TODO: fix me once (https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/3744) is merged [[object.function]] name = "get_arg_vec4" manual = true # TODO: fix me once (https://gitlab.gnome.org/GNOME/gtk/-/merge_requests/3744) is merged [[object]] name = "Gsk.NglRenderer" status = "generate" version = "4.2" [[object]] name = "Gsk.Renderer" status = "generate" manual_traits = ["RendererExtManual"] [[object.function]] name = "render" # uses IsA but RenderNode is not an Object manual = true doc_trait_name = "RendererExtManual" [[object.function]] name = "render_texture" # uses IsA but RenderNode is not an Object manual = true doc_trait_name = "RendererExtManual" [[object]] name = "Gsk.RenderNode" status = "manual" # fundemental type final_type = true # avoids the usage of RenderNodeExt trait [[object]] name = "Gsk.Transform" status = "generate" [[object.function]] name = "equal" [[object.function.parameter]] name = "second" nullable = false [[object.function]] name = "print" ignore = true # Same as Transform::to_string gsk4-0.3.1/LICENSE000064400000000000000000000020000072674642500115220ustar 00000000000000Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions: The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software. THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE. gsk4-0.3.1/README.md000064400000000000000000000032710072674642500120070ustar 00000000000000# Rust GSK 4 bindings The project website is [here](https://gtk-rs.org/). Rust bindings of [GSK 4](https://docs.gtk.org/gsk4/), part of [gtk4-rs](https://github.com/gtk-rs/gtk4-rs/). GSK is an intermediate layer that isolates GTK from the details of the OpenGL or Vulkan implementation. ## Minimum supported Rust version Currently, the minimum supported Rust version is `1.54.0`. ## Documentation - The Rust API [Stable](https://gtk-rs.org/gtk4-rs/stable/latest/docs/gsk4)/[Development](https://gtk-rs.org/gtk4-rs/git/docs/gsk4/) - [The C API](https://docs.gtk.org/gsk4/) - [GTK Installation instructions](https://www.gtk.org/docs/installations/) ## Using We recommend using [crates from crates.io](https://crates.io/keywords/gtk-rs), as [demonstrated here](https://gtk-rs.org/gtk4-rs/stable/latest/docs/gtk4/index.html#library-versions). If you want to track the bleeding edge, use the git dependency instead: ```toml [dependencies] gsk = { git = "https://github.com/gtk-rs/gtk4-rs.git", package = "gsk4" } ``` Avoid mixing versioned and git crates like this: ```toml # This will not compile [dependencies] gdk = {version = "0.1", package = "gdk4"} gsk = { git = "https://github.com/gtk-rs/gtk4-rs.git", package = "gsk4" } ``` ### Features | Feature | Description | | --- | ----------- | | `broadway` | Enable `broadway` Renderer. Only if GTK is compiled with Broadway support | | `v4_2` | Enable the new APIs part of GTK 4.2 | ### See Also - [glib](https://crates.io/crates/glib) - [gio](https://crates.io/crates/gio) - [gdk4](https://crates.io/crates/gdk4) - [gtk4](https://crates.io/crates/gtk4) ## License The Rust bindings of __gsk4__ are available under the MIT License, please refer to it. gsk4-0.3.1/src/auto/broadway_renderer.rs000064400000000000000000000017240072674642500163340ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::Renderer; use glib::object::Cast; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "GskBroadwayRenderer")] pub struct BroadwayRenderer(Object) @extends Renderer; match fn { type_ => || ffi::gsk_broadway_renderer_get_type(), } } impl BroadwayRenderer { #[doc(alias = "gsk_broadway_renderer_new")] pub fn new() -> BroadwayRenderer { assert_initialized_main_thread!(); unsafe { Renderer::from_glib_full(ffi::gsk_broadway_renderer_new()).unsafe_cast() } } } impl Default for BroadwayRenderer { fn default() -> Self { Self::new() } } impl fmt::Display for BroadwayRenderer { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("BroadwayRenderer") } } gsk4-0.3.1/src/auto/cairo_renderer.rs000064400000000000000000000016600072674642500156200ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::Renderer; use glib::object::Cast; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "GskCairoRenderer")] pub struct CairoRenderer(Object) @extends Renderer; match fn { type_ => || ffi::gsk_cairo_renderer_get_type(), } } impl CairoRenderer { #[doc(alias = "gsk_cairo_renderer_new")] pub fn new() -> CairoRenderer { assert_initialized_main_thread!(); unsafe { Renderer::from_glib_full(ffi::gsk_cairo_renderer_new()).unsafe_cast() } } } impl Default for CairoRenderer { fn default() -> Self { Self::new() } } impl fmt::Display for CairoRenderer { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("CairoRenderer") } } gsk4-0.3.1/src/auto/enums.rs000064400000000000000000000707750072674642500140010ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use glib::error::ErrorDomain; use glib::translate::*; use glib::value::FromValue; use glib::value::ToValue; use glib::Quark; use glib::StaticType; use glib::Type; use std::fmt; #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskBlendMode")] pub enum BlendMode { #[doc(alias = "GSK_BLEND_MODE_DEFAULT")] Default, #[doc(alias = "GSK_BLEND_MODE_MULTIPLY")] Multiply, #[doc(alias = "GSK_BLEND_MODE_SCREEN")] Screen, #[doc(alias = "GSK_BLEND_MODE_OVERLAY")] Overlay, #[doc(alias = "GSK_BLEND_MODE_DARKEN")] Darken, #[doc(alias = "GSK_BLEND_MODE_LIGHTEN")] Lighten, #[doc(alias = "GSK_BLEND_MODE_COLOR_DODGE")] ColorDodge, #[doc(alias = "GSK_BLEND_MODE_COLOR_BURN")] ColorBurn, #[doc(alias = "GSK_BLEND_MODE_HARD_LIGHT")] HardLight, #[doc(alias = "GSK_BLEND_MODE_SOFT_LIGHT")] SoftLight, #[doc(alias = "GSK_BLEND_MODE_DIFFERENCE")] Difference, #[doc(alias = "GSK_BLEND_MODE_EXCLUSION")] Exclusion, #[doc(alias = "GSK_BLEND_MODE_COLOR")] Color, #[doc(alias = "GSK_BLEND_MODE_HUE")] Hue, #[doc(alias = "GSK_BLEND_MODE_SATURATION")] Saturation, #[doc(alias = "GSK_BLEND_MODE_LUMINOSITY")] Luminosity, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for BlendMode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "BlendMode::{}", match *self { Self::Default => "Default", Self::Multiply => "Multiply", Self::Screen => "Screen", Self::Overlay => "Overlay", Self::Darken => "Darken", Self::Lighten => "Lighten", Self::ColorDodge => "ColorDodge", Self::ColorBurn => "ColorBurn", Self::HardLight => "HardLight", Self::SoftLight => "SoftLight", Self::Difference => "Difference", Self::Exclusion => "Exclusion", Self::Color => "Color", Self::Hue => "Hue", Self::Saturation => "Saturation", Self::Luminosity => "Luminosity", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for BlendMode { type GlibType = ffi::GskBlendMode; fn into_glib(self) -> ffi::GskBlendMode { match self { Self::Default => ffi::GSK_BLEND_MODE_DEFAULT, Self::Multiply => ffi::GSK_BLEND_MODE_MULTIPLY, Self::Screen => ffi::GSK_BLEND_MODE_SCREEN, Self::Overlay => ffi::GSK_BLEND_MODE_OVERLAY, Self::Darken => ffi::GSK_BLEND_MODE_DARKEN, Self::Lighten => ffi::GSK_BLEND_MODE_LIGHTEN, Self::ColorDodge => ffi::GSK_BLEND_MODE_COLOR_DODGE, Self::ColorBurn => ffi::GSK_BLEND_MODE_COLOR_BURN, Self::HardLight => ffi::GSK_BLEND_MODE_HARD_LIGHT, Self::SoftLight => ffi::GSK_BLEND_MODE_SOFT_LIGHT, Self::Difference => ffi::GSK_BLEND_MODE_DIFFERENCE, Self::Exclusion => ffi::GSK_BLEND_MODE_EXCLUSION, Self::Color => ffi::GSK_BLEND_MODE_COLOR, Self::Hue => ffi::GSK_BLEND_MODE_HUE, Self::Saturation => ffi::GSK_BLEND_MODE_SATURATION, Self::Luminosity => ffi::GSK_BLEND_MODE_LUMINOSITY, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for BlendMode { unsafe fn from_glib(value: ffi::GskBlendMode) -> Self { skip_assert_initialized!(); match value { ffi::GSK_BLEND_MODE_DEFAULT => Self::Default, ffi::GSK_BLEND_MODE_MULTIPLY => Self::Multiply, ffi::GSK_BLEND_MODE_SCREEN => Self::Screen, ffi::GSK_BLEND_MODE_OVERLAY => Self::Overlay, ffi::GSK_BLEND_MODE_DARKEN => Self::Darken, ffi::GSK_BLEND_MODE_LIGHTEN => Self::Lighten, ffi::GSK_BLEND_MODE_COLOR_DODGE => Self::ColorDodge, ffi::GSK_BLEND_MODE_COLOR_BURN => Self::ColorBurn, ffi::GSK_BLEND_MODE_HARD_LIGHT => Self::HardLight, ffi::GSK_BLEND_MODE_SOFT_LIGHT => Self::SoftLight, ffi::GSK_BLEND_MODE_DIFFERENCE => Self::Difference, ffi::GSK_BLEND_MODE_EXCLUSION => Self::Exclusion, ffi::GSK_BLEND_MODE_COLOR => Self::Color, ffi::GSK_BLEND_MODE_HUE => Self::Hue, ffi::GSK_BLEND_MODE_SATURATION => Self::Saturation, ffi::GSK_BLEND_MODE_LUMINOSITY => Self::Luminosity, value => Self::__Unknown(value), } } } impl StaticType for BlendMode { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_blend_mode_get_type()) } } } impl glib::value::ValueType for BlendMode { type Type = Self; } unsafe impl<'a> FromValue<'a> for BlendMode { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for BlendMode { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskCorner")] pub enum Corner { #[doc(alias = "GSK_CORNER_TOP_LEFT")] TopLeft, #[doc(alias = "GSK_CORNER_TOP_RIGHT")] TopRight, #[doc(alias = "GSK_CORNER_BOTTOM_RIGHT")] BottomRight, #[doc(alias = "GSK_CORNER_BOTTOM_LEFT")] BottomLeft, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for Corner { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "Corner::{}", match *self { Self::TopLeft => "TopLeft", Self::TopRight => "TopRight", Self::BottomRight => "BottomRight", Self::BottomLeft => "BottomLeft", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for Corner { type GlibType = ffi::GskCorner; fn into_glib(self) -> ffi::GskCorner { match self { Self::TopLeft => ffi::GSK_CORNER_TOP_LEFT, Self::TopRight => ffi::GSK_CORNER_TOP_RIGHT, Self::BottomRight => ffi::GSK_CORNER_BOTTOM_RIGHT, Self::BottomLeft => ffi::GSK_CORNER_BOTTOM_LEFT, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for Corner { unsafe fn from_glib(value: ffi::GskCorner) -> Self { skip_assert_initialized!(); match value { ffi::GSK_CORNER_TOP_LEFT => Self::TopLeft, ffi::GSK_CORNER_TOP_RIGHT => Self::TopRight, ffi::GSK_CORNER_BOTTOM_RIGHT => Self::BottomRight, ffi::GSK_CORNER_BOTTOM_LEFT => Self::BottomLeft, value => Self::__Unknown(value), } } } impl StaticType for Corner { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_corner_get_type()) } } } impl glib::value::ValueType for Corner { type Type = Self; } unsafe impl<'a> FromValue<'a> for Corner { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for Corner { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskGLUniformType")] pub enum GLUniformType { #[doc(alias = "GSK_GL_UNIFORM_TYPE_NONE")] None, #[doc(alias = "GSK_GL_UNIFORM_TYPE_FLOAT")] Float, #[doc(alias = "GSK_GL_UNIFORM_TYPE_INT")] Int, #[doc(alias = "GSK_GL_UNIFORM_TYPE_UINT")] Uint, #[doc(alias = "GSK_GL_UNIFORM_TYPE_BOOL")] Bool, #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC2")] Vec2, #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC3")] Vec3, #[doc(alias = "GSK_GL_UNIFORM_TYPE_VEC4")] Vec4, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for GLUniformType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "GLUniformType::{}", match *self { Self::None => "None", Self::Float => "Float", Self::Int => "Int", Self::Uint => "Uint", Self::Bool => "Bool", Self::Vec2 => "Vec2", Self::Vec3 => "Vec3", Self::Vec4 => "Vec4", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for GLUniformType { type GlibType = ffi::GskGLUniformType; fn into_glib(self) -> ffi::GskGLUniformType { match self { Self::None => ffi::GSK_GL_UNIFORM_TYPE_NONE, Self::Float => ffi::GSK_GL_UNIFORM_TYPE_FLOAT, Self::Int => ffi::GSK_GL_UNIFORM_TYPE_INT, Self::Uint => ffi::GSK_GL_UNIFORM_TYPE_UINT, Self::Bool => ffi::GSK_GL_UNIFORM_TYPE_BOOL, Self::Vec2 => ffi::GSK_GL_UNIFORM_TYPE_VEC2, Self::Vec3 => ffi::GSK_GL_UNIFORM_TYPE_VEC3, Self::Vec4 => ffi::GSK_GL_UNIFORM_TYPE_VEC4, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for GLUniformType { unsafe fn from_glib(value: ffi::GskGLUniformType) -> Self { skip_assert_initialized!(); match value { ffi::GSK_GL_UNIFORM_TYPE_NONE => Self::None, ffi::GSK_GL_UNIFORM_TYPE_FLOAT => Self::Float, ffi::GSK_GL_UNIFORM_TYPE_INT => Self::Int, ffi::GSK_GL_UNIFORM_TYPE_UINT => Self::Uint, ffi::GSK_GL_UNIFORM_TYPE_BOOL => Self::Bool, ffi::GSK_GL_UNIFORM_TYPE_VEC2 => Self::Vec2, ffi::GSK_GL_UNIFORM_TYPE_VEC3 => Self::Vec3, ffi::GSK_GL_UNIFORM_TYPE_VEC4 => Self::Vec4, value => Self::__Unknown(value), } } } impl StaticType for GLUniformType { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_gl_uniform_type_get_type()) } } } impl glib::value::ValueType for GLUniformType { type Type = Self; } unsafe impl<'a> FromValue<'a> for GLUniformType { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for GLUniformType { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskRenderNodeType")] pub enum RenderNodeType { #[doc(alias = "GSK_NOT_A_RENDER_NODE")] NotARenderNode, #[doc(alias = "GSK_CONTAINER_NODE")] ContainerNode, #[doc(alias = "GSK_CAIRO_NODE")] CairoNode, #[doc(alias = "GSK_COLOR_NODE")] ColorNode, #[doc(alias = "GSK_LINEAR_GRADIENT_NODE")] LinearGradientNode, #[doc(alias = "GSK_REPEATING_LINEAR_GRADIENT_NODE")] RepeatingLinearGradientNode, #[doc(alias = "GSK_RADIAL_GRADIENT_NODE")] RadialGradientNode, #[doc(alias = "GSK_REPEATING_RADIAL_GRADIENT_NODE")] RepeatingRadialGradientNode, #[doc(alias = "GSK_CONIC_GRADIENT_NODE")] ConicGradientNode, #[doc(alias = "GSK_BORDER_NODE")] BorderNode, #[doc(alias = "GSK_TEXTURE_NODE")] TextureNode, #[doc(alias = "GSK_INSET_SHADOW_NODE")] InsetShadowNode, #[doc(alias = "GSK_OUTSET_SHADOW_NODE")] OutsetShadowNode, #[doc(alias = "GSK_TRANSFORM_NODE")] TransformNode, #[doc(alias = "GSK_OPACITY_NODE")] OpacityNode, #[doc(alias = "GSK_COLOR_MATRIX_NODE")] ColorMatrixNode, #[doc(alias = "GSK_REPEAT_NODE")] RepeatNode, #[doc(alias = "GSK_CLIP_NODE")] ClipNode, #[doc(alias = "GSK_ROUNDED_CLIP_NODE")] RoundedClipNode, #[doc(alias = "GSK_SHADOW_NODE")] ShadowNode, #[doc(alias = "GSK_BLEND_NODE")] BlendNode, #[doc(alias = "GSK_CROSS_FADE_NODE")] CrossFadeNode, #[doc(alias = "GSK_TEXT_NODE")] TextNode, #[doc(alias = "GSK_BLUR_NODE")] BlurNode, #[doc(alias = "GSK_DEBUG_NODE")] DebugNode, #[doc(alias = "GSK_GL_SHADER_NODE")] GlShaderNode, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for RenderNodeType { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "RenderNodeType::{}", match *self { Self::NotARenderNode => "NotARenderNode", Self::ContainerNode => "ContainerNode", Self::CairoNode => "CairoNode", Self::ColorNode => "ColorNode", Self::LinearGradientNode => "LinearGradientNode", Self::RepeatingLinearGradientNode => "RepeatingLinearGradientNode", Self::RadialGradientNode => "RadialGradientNode", Self::RepeatingRadialGradientNode => "RepeatingRadialGradientNode", Self::ConicGradientNode => "ConicGradientNode", Self::BorderNode => "BorderNode", Self::TextureNode => "TextureNode", Self::InsetShadowNode => "InsetShadowNode", Self::OutsetShadowNode => "OutsetShadowNode", Self::TransformNode => "TransformNode", Self::OpacityNode => "OpacityNode", Self::ColorMatrixNode => "ColorMatrixNode", Self::RepeatNode => "RepeatNode", Self::ClipNode => "ClipNode", Self::RoundedClipNode => "RoundedClipNode", Self::ShadowNode => "ShadowNode", Self::BlendNode => "BlendNode", Self::CrossFadeNode => "CrossFadeNode", Self::TextNode => "TextNode", Self::BlurNode => "BlurNode", Self::DebugNode => "DebugNode", Self::GlShaderNode => "GlShaderNode", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for RenderNodeType { type GlibType = ffi::GskRenderNodeType; fn into_glib(self) -> ffi::GskRenderNodeType { match self { Self::NotARenderNode => ffi::GSK_NOT_A_RENDER_NODE, Self::ContainerNode => ffi::GSK_CONTAINER_NODE, Self::CairoNode => ffi::GSK_CAIRO_NODE, Self::ColorNode => ffi::GSK_COLOR_NODE, Self::LinearGradientNode => ffi::GSK_LINEAR_GRADIENT_NODE, Self::RepeatingLinearGradientNode => ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE, Self::RadialGradientNode => ffi::GSK_RADIAL_GRADIENT_NODE, Self::RepeatingRadialGradientNode => ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE, Self::ConicGradientNode => ffi::GSK_CONIC_GRADIENT_NODE, Self::BorderNode => ffi::GSK_BORDER_NODE, Self::TextureNode => ffi::GSK_TEXTURE_NODE, Self::InsetShadowNode => ffi::GSK_INSET_SHADOW_NODE, Self::OutsetShadowNode => ffi::GSK_OUTSET_SHADOW_NODE, Self::TransformNode => ffi::GSK_TRANSFORM_NODE, Self::OpacityNode => ffi::GSK_OPACITY_NODE, Self::ColorMatrixNode => ffi::GSK_COLOR_MATRIX_NODE, Self::RepeatNode => ffi::GSK_REPEAT_NODE, Self::ClipNode => ffi::GSK_CLIP_NODE, Self::RoundedClipNode => ffi::GSK_ROUNDED_CLIP_NODE, Self::ShadowNode => ffi::GSK_SHADOW_NODE, Self::BlendNode => ffi::GSK_BLEND_NODE, Self::CrossFadeNode => ffi::GSK_CROSS_FADE_NODE, Self::TextNode => ffi::GSK_TEXT_NODE, Self::BlurNode => ffi::GSK_BLUR_NODE, Self::DebugNode => ffi::GSK_DEBUG_NODE, Self::GlShaderNode => ffi::GSK_GL_SHADER_NODE, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for RenderNodeType { unsafe fn from_glib(value: ffi::GskRenderNodeType) -> Self { skip_assert_initialized!(); match value { ffi::GSK_NOT_A_RENDER_NODE => Self::NotARenderNode, ffi::GSK_CONTAINER_NODE => Self::ContainerNode, ffi::GSK_CAIRO_NODE => Self::CairoNode, ffi::GSK_COLOR_NODE => Self::ColorNode, ffi::GSK_LINEAR_GRADIENT_NODE => Self::LinearGradientNode, ffi::GSK_REPEATING_LINEAR_GRADIENT_NODE => Self::RepeatingLinearGradientNode, ffi::GSK_RADIAL_GRADIENT_NODE => Self::RadialGradientNode, ffi::GSK_REPEATING_RADIAL_GRADIENT_NODE => Self::RepeatingRadialGradientNode, ffi::GSK_CONIC_GRADIENT_NODE => Self::ConicGradientNode, ffi::GSK_BORDER_NODE => Self::BorderNode, ffi::GSK_TEXTURE_NODE => Self::TextureNode, ffi::GSK_INSET_SHADOW_NODE => Self::InsetShadowNode, ffi::GSK_OUTSET_SHADOW_NODE => Self::OutsetShadowNode, ffi::GSK_TRANSFORM_NODE => Self::TransformNode, ffi::GSK_OPACITY_NODE => Self::OpacityNode, ffi::GSK_COLOR_MATRIX_NODE => Self::ColorMatrixNode, ffi::GSK_REPEAT_NODE => Self::RepeatNode, ffi::GSK_CLIP_NODE => Self::ClipNode, ffi::GSK_ROUNDED_CLIP_NODE => Self::RoundedClipNode, ffi::GSK_SHADOW_NODE => Self::ShadowNode, ffi::GSK_BLEND_NODE => Self::BlendNode, ffi::GSK_CROSS_FADE_NODE => Self::CrossFadeNode, ffi::GSK_TEXT_NODE => Self::TextNode, ffi::GSK_BLUR_NODE => Self::BlurNode, ffi::GSK_DEBUG_NODE => Self::DebugNode, ffi::GSK_GL_SHADER_NODE => Self::GlShaderNode, value => Self::__Unknown(value), } } } impl StaticType for RenderNodeType { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_render_node_type_get_type()) } } } impl glib::value::ValueType for RenderNodeType { type Type = Self; } unsafe impl<'a> FromValue<'a> for RenderNodeType { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for RenderNodeType { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskScalingFilter")] pub enum ScalingFilter { #[doc(alias = "GSK_SCALING_FILTER_LINEAR")] Linear, #[doc(alias = "GSK_SCALING_FILTER_NEAREST")] Nearest, #[doc(alias = "GSK_SCALING_FILTER_TRILINEAR")] Trilinear, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for ScalingFilter { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "ScalingFilter::{}", match *self { Self::Linear => "Linear", Self::Nearest => "Nearest", Self::Trilinear => "Trilinear", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for ScalingFilter { type GlibType = ffi::GskScalingFilter; fn into_glib(self) -> ffi::GskScalingFilter { match self { Self::Linear => ffi::GSK_SCALING_FILTER_LINEAR, Self::Nearest => ffi::GSK_SCALING_FILTER_NEAREST, Self::Trilinear => ffi::GSK_SCALING_FILTER_TRILINEAR, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for ScalingFilter { unsafe fn from_glib(value: ffi::GskScalingFilter) -> Self { skip_assert_initialized!(); match value { ffi::GSK_SCALING_FILTER_LINEAR => Self::Linear, ffi::GSK_SCALING_FILTER_NEAREST => Self::Nearest, ffi::GSK_SCALING_FILTER_TRILINEAR => Self::Trilinear, value => Self::__Unknown(value), } } } impl StaticType for ScalingFilter { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_scaling_filter_get_type()) } } } impl glib::value::ValueType for ScalingFilter { type Type = Self; } unsafe impl<'a> FromValue<'a> for ScalingFilter { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for ScalingFilter { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskSerializationError")] pub enum SerializationError { #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_FORMAT")] UnsupportedFormat, #[doc(alias = "GSK_SERIALIZATION_UNSUPPORTED_VERSION")] UnsupportedVersion, #[doc(alias = "GSK_SERIALIZATION_INVALID_DATA")] InvalidData, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for SerializationError { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "SerializationError::{}", match *self { Self::UnsupportedFormat => "UnsupportedFormat", Self::UnsupportedVersion => "UnsupportedVersion", Self::InvalidData => "InvalidData", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for SerializationError { type GlibType = ffi::GskSerializationError; fn into_glib(self) -> ffi::GskSerializationError { match self { Self::UnsupportedFormat => ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT, Self::UnsupportedVersion => ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION, Self::InvalidData => ffi::GSK_SERIALIZATION_INVALID_DATA, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for SerializationError { unsafe fn from_glib(value: ffi::GskSerializationError) -> Self { skip_assert_initialized!(); match value { ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT => Self::UnsupportedFormat, ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION => Self::UnsupportedVersion, ffi::GSK_SERIALIZATION_INVALID_DATA => Self::InvalidData, value => Self::__Unknown(value), } } } impl ErrorDomain for SerializationError { fn domain() -> Quark { skip_assert_initialized!(); unsafe { from_glib(ffi::gsk_serialization_error_quark()) } } fn code(self) -> i32 { self.into_glib() } fn from(code: i32) -> Option { skip_assert_initialized!(); match code { ffi::GSK_SERIALIZATION_UNSUPPORTED_FORMAT => Some(Self::UnsupportedFormat), ffi::GSK_SERIALIZATION_UNSUPPORTED_VERSION => Some(Self::UnsupportedVersion), ffi::GSK_SERIALIZATION_INVALID_DATA => Some(Self::InvalidData), value => Some(Self::__Unknown(value)), } } } impl StaticType for SerializationError { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_serialization_error_get_type()) } } } impl glib::value::ValueType for SerializationError { type Type = Self; } unsafe impl<'a> FromValue<'a> for SerializationError { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for SerializationError { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } #[derive(Debug, Eq, PartialEq, Ord, PartialOrd, Hash, Clone, Copy)] #[non_exhaustive] #[doc(alias = "GskTransformCategory")] pub enum TransformCategory { #[doc(alias = "GSK_TRANSFORM_CATEGORY_UNKNOWN")] Unknown, #[doc(alias = "GSK_TRANSFORM_CATEGORY_ANY")] Any, #[doc(alias = "GSK_TRANSFORM_CATEGORY_3D")] _3d, #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D")] _2d, #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_AFFINE")] _2dAffine, #[doc(alias = "GSK_TRANSFORM_CATEGORY_2D_TRANSLATE")] _2dTranslate, #[doc(alias = "GSK_TRANSFORM_CATEGORY_IDENTITY")] Identity, #[doc(hidden)] __Unknown(i32), } impl fmt::Display for TransformCategory { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!( f, "TransformCategory::{}", match *self { Self::Unknown => "Unknown", Self::Any => "Any", Self::_3d => "_3d", Self::_2d => "_2d", Self::_2dAffine => "_2dAffine", Self::_2dTranslate => "_2dTranslate", Self::Identity => "Identity", _ => "Unknown", } ) } } #[doc(hidden)] impl IntoGlib for TransformCategory { type GlibType = ffi::GskTransformCategory; fn into_glib(self) -> ffi::GskTransformCategory { match self { Self::Unknown => ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN, Self::Any => ffi::GSK_TRANSFORM_CATEGORY_ANY, Self::_3d => ffi::GSK_TRANSFORM_CATEGORY_3D, Self::_2d => ffi::GSK_TRANSFORM_CATEGORY_2D, Self::_2dAffine => ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE, Self::_2dTranslate => ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE, Self::Identity => ffi::GSK_TRANSFORM_CATEGORY_IDENTITY, Self::__Unknown(value) => value, } } } #[doc(hidden)] impl FromGlib for TransformCategory { unsafe fn from_glib(value: ffi::GskTransformCategory) -> Self { skip_assert_initialized!(); match value { ffi::GSK_TRANSFORM_CATEGORY_UNKNOWN => Self::Unknown, ffi::GSK_TRANSFORM_CATEGORY_ANY => Self::Any, ffi::GSK_TRANSFORM_CATEGORY_3D => Self::_3d, ffi::GSK_TRANSFORM_CATEGORY_2D => Self::_2d, ffi::GSK_TRANSFORM_CATEGORY_2D_AFFINE => Self::_2dAffine, ffi::GSK_TRANSFORM_CATEGORY_2D_TRANSLATE => Self::_2dTranslate, ffi::GSK_TRANSFORM_CATEGORY_IDENTITY => Self::Identity, value => Self::__Unknown(value), } } } impl StaticType for TransformCategory { fn static_type() -> Type { unsafe { from_glib(ffi::gsk_transform_category_get_type()) } } } impl glib::value::ValueType for TransformCategory { type Type = Self; } unsafe impl<'a> FromValue<'a> for TransformCategory { type Checker = glib::value::GenericValueTypeChecker; unsafe fn from_value(value: &'a glib::Value) -> Self { skip_assert_initialized!(); from_glib(glib::gobject_ffi::g_value_get_enum(value.to_glib_none().0)) } } impl ToValue for TransformCategory { fn to_value(&self) -> glib::Value { let mut value = glib::Value::for_value_type::(); unsafe { glib::gobject_ffi::g_value_set_enum(value.to_glib_none_mut().0, self.into_glib()); } value } fn value_type(&self) -> glib::Type { Self::static_type() } } gsk4-0.3.1/src/auto/gl_renderer.rs000064400000000000000000000016140072674642500151240ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::Renderer; use glib::object::Cast; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "GskGLRenderer")] pub struct GLRenderer(Object) @extends Renderer; match fn { type_ => || ffi::gsk_gl_renderer_get_type(), } } impl GLRenderer { #[doc(alias = "gsk_gl_renderer_new")] pub fn new() -> GLRenderer { assert_initialized_main_thread!(); unsafe { Renderer::from_glib_full(ffi::gsk_gl_renderer_new()).unsafe_cast() } } } impl Default for GLRenderer { fn default() -> Self { Self::new() } } impl fmt::Display for GLRenderer { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("GLRenderer") } } gsk4-0.3.1/src/auto/gl_shader.rs000064400000000000000000000153320072674642500145660ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::GLUniformType; use crate::Renderer; use glib::object::Cast; use glib::object::IsA; use glib::translate::*; use glib::StaticType; use glib::ToValue; use std::fmt; use std::ptr; glib::wrapper! { #[doc(alias = "GskGLShader")] pub struct GLShader(Object); match fn { type_ => || ffi::gsk_gl_shader_get_type(), } } impl GLShader { #[doc(alias = "gsk_gl_shader_new_from_bytes")] #[doc(alias = "new_from_bytes")] pub fn from_bytes(sourcecode: &glib::Bytes) -> GLShader { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_gl_shader_new_from_bytes( sourcecode.to_glib_none().0, )) } } #[doc(alias = "gsk_gl_shader_new_from_resource")] #[doc(alias = "new_from_resource")] pub fn from_resource(resource_path: &str) -> GLShader { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_gl_shader_new_from_resource( resource_path.to_glib_none().0, )) } } // rustdoc-stripper-ignore-next /// Creates a new builder-pattern struct instance to construct [`GLShader`] objects. /// /// This method returns an instance of [`GLShaderBuilder`] which can be used to create [`GLShader`] objects. pub fn builder() -> GLShaderBuilder { GLShaderBuilder::default() } #[doc(alias = "gsk_gl_shader_compile")] pub fn compile(&self, renderer: &impl IsA) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); let _ = ffi::gsk_gl_shader_compile( self.to_glib_none().0, renderer.as_ref().to_glib_none().0, &mut error, ); if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } } } #[doc(alias = "gsk_gl_shader_find_uniform_by_name")] pub fn find_uniform_by_name(&self, name: &str) -> i32 { unsafe { ffi::gsk_gl_shader_find_uniform_by_name(self.to_glib_none().0, name.to_glib_none().0) } } #[doc(alias = "gsk_gl_shader_get_arg_bool")] #[doc(alias = "get_arg_bool")] pub fn arg_bool(&self, args: &glib::Bytes, idx: i32) -> bool { unsafe { from_glib(ffi::gsk_gl_shader_get_arg_bool( self.to_glib_none().0, args.to_glib_none().0, idx, )) } } #[doc(alias = "gsk_gl_shader_get_arg_float")] #[doc(alias = "get_arg_float")] pub fn arg_float(&self, args: &glib::Bytes, idx: i32) -> f32 { unsafe { ffi::gsk_gl_shader_get_arg_float(self.to_glib_none().0, args.to_glib_none().0, idx) } } #[doc(alias = "gsk_gl_shader_get_arg_int")] #[doc(alias = "get_arg_int")] pub fn arg_int(&self, args: &glib::Bytes, idx: i32) -> i32 { unsafe { ffi::gsk_gl_shader_get_arg_int(self.to_glib_none().0, args.to_glib_none().0, idx) } } #[doc(alias = "gsk_gl_shader_get_arg_uint")] #[doc(alias = "get_arg_uint")] pub fn arg_uint(&self, args: &glib::Bytes, idx: i32) -> u32 { unsafe { ffi::gsk_gl_shader_get_arg_uint(self.to_glib_none().0, args.to_glib_none().0, idx) } } #[doc(alias = "gsk_gl_shader_get_args_size")] #[doc(alias = "get_args_size")] pub fn args_size(&self) -> usize { unsafe { ffi::gsk_gl_shader_get_args_size(self.to_glib_none().0) } } #[doc(alias = "gsk_gl_shader_get_n_textures")] #[doc(alias = "get_n_textures")] pub fn n_textures(&self) -> i32 { unsafe { ffi::gsk_gl_shader_get_n_textures(self.to_glib_none().0) } } #[doc(alias = "gsk_gl_shader_get_n_uniforms")] #[doc(alias = "get_n_uniforms")] pub fn n_uniforms(&self) -> i32 { unsafe { ffi::gsk_gl_shader_get_n_uniforms(self.to_glib_none().0) } } #[doc(alias = "gsk_gl_shader_get_resource")] #[doc(alias = "get_resource")] pub fn resource(&self) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_get_resource(self.to_glib_none().0)) } } #[doc(alias = "gsk_gl_shader_get_source")] #[doc(alias = "get_source")] pub fn source(&self) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_get_source(self.to_glib_none().0)) } } #[doc(alias = "gsk_gl_shader_get_uniform_name")] #[doc(alias = "get_uniform_name")] pub fn uniform_name(&self, idx: i32) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_get_uniform_name( self.to_glib_none().0, idx, )) } } #[doc(alias = "gsk_gl_shader_get_uniform_offset")] #[doc(alias = "get_uniform_offset")] pub fn uniform_offset(&self, idx: i32) -> i32 { unsafe { ffi::gsk_gl_shader_get_uniform_offset(self.to_glib_none().0, idx) } } #[doc(alias = "gsk_gl_shader_get_uniform_type")] #[doc(alias = "get_uniform_type")] pub fn uniform_type(&self, idx: i32) -> GLUniformType { unsafe { from_glib(ffi::gsk_gl_shader_get_uniform_type( self.to_glib_none().0, idx, )) } } } #[derive(Clone, Default)] // rustdoc-stripper-ignore-next /// A [builder-pattern] type to construct [`GLShader`] objects. /// /// [builder-pattern]: https://doc.rust-lang.org/1.0.0/style/ownership/builders.html pub struct GLShaderBuilder { resource: Option, source: Option, } impl GLShaderBuilder { // rustdoc-stripper-ignore-next /// Create a new [`GLShaderBuilder`]. pub fn new() -> Self { Self::default() } // rustdoc-stripper-ignore-next /// Build the [`GLShader`]. pub fn build(self) -> GLShader { let mut properties: Vec<(&str, &dyn ToValue)> = vec![]; if let Some(ref resource) = self.resource { properties.push(("resource", resource)); } if let Some(ref source) = self.source { properties.push(("source", source)); } glib::Object::new::(&properties) .expect("Failed to create an instance of GLShader") } pub fn resource(mut self, resource: &str) -> Self { self.resource = Some(resource.to_string()); self } pub fn source(mut self, source: &glib::Bytes) -> Self { self.source = Some(source.clone()); self } } impl fmt::Display for GLShader { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("GLShader") } } gsk4-0.3.1/src/auto/mod.rs000064400000000000000000000026660072674642500134230ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT #[cfg(any(feature = "broadway", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "broadway")))] mod broadway_renderer; #[cfg(any(feature = "broadway", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "broadway")))] pub use self::broadway_renderer::BroadwayRenderer; mod cairo_renderer; pub use self::cairo_renderer::CairoRenderer; mod gl_renderer; pub use self::gl_renderer::GLRenderer; mod gl_shader; pub use self::gl_shader::GLShader; pub use self::gl_shader::GLShaderBuilder; #[cfg(any(feature = "v4_2", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))] mod ngl_renderer; #[cfg(any(feature = "v4_2", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))] pub use self::ngl_renderer::NglRenderer; mod renderer; pub use self::renderer::{Renderer, NONE_RENDERER}; mod shader_args_builder; pub use self::shader_args_builder::ShaderArgsBuilder; mod transform; pub use self::transform::Transform; mod enums; pub use self::enums::BlendMode; pub use self::enums::Corner; pub use self::enums::GLUniformType; pub use self::enums::RenderNodeType; pub use self::enums::ScalingFilter; pub use self::enums::SerializationError; pub use self::enums::TransformCategory; #[doc(hidden)] pub mod traits { pub use super::renderer::RendererExt; } gsk4-0.3.1/src/auto/ngl_renderer.rs000064400000000000000000000020000072674642500152700ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::Renderer; use glib::object::Cast; use glib::translate::*; use std::fmt; glib::wrapper! { #[doc(alias = "GskNglRenderer")] pub struct NglRenderer(Object) @extends Renderer; match fn { type_ => || ffi::gsk_ngl_renderer_get_type(), } } impl NglRenderer { #[doc(alias = "gsk_ngl_renderer_new")] pub fn new() -> NglRenderer { assert_initialized_main_thread!(); unsafe { Renderer::from_glib_full(ffi::gsk_ngl_renderer_new()).unsafe_cast() } } } #[cfg(any(feature = "v4_2", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))] impl Default for NglRenderer { fn default() -> Self { Self::new() } } impl fmt::Display for NglRenderer { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("NglRenderer") } } gsk4-0.3.1/src/auto/renderer.rs000064400000000000000000000105540072674642500144450ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use glib::object::Cast; use glib::object::IsA; use glib::signal::connect_raw; use glib::signal::SignalHandlerId; use glib::translate::*; use std::boxed::Box as Box_; use std::fmt; use std::mem::transmute; use std::ptr; glib::wrapper! { #[doc(alias = "GskRenderer")] pub struct Renderer(Object); match fn { type_ => || ffi::gsk_renderer_get_type(), } } impl Renderer { #[doc(alias = "gsk_renderer_new_for_surface")] #[doc(alias = "new_for_surface")] pub fn for_surface(surface: &gdk::Surface) -> Option { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_renderer_new_for_surface(surface.to_glib_none().0)) } } } pub const NONE_RENDERER: Option<&Renderer> = None; pub trait RendererExt: 'static { #[doc(alias = "gsk_renderer_get_surface")] #[doc(alias = "get_surface")] fn surface(&self) -> Option; #[doc(alias = "gsk_renderer_is_realized")] fn is_realized(&self) -> bool; #[doc(alias = "gsk_renderer_realize")] fn realize(&self, surface: &gdk::Surface) -> Result<(), glib::Error>; #[doc(alias = "gsk_renderer_unrealize")] fn unrealize(&self); #[doc(alias = "realized")] fn connect_realized_notify(&self, f: F) -> SignalHandlerId; #[doc(alias = "surface")] fn connect_surface_notify(&self, f: F) -> SignalHandlerId; } impl> RendererExt for O { fn surface(&self) -> Option { unsafe { from_glib_none(ffi::gsk_renderer_get_surface( self.as_ref().to_glib_none().0, )) } } fn is_realized(&self) -> bool { unsafe { from_glib(ffi::gsk_renderer_is_realized( self.as_ref().to_glib_none().0, )) } } fn realize(&self, surface: &gdk::Surface) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); let _ = ffi::gsk_renderer_realize( self.as_ref().to_glib_none().0, surface.to_glib_none().0, &mut error, ); if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } } } fn unrealize(&self) { unsafe { ffi::gsk_renderer_unrealize(self.as_ref().to_glib_none().0); } } fn connect_realized_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_realized_trampoline, F: Fn(&P) + 'static>( this: *mut ffi::GskRenderer, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer, ) { let f: &F = &*(f as *const F); f(Renderer::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_ = Box_::new(f); connect_raw( self.as_ptr() as *mut _, b"notify::realized\0".as_ptr() as *const _, Some(transmute::<_, unsafe extern "C" fn()>( notify_realized_trampoline:: as *const (), )), Box_::into_raw(f), ) } } fn connect_surface_notify(&self, f: F) -> SignalHandlerId { unsafe extern "C" fn notify_surface_trampoline, F: Fn(&P) + 'static>( this: *mut ffi::GskRenderer, _param_spec: glib::ffi::gpointer, f: glib::ffi::gpointer, ) { let f: &F = &*(f as *const F); f(Renderer::from_glib_borrow(this).unsafe_cast_ref()) } unsafe { let f: Box_ = Box_::new(f); connect_raw( self.as_ptr() as *mut _, b"notify::surface\0".as_ptr() as *const _, Some(transmute::<_, unsafe extern "C" fn()>( notify_surface_trampoline:: as *const (), )), Box_::into_raw(f), ) } } } impl fmt::Display for Renderer { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("Renderer") } } gsk4-0.3.1/src/auto/shader_args_builder.rs000064400000000000000000000063450072674642500166320ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::GLShader; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] pub struct ShaderArgsBuilder(Shared); match fn { ref => |ptr| ffi::gsk_shader_args_builder_ref(ptr), unref => |ptr| ffi::gsk_shader_args_builder_unref(ptr), type_ => || ffi::gsk_shader_args_builder_get_type(), } } impl ShaderArgsBuilder { #[doc(alias = "gsk_shader_args_builder_new")] pub fn new(shader: &GLShader, initial_values: Option<&glib::Bytes>) -> ShaderArgsBuilder { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_shader_args_builder_new( shader.to_glib_none().0, initial_values.to_glib_none().0, )) } } #[doc(alias = "gsk_shader_args_builder_free_to_args")] pub fn free_to_args(&self) -> Option { unsafe { from_glib_full(ffi::gsk_shader_args_builder_free_to_args( self.to_glib_none().0, )) } } #[doc(alias = "gsk_shader_args_builder_set_bool")] pub fn set_bool(&self, idx: i32, value: bool) { unsafe { ffi::gsk_shader_args_builder_set_bool(self.to_glib_none().0, idx, value.into_glib()); } } #[doc(alias = "gsk_shader_args_builder_set_float")] pub fn set_float(&self, idx: i32, value: f32) { unsafe { ffi::gsk_shader_args_builder_set_float(self.to_glib_none().0, idx, value); } } #[doc(alias = "gsk_shader_args_builder_set_int")] pub fn set_int(&self, idx: i32, value: i32) { unsafe { ffi::gsk_shader_args_builder_set_int(self.to_glib_none().0, idx, value); } } #[doc(alias = "gsk_shader_args_builder_set_uint")] pub fn set_uint(&self, idx: i32, value: u32) { unsafe { ffi::gsk_shader_args_builder_set_uint(self.to_glib_none().0, idx, value); } } #[doc(alias = "gsk_shader_args_builder_set_vec2")] pub fn set_vec2(&self, idx: i32, value: &graphene::Vec2) { unsafe { ffi::gsk_shader_args_builder_set_vec2( self.to_glib_none().0, idx, value.to_glib_none().0, ); } } #[doc(alias = "gsk_shader_args_builder_set_vec3")] pub fn set_vec3(&self, idx: i32, value: &graphene::Vec3) { unsafe { ffi::gsk_shader_args_builder_set_vec3( self.to_glib_none().0, idx, value.to_glib_none().0, ); } } #[doc(alias = "gsk_shader_args_builder_set_vec4")] pub fn set_vec4(&self, idx: i32, value: &graphene::Vec4) { unsafe { ffi::gsk_shader_args_builder_set_vec4( self.to_glib_none().0, idx, value.to_glib_none().0, ); } } #[doc(alias = "gsk_shader_args_builder_to_args")] pub fn to_args(&self) -> Option { unsafe { from_glib_full(ffi::gsk_shader_args_builder_to_args(self.to_glib_none().0)) } } } gsk4-0.3.1/src/auto/transform.rs000064400000000000000000000213370072674642500146530ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from gir-files (https://github.com/gtk-rs/gir-files.git) // DO NOT EDIT use crate::TransformCategory; use glib::translate::*; use std::fmt; use std::mem; use std::ptr; glib::wrapper! { #[derive(Debug, PartialOrd, Ord, Hash)] pub struct Transform(Shared); match fn { ref => |ptr| ffi::gsk_transform_ref(ptr), unref => |ptr| ffi::gsk_transform_unref(ptr), type_ => || ffi::gsk_transform_get_type(), } } impl Transform { #[doc(alias = "gsk_transform_new")] pub fn new() -> Transform { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_transform_new()) } } #[doc(alias = "gsk_transform_equal")] fn equal(&self, second: &Transform) -> bool { unsafe { from_glib(ffi::gsk_transform_equal( self.to_glib_none().0, second.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_get_category")] #[doc(alias = "get_category")] pub fn category(&self) -> TransformCategory { unsafe { from_glib(ffi::gsk_transform_get_category(self.to_glib_none().0)) } } #[doc(alias = "gsk_transform_invert")] pub fn invert(&self) -> Option { unsafe { from_glib_full(ffi::gsk_transform_invert(self.to_glib_full())) } } #[doc(alias = "gsk_transform_matrix")] pub fn matrix(&self, matrix: &graphene::Matrix) -> Option { unsafe { from_glib_full(ffi::gsk_transform_matrix( self.to_glib_full(), matrix.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_perspective")] pub fn perspective(&self, depth: f32) -> Option { unsafe { from_glib_full(ffi::gsk_transform_perspective(self.to_glib_full(), depth)) } } #[doc(alias = "gsk_transform_rotate")] pub fn rotate(&self, angle: f32) -> Option { unsafe { from_glib_full(ffi::gsk_transform_rotate(self.to_glib_full(), angle)) } } #[doc(alias = "gsk_transform_rotate_3d")] pub fn rotate_3d(&self, angle: f32, axis: &graphene::Vec3) -> Option { unsafe { from_glib_full(ffi::gsk_transform_rotate_3d( self.to_glib_full(), angle, axis.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_scale")] pub fn scale(&self, factor_x: f32, factor_y: f32) -> Option { unsafe { from_glib_full(ffi::gsk_transform_scale( self.to_glib_full(), factor_x, factor_y, )) } } #[doc(alias = "gsk_transform_scale_3d")] pub fn scale_3d(&self, factor_x: f32, factor_y: f32, factor_z: f32) -> Option { unsafe { from_glib_full(ffi::gsk_transform_scale_3d( self.to_glib_full(), factor_x, factor_y, factor_z, )) } } #[doc(alias = "gsk_transform_to_2d")] pub fn to_2d(&self) -> (f32, f32, f32, f32, f32, f32) { unsafe { let mut out_xx = mem::MaybeUninit::uninit(); let mut out_yx = mem::MaybeUninit::uninit(); let mut out_xy = mem::MaybeUninit::uninit(); let mut out_yy = mem::MaybeUninit::uninit(); let mut out_dx = mem::MaybeUninit::uninit(); let mut out_dy = mem::MaybeUninit::uninit(); ffi::gsk_transform_to_2d( self.to_glib_none().0, out_xx.as_mut_ptr(), out_yx.as_mut_ptr(), out_xy.as_mut_ptr(), out_yy.as_mut_ptr(), out_dx.as_mut_ptr(), out_dy.as_mut_ptr(), ); let out_xx = out_xx.assume_init(); let out_yx = out_yx.assume_init(); let out_xy = out_xy.assume_init(); let out_yy = out_yy.assume_init(); let out_dx = out_dx.assume_init(); let out_dy = out_dy.assume_init(); (out_xx, out_yx, out_xy, out_yy, out_dx, out_dy) } } #[doc(alias = "gsk_transform_to_affine")] pub fn to_affine(&self) -> (f32, f32, f32, f32) { unsafe { let mut out_scale_x = mem::MaybeUninit::uninit(); let mut out_scale_y = mem::MaybeUninit::uninit(); let mut out_dx = mem::MaybeUninit::uninit(); let mut out_dy = mem::MaybeUninit::uninit(); ffi::gsk_transform_to_affine( self.to_glib_none().0, out_scale_x.as_mut_ptr(), out_scale_y.as_mut_ptr(), out_dx.as_mut_ptr(), out_dy.as_mut_ptr(), ); let out_scale_x = out_scale_x.assume_init(); let out_scale_y = out_scale_y.assume_init(); let out_dx = out_dx.assume_init(); let out_dy = out_dy.assume_init(); (out_scale_x, out_scale_y, out_dx, out_dy) } } #[doc(alias = "gsk_transform_to_matrix")] pub fn to_matrix(&self) -> graphene::Matrix { unsafe { let mut out_matrix = graphene::Matrix::uninitialized(); ffi::gsk_transform_to_matrix(self.to_glib_none().0, out_matrix.to_glib_none_mut().0); out_matrix } } #[doc(alias = "gsk_transform_to_string")] #[doc(alias = "to_string")] pub fn to_str(&self) -> glib::GString { unsafe { from_glib_full(ffi::gsk_transform_to_string(self.to_glib_none().0)) } } #[doc(alias = "gsk_transform_to_translate")] pub fn to_translate(&self) -> (f32, f32) { unsafe { let mut out_dx = mem::MaybeUninit::uninit(); let mut out_dy = mem::MaybeUninit::uninit(); ffi::gsk_transform_to_translate( self.to_glib_none().0, out_dx.as_mut_ptr(), out_dy.as_mut_ptr(), ); let out_dx = out_dx.assume_init(); let out_dy = out_dy.assume_init(); (out_dx, out_dy) } } #[doc(alias = "gsk_transform_transform")] pub fn transform(&self, other: Option<&Transform>) -> Option { unsafe { from_glib_full(ffi::gsk_transform_transform( self.to_glib_full(), other.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_transform_bounds")] pub fn transform_bounds(&self, rect: &graphene::Rect) -> graphene::Rect { unsafe { let mut out_rect = graphene::Rect::uninitialized(); ffi::gsk_transform_transform_bounds( self.to_glib_none().0, rect.to_glib_none().0, out_rect.to_glib_none_mut().0, ); out_rect } } #[doc(alias = "gsk_transform_transform_point")] pub fn transform_point(&self, point: &graphene::Point) -> graphene::Point { unsafe { let mut out_point = graphene::Point::uninitialized(); ffi::gsk_transform_transform_point( self.to_glib_none().0, point.to_glib_none().0, out_point.to_glib_none_mut().0, ); out_point } } #[doc(alias = "gsk_transform_translate")] pub fn translate(&self, point: &graphene::Point) -> Option { unsafe { from_glib_full(ffi::gsk_transform_translate( self.to_glib_full(), point.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_translate_3d")] pub fn translate_3d(&self, point: &graphene::Point3D) -> Option { unsafe { from_glib_full(ffi::gsk_transform_translate_3d( self.to_glib_full(), point.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_parse")] pub fn parse(string: &str) -> Option { assert_initialized_main_thread!(); unsafe { let mut out_transform = ptr::null_mut(); let ret = from_glib(ffi::gsk_transform_parse( string.to_glib_none().0, &mut out_transform, )); if ret { Some(from_glib_full(out_transform)) } else { None } } } } impl Default for Transform { fn default() -> Self { Self::new() } } impl PartialEq for Transform { #[inline] fn eq(&self, other: &Self) -> bool { self.equal(other) } } impl Eq for Transform {} impl fmt::Display for Transform { #[inline] fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str(&self.to_str()) } } gsk4-0.3.1/src/auto/versions.txt000064400000000000000000000002100072674642500146660ustar 00000000000000Generated by gir (https://github.com/gtk-rs/gir @ 4aa58cff8048) from gir-files (https://github.com/gtk-rs/gir-files.git @ b827978e7d18) gsk4-0.3.1/src/blend_node.rs000064400000000000000000000034450072674642500137610ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{BlendMode, RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskBlendNode")] pub struct BlendNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( BlendNode, ffi::GskBlendNode, ffi::gsk_blend_node_get_type, RenderNodeType::BlendNode ); impl BlendNode { #[doc(alias = "gsk_blend_node_new")] pub fn new, Q: AsRef>( bottom: &P, top: &Q, blend_mode: BlendMode, ) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_blend_node_new( bottom.as_ref().to_glib_none().0, top.as_ref().to_glib_none().0, blend_mode.into_glib(), )) } } #[doc(alias = "gsk_blend_node_get_blend_mode")] #[doc(alias = "get_blend_mode")] pub fn blend_mode(&self) -> BlendMode { unsafe { from_glib(ffi::gsk_blend_node_get_blend_mode(self.to_glib_none().0)) } } #[doc(alias = "gsk_blend_node_get_bottom_child")] #[doc(alias = "get_bottom_child")] pub fn bottom_child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_blend_node_get_bottom_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_blend_node_get_top_child")] #[doc(alias = "get_top_child")] pub fn top_child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_blend_node_get_top_child(self.to_glib_none().0)) } } } gsk4-0.3.1/src/blur_node.rs000064400000000000000000000025300072674642500136330ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskBlurNode")] pub struct BlurNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( BlurNode, ffi::GskBlurNode, ffi::gsk_blur_node_get_type, RenderNodeType::BlurNode ); impl BlurNode { #[doc(alias = "gsk_blur_node_new")] pub fn new>(child: &P, radius: f32) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_blur_node_new( child.as_ref().to_glib_none().0, radius, )) } } #[doc(alias = "gsk_blur_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_blur_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_blur_node_get_radius")] #[doc(alias = "get_radius")] pub fn radius(&self) -> f32 { unsafe { ffi::gsk_blur_node_get_radius(self.to_glib_none().0) } } } gsk4-0.3.1/src/border_node.rs000064400000000000000000000033770072674642500141560ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNodeType, RoundedRect}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskBorderNode")] pub struct BorderNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( BorderNode, ffi::GskBorderNode, ffi::gsk_border_node_get_type, RenderNodeType::BorderNode ); impl BorderNode { #[doc(alias = "gsk_border_node_new")] pub fn new( outline: &RoundedRect, border_width: &[f32; 4], border_color: &[gdk::RGBA; 4], ) -> Self { unsafe { from_glib_full(ffi::gsk_border_node_new( outline.to_glib_none().0, border_width.as_ptr() as *const [f32; 4], border_color.as_ptr() as *const [gdk::ffi::GdkRGBA; 4], )) } } #[doc(alias = "gsk_border_node_get_colors")] #[doc(alias = "get_colors")] pub fn colors(&self) -> &[gdk::RGBA; 4] { unsafe { &*(ffi::gsk_border_node_get_colors(self.to_glib_none().0) as *const [gdk::RGBA; 4]) } } #[doc(alias = "gsk_border_node_get_outline")] #[doc(alias = "get_outline")] pub fn outline(&self) -> RoundedRect { unsafe { from_glib_none(ffi::gsk_border_node_get_outline(self.to_glib_none().0)) } } #[doc(alias = "gsk_border_node_get_widths")] #[doc(alias = "get_widths")] pub fn widths(&self) -> &[f32; 4] { unsafe { &*ffi::gsk_border_node_get_widths(self.to_glib_none().0) } } } gsk4-0.3.1/src/cairo_node.rs000064400000000000000000000024760072674642500137750ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::RenderNodeType; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskCairoNode")] pub struct CairoNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( CairoNode, ffi::GskCairoNode, ffi::gsk_cairo_node_get_type, RenderNodeType::CairoNode ); impl CairoNode { #[doc(alias = "gsk_cairo_node_new")] pub fn new(bounds: &graphene::Rect) -> Self { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_cairo_node_new(bounds.to_glib_none().0)) } } #[doc(alias = "gsk_cairo_node_get_draw_context")] #[doc(alias = "get_draw_context")] pub fn draw_context(&self) -> Option { unsafe { from_glib_full(ffi::gsk_cairo_node_get_draw_context(self.to_glib_none().0)) } } #[doc(alias = "gsk_cairo_node_get_surface")] #[doc(alias = "get_surface")] pub fn surface(&self) -> Option { unsafe { from_glib_none(ffi::gsk_cairo_node_get_surface(self.to_glib_none().0)) } } } gsk4-0.3.1/src/clip_node.rs000064400000000000000000000026140072674642500136210ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskClipNode")] pub struct ClipNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ClipNode, ffi::GskClipNode, ffi::gsk_clip_node_get_type, RenderNodeType::ClipNode ); impl ClipNode { #[doc(alias = "gsk_clip_node_new")] pub fn new>(child: &P, clip: &graphene::Rect) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_clip_node_new( child.as_ref().to_glib_none().0, clip.to_glib_none().0, )) } } #[doc(alias = "gsk_clip_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_clip_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_clip_node_get_clip")] #[doc(alias = "get_clip")] pub fn clip(&self) -> Option { unsafe { from_glib_none(ffi::gsk_clip_node_get_clip(self.to_glib_none().0)) } } } gsk4-0.3.1/src/color_matrix_node.rs000064400000000000000000000040100072674642500153640ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskColorMatrixNode")] pub struct ColorMatrixNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ColorMatrixNode, ffi::GskColorMatrixNode, ffi::gsk_color_matrix_node_get_type, RenderNodeType::ColorMatrixNode ); impl ColorMatrixNode { #[doc(alias = "gsk_color_matrix_node_new")] pub fn new>( child: &P, color_matrix: &graphene::Matrix, color_offset: &graphene::Vec4, ) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_color_matrix_node_new( child.as_ref().to_glib_none().0, color_matrix.to_glib_none().0, color_offset.to_glib_none().0, )) } } #[doc(alias = "gsk_color_matrix_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_color_matrix_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_color_matrix_node_get_color_matrix")] #[doc(alias = "get_color_matrix")] pub fn color_matrix(&self) -> Option { unsafe { from_glib_none(ffi::gsk_color_matrix_node_get_color_matrix( self.to_glib_none().0, )) } } #[doc(alias = "gsk_color_matrix_node_get_color_offset")] #[doc(alias = "get_color_offset")] pub fn color_offset(&self) -> Option { unsafe { from_glib_none(ffi::gsk_color_matrix_node_get_color_offset( self.to_glib_none().0, )) } } } gsk4-0.3.1/src/color_node.rs000064400000000000000000000022370072674642500140110ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::RenderNodeType; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskColorNode")] pub struct ColorNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ColorNode, ffi::GskColorNode, ffi::gsk_color_node_get_type, RenderNodeType::ColorNode ); impl ColorNode { #[doc(alias = "gsk_color_node_new")] pub fn new(rgba: &gdk::RGBA, bounds: &graphene::Rect) -> Self { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_color_node_new( rgba.to_glib_none().0, bounds.to_glib_none().0, )) } } #[doc(alias = "gsk_color_node_get_color")] #[doc(alias = "get_color")] pub fn color(&self) -> Option { unsafe { from_glib_none(ffi::gsk_color_node_get_color(self.to_glib_none().0)) } } } gsk4-0.3.1/src/color_stop.rs000064400000000000000000000057430072674642500140560ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use gdk::RGBA; use glib::translate::*; use std::mem; use std::ptr; #[repr(transparent)] #[derive(Clone, Debug)] #[doc(alias = "GskColorStop")] pub struct ColorStop(ffi::GskColorStop); impl ColorStop { pub fn new(offset: f32, color: RGBA) -> Self { assert_initialized_main_thread!(); Self(ffi::GskColorStop { offset, color: unsafe { *color.to_glib_none().0 }, }) } pub fn offset(&self) -> f32 { self.0.offset } pub fn color(&self) -> RGBA { unsafe { from_glib_none(&self.0.color as *const _) } } } #[doc(hidden)] impl<'a> ToGlibPtr<'a, *const ffi::GskColorStop> for ColorStop { type Storage = &'a Self; #[inline] fn to_glib_none(&'a self) -> Stash<'a, *const ffi::GskColorStop, Self> { let ptr: *const ColorStop = &*self; Stash(ptr as *const ffi::GskColorStop, self) } } #[doc(hidden)] impl<'a> ToGlibPtrMut<'a, *mut ffi::GskColorStop> for ColorStop { type Storage = &'a mut Self; #[inline] fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GskColorStop, Self> { let ptr: *mut ColorStop = &mut *self; StashMut(ptr as *mut ffi::GskColorStop, self) } } #[doc(hidden)] impl FromGlibContainerAsVec for ColorStop { unsafe fn from_glib_none_num_as_vec(ptr: *const ffi::GskColorStop, num: usize) -> Vec { if num == 0 || ptr.is_null() { return Vec::new(); } let mut res = Vec::with_capacity(num); for i in 0..num { res.push(ColorStop(ptr::read(ptr.add(i)))); } res } unsafe fn from_glib_container_num_as_vec(_: *const ffi::GskColorStop, _: usize) -> Vec { // Can't really free a *const unimplemented!(); } unsafe fn from_glib_full_num_as_vec(_: *const ffi::GskColorStop, _: usize) -> Vec { // Can't really free a *const unimplemented!(); } } #[doc(hidden)] impl<'a> ToGlibContainerFromSlice<'a, *const ffi::GskColorStop> for ColorStop { type Storage = &'a [Self]; fn to_glib_none_from_slice(t: &'a [Self]) -> (*const ffi::GskColorStop, &'a [Self]) { assert_initialized_main_thread!(); (t.as_ptr() as *const _, t) } fn to_glib_container_from_slice(t: &'a [Self]) -> (*const ffi::GskColorStop, &'a [Self]) { assert_initialized_main_thread!(); (ToGlibContainerFromSlice::to_glib_full_from_slice(t), t) } fn to_glib_full_from_slice(t: &[Self]) -> *const ffi::GskColorStop { assert_initialized_main_thread!(); if t.is_empty() { return ptr::null_mut(); } unsafe { let res = glib::ffi::g_malloc(mem::size_of::() * t.len()) as *mut ffi::GskColorStop; ptr::copy_nonoverlapping(t.as_ptr() as *const _, res, t.len()); res } } } gsk4-0.3.1/src/conic_gradient_node.rs000064400000000000000000000056030072674642500156430ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ColorStop, RenderNodeType}; use glib::translate::*; use std::mem; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskConicGradientNode")] pub struct ConicGradientNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ConicGradientNode, ffi::GskConicGradientNode, ffi::gsk_conic_gradient_node_get_type, RenderNodeType::ConicGradientNode ); impl ConicGradientNode { #[doc(alias = "gsk_conic_gradient_node_new")] pub fn new( bounds: &graphene::Rect, center: &graphene::Point, rotation: f32, color_stops: &[ColorStop], ) -> Self { assert_initialized_main_thread!(); let n_color_stops = color_stops.len() as usize; unsafe { from_glib_full(ffi::gsk_conic_gradient_node_new( bounds.to_glib_none().0, center.to_glib_none().0, rotation, color_stops.to_glib_none().0, n_color_stops, )) } } #[doc(alias = "gsk_conic_gradient_node_get_center")] #[doc(alias = "get_center")] pub fn center(&self) -> graphene::Point { unsafe { from_glib_none(ffi::gsk_conic_gradient_node_get_center( self.to_glib_none().0, )) } } #[doc(alias = "gsk_conic_gradient_node_get_angle")] #[doc(alias = "get_angle")] #[cfg(any(feature = "v4_2", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))] pub fn angle(&self) -> f32 { unsafe { ffi::gsk_conic_gradient_node_get_angle(self.to_glib_none().0) } } #[doc(alias = "gsk_conic_gradient_node_get_color_stops")] #[doc(alias = "get_color_stops")] pub fn color_stops(&self) -> Vec { unsafe { let mut n_stops = mem::MaybeUninit::uninit(); let ret = FromGlibContainer::from_glib_none_num( ffi::gsk_conic_gradient_node_get_color_stops( self.to_glib_none().0, n_stops.as_mut_ptr(), ), n_stops.assume_init() as usize, ); ret } } #[doc(alias = "gsk_conic_gradient_node_get_n_color_stops")] #[doc(alias = "get_n_color_stops")] pub fn n_color_stops(&self) -> usize { unsafe { ffi::gsk_conic_gradient_node_get_n_color_stops(self.to_glib_none().0) } } #[doc(alias = "gsk_conic_gradient_node_get_rotation")] #[doc(alias = "get_rotation")] pub fn rotation(&self) -> f32 { unsafe { ffi::gsk_conic_gradient_node_get_rotation(self.to_glib_none().0) } } } gsk4-0.3.1/src/container_node.rs000064400000000000000000000030400072674642500146460ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskContainerNode")] pub struct ContainerNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ContainerNode, ffi::GskContainerNode, ffi::gsk_container_node_get_type, RenderNodeType::ContainerNode ); impl ContainerNode { #[doc(alias = "gsk_container_node_new")] pub fn new(children: &[RenderNode]) -> Self { assert_initialized_main_thread!(); let n_children = children.len() as u32; unsafe { from_glib_full(ffi::gsk_container_node_new( children.to_glib_none().0, n_children, )) } } #[doc(alias = "gsk_container_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self, idx: u32) -> Option { unsafe { from_glib_none(ffi::gsk_container_node_get_child( self.to_glib_none().0, idx, )) } } #[doc(alias = "gsk_container_node_get_n_children")] #[doc(alias = "get_n_children")] pub fn n_children(&self) -> u32 { unsafe { ffi::gsk_container_node_get_n_children(self.to_glib_none().0) } } } gsk4-0.3.1/src/cross_fade_node.rs000064400000000000000000000036240072674642500150040ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskCrossFadeNode")] pub struct CrossFadeNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( CrossFadeNode, ffi::GskCrossFadeNode, ffi::gsk_cross_fade_node_get_type, RenderNodeType::CrossFadeNode ); impl CrossFadeNode { #[doc(alias = "gsk_cross_fade_node_new")] pub fn new, Q: AsRef>( start: &P, end: &Q, progress: f32, ) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_cross_fade_node_new( start.as_ref().to_glib_none().0, end.as_ref().to_glib_none().0, progress, )) } } #[doc(alias = "gsk_cross_fade_node_get_end_child")] #[doc(alias = "get_end_child")] pub fn end_child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_cross_fade_node_get_end_child( self.to_glib_none().0, )) } } #[doc(alias = "gsk_cross_fade_node_get_progress")] #[doc(alias = "get_progress")] pub fn progress(&self) -> f32 { unsafe { ffi::gsk_cross_fade_node_get_progress(self.to_glib_none().0) } } #[doc(alias = "gsk_cross_fade_node_get_start_child")] #[doc(alias = "get_start_child")] pub fn start_child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_cross_fade_node_get_start_child( self.to_glib_none().0, )) } } } gsk4-0.3.1/src/debug_node.rs000064400000000000000000000026360072674642500137640ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskDebugNode")] pub struct DebugNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( DebugNode, ffi::GskDebugNode, ffi::gsk_debug_node_get_type, RenderNodeType::DebugNode ); impl DebugNode { #[doc(alias = "gsk_debug_node_new")] pub fn new>(child: &P, message: &str) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_debug_node_new( child.as_ref().to_glib_none().0, message.to_glib_full(), )) } } #[doc(alias = "gsk_debug_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_debug_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_debug_node_get_message")] #[doc(alias = "get_message")] pub fn message(&self) -> Option { unsafe { from_glib_none(ffi::gsk_debug_node_get_message(self.to_glib_none().0)) } } } gsk4-0.3.1/src/gl_shader.rs000064400000000000000000000031130072674642500136100ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::GLShader; use glib::translate::*; impl GLShader { #[doc(alias = "gsk_gl_shader_get_arg_vec2")] #[doc(alias = "get_arg_vec2")] pub fn arg_vec2(&self, args: &glib::Bytes, idx: i32) -> graphene::Vec2 { unsafe { let mut out_value = graphene::Vec2::uninitialized(); ffi::gsk_gl_shader_get_arg_vec2( self.to_glib_none().0, args.to_glib_none().0, idx, out_value.to_glib_none_mut().0, ); out_value } } #[doc(alias = "gsk_gl_shader_get_arg_vec3")] #[doc(alias = "get_arg_vec3")] pub fn arg_vec3(&self, args: &glib::Bytes, idx: i32) -> graphene::Vec3 { unsafe { let mut out_value = graphene::Vec3::uninitialized(); ffi::gsk_gl_shader_get_arg_vec3( self.to_glib_none().0, args.to_glib_none().0, idx, out_value.to_glib_none_mut().0, ); out_value } } #[doc(alias = "gsk_gl_shader_get_arg_vec4")] #[doc(alias = "get_arg_vec4")] pub fn arg_vec4(&self, args: &glib::Bytes, idx: i32) -> graphene::Vec4 { unsafe { let mut out_value = graphene::Vec4::uninitialized(); ffi::gsk_gl_shader_get_arg_vec4( self.to_glib_none().0, args.to_glib_none().0, idx, out_value.to_glib_none_mut().0, ); out_value } } } gsk4-0.3.1/src/gl_shader_node.rs000064400000000000000000000043220072674642500146200ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::RenderNode; use crate::{GLShader, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskGLShaderNode")] pub struct GLShaderNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( GLShaderNode, ffi::GskGLShaderNode, ffi::gsk_gl_shader_node_get_type, RenderNodeType::GlShaderNode ); impl GLShaderNode { #[doc(alias = "gsk_gl_shader_node_new")] pub fn new( shader: &GLShader, bounds: &graphene::Rect, args: &glib::Bytes, children: &[RenderNode], ) -> Self { skip_assert_initialized!(); let n_children = children.len() as u32; unsafe { from_glib_full(ffi::gsk_gl_shader_node_new( shader.to_glib_none().0, bounds.to_glib_none().0, args.to_glib_none().0, children.to_glib_none().0, n_children, )) } } #[doc(alias = "gsk_gl_shader_node_get_args")] #[doc(alias = "get_args")] pub fn args(&self) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_node_get_args(self.to_glib_none().0)) } } #[doc(alias = "gsk_gl_shader_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self, idx: u32) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_node_get_child( self.to_glib_none().0, idx, )) } } #[doc(alias = "gsk_gl_shader_node_get_n_children")] #[doc(alias = "get_n_children")] pub fn n_children(&self) -> u32 { unsafe { ffi::gsk_gl_shader_node_get_n_children(self.to_glib_none().0) } } #[doc(alias = "gsk_gl_shader_node_get_shader")] #[doc(alias = "get_shader")] pub fn shader(&self) -> Option { unsafe { from_glib_none(ffi::gsk_gl_shader_node_get_shader(self.to_glib_none().0)) } } } gsk4-0.3.1/src/inset_shadow_node.rs000064400000000000000000000050410072674642500153560ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNodeType, RoundedRect}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskInsetShadowNode")] pub struct InsetShadowNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( InsetShadowNode, ffi::GskInsetShadowNode, ffi::gsk_inset_shadow_node_get_type, RenderNodeType::InsetShadowNode ); impl InsetShadowNode { #[doc(alias = "gsk_inset_shadow_node_new")] pub fn new( outline: &RoundedRect, color: &gdk::RGBA, dx: f32, dy: f32, spread: f32, blur_radius: f32, ) -> Self { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_inset_shadow_node_new( outline.to_glib_none().0, color.to_glib_none().0, dx, dy, spread, blur_radius, )) } } #[doc(alias = "gsk_inset_shadow_node_get_blur_radius")] #[doc(alias = "get_blur_radius")] pub fn blur_radius(&self) -> f32 { unsafe { ffi::gsk_inset_shadow_node_get_blur_radius(self.to_glib_none().0) } } #[doc(alias = "gsk_inset_shadow_node_get_color")] #[doc(alias = "get_color")] pub fn color(&self) -> Option { unsafe { from_glib_none(ffi::gsk_inset_shadow_node_get_color(self.to_glib_none().0)) } } #[doc(alias = "gsk_inset_shadow_node_get_dx")] #[doc(alias = "get_dx")] pub fn dx(&self) -> f32 { unsafe { ffi::gsk_inset_shadow_node_get_dx(self.to_glib_none().0) } } #[doc(alias = "gsk_inset_shadow_node_get_dy")] #[doc(alias = "get_dy")] pub fn dy(&self) -> f32 { unsafe { ffi::gsk_inset_shadow_node_get_dy(self.to_glib_none().0) } } #[doc(alias = "gsk_inset_shadow_node_get_outline")] #[doc(alias = "get_outline")] pub fn outline(&self) -> Option { unsafe { from_glib_none(ffi::gsk_inset_shadow_node_get_outline( self.to_glib_none().0, )) } } #[doc(alias = "gsk_inset_shadow_node_get_spread")] #[doc(alias = "get_spread")] pub fn spread(&self) -> f32 { unsafe { ffi::gsk_inset_shadow_node_get_spread(self.to_glib_none().0) } } } gsk4-0.3.1/src/lib.rs000064400000000000000000000047220072674642500124350ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. #![cfg_attr(feature = "dox", feature(doc_cfg))] #![allow(clippy::derive_hash_xor_eq)] #![allow(clippy::too_many_arguments)] #![allow(clippy::wrong_self_convention)] #![doc = include_str!("../README.md")] pub use cairo; pub use ffi; pub use gdk; pub use glib; pub use graphene; pub use pango; // GSK 4 has no runtime to initialize macro_rules! assert_initialized_main_thread { () => {}; } // No-op macro_rules! skip_assert_initialized { () => {}; } #[allow(clippy::upper_case_acronyms)] #[allow(unused_imports)] mod auto; pub mod prelude; pub use auto::*; #[macro_use] mod render_node; mod renderer; mod rounded_rect; mod shadow; // Render node types mod blend_node; mod blur_node; mod border_node; mod cairo_node; mod clip_node; mod color_matrix_node; mod color_node; mod color_stop; mod conic_gradient_node; mod container_node; mod cross_fade_node; mod debug_node; mod gl_shader; mod gl_shader_node; mod inset_shadow_node; mod linear_gradient_node; mod opacity_node; mod outset_shadow_node; mod parse_location; mod radial_gradient_node; mod repeat_node; mod repeating_linear_gradient_node; mod repeating_radial_gradient_node; mod rounded_clip_node; mod shadow_node; mod text_node; mod texture_node; mod transform_node; pub use blend_node::BlendNode; pub use blur_node::BlurNode; pub use border_node::BorderNode; pub use cairo_node::CairoNode; pub use clip_node::ClipNode; pub use color_matrix_node::ColorMatrixNode; pub use color_node::ColorNode; pub use color_stop::ColorStop; pub use conic_gradient_node::ConicGradientNode; pub use container_node::ContainerNode; pub use cross_fade_node::CrossFadeNode; pub use debug_node::DebugNode; pub use gl_shader_node::GLShaderNode; pub use inset_shadow_node::InsetShadowNode; pub use linear_gradient_node::LinearGradientNode; pub use opacity_node::OpacityNode; pub use outset_shadow_node::OutsetShadowNode; pub use parse_location::ParseLocation; pub use radial_gradient_node::RadialGradientNode; pub use render_node::{IsRenderNode, RenderNode, NONE_RENDER_NODE}; pub use repeat_node::RepeatNode; pub use repeating_linear_gradient_node::RepeatingLinearGradientNode; pub use repeating_radial_gradient_node::RepeatingRadialGradientNode; pub use rounded_clip_node::RoundedClipNode; pub use rounded_rect::RoundedRect; pub use shadow::Shadow; pub use shadow_node::ShadowNode; pub use text_node::TextNode; pub use texture_node::TextureNode; pub use transform_node::TransformNode; gsk4-0.3.1/src/linear_gradient_node.rs000064400000000000000000000051020072674642500160140ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ColorStop, RenderNodeType}; use glib::translate::*; use graphene::{Point, Rect}; use std::mem; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskLinearGradientNode")] pub struct LinearGradientNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( LinearGradientNode, ffi::GskLinearGradientNode, ffi::gsk_linear_gradient_node_get_type, RenderNodeType::LinearGradientNode ); impl LinearGradientNode { #[doc(alias = "gsk_linear_gradient_node_new")] pub fn new(bounds: &Rect, start: &Point, end: &Point, color_stops: &[ColorStop]) -> Self { assert_initialized_main_thread!(); let n_color_stops = color_stops.len() as usize; unsafe { from_glib_full(ffi::gsk_linear_gradient_node_new( bounds.to_glib_none().0, start.to_glib_none().0, end.to_glib_none().0, color_stops.to_glib_none().0, n_color_stops, )) } } #[doc(alias = "gsk_linear_gradient_node_get_color_stops")] #[doc(alias = "get_color_stops")] pub fn color_stops(&self) -> Vec { unsafe { let mut n_stops = mem::MaybeUninit::uninit(); let ret = FromGlibContainer::from_glib_none_num( ffi::gsk_linear_gradient_node_get_color_stops( self.to_glib_none().0, n_stops.as_mut_ptr(), ), n_stops.assume_init() as usize, ); ret } } #[doc(alias = "gsk_linear_gradient_node_get_end")] #[doc(alias = "get_end")] pub fn end(&self) -> graphene::Point { unsafe { from_glib_none(ffi::gsk_linear_gradient_node_get_end(self.to_glib_none().0)) } } #[doc(alias = "gsk_linear_gradient_node_get_n_color_stops")] #[doc(alias = "get_n_color_stops")] pub fn n_color_stops(&self) -> usize { unsafe { ffi::gsk_linear_gradient_node_get_n_color_stops(self.to_glib_none().0) } } #[doc(alias = "gsk_linear_gradient_node_get_start")] #[doc(alias = "get_start")] pub fn start(&self) -> graphene::Point { unsafe { from_glib_none(ffi::gsk_linear_gradient_node_get_start( self.to_glib_none().0, )) } } } gsk4-0.3.1/src/opacity_node.rs000064400000000000000000000026100072674642500143360ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskOpacityNode")] pub struct OpacityNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( OpacityNode, ffi::GskOpacityNode, ffi::gsk_opacity_node_get_type, RenderNodeType::OpacityNode ); impl OpacityNode { #[doc(alias = "gsk_opacity_node_new")] pub fn new>(child: &P, opacity: f32) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_opacity_node_new( child.as_ref().to_glib_none().0, opacity, )) } } #[doc(alias = "gsk_opacity_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_opacity_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_opacity_node_get_opacity")] #[doc(alias = "get_opacity")] pub fn opacity(&self) -> f32 { unsafe { ffi::gsk_opacity_node_get_opacity(self.to_glib_none().0) } } } gsk4-0.3.1/src/outset_shadow_node.rs000064400000000000000000000050670072674642500155670ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNodeType, RoundedRect}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskOutsetShadowNode")] pub struct OutsetShadowNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( OutsetShadowNode, ffi::GskOutsetShadowNode, ffi::gsk_outset_shadow_node_get_type, RenderNodeType::OutsetShadowNode ); impl OutsetShadowNode { #[doc(alias = "gsk_outset_shadow_node_new")] pub fn new( outline: &RoundedRect, color: &gdk::RGBA, dx: f32, dy: f32, spread: f32, blur_radius: f32, ) -> Self { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_outset_shadow_node_new( outline.to_glib_none().0, color.to_glib_none().0, dx, dy, spread, blur_radius, )) } } #[doc(alias = "gsk_outset_shadow_node_get_blur_radius")] #[doc(alias = "get_blur_radius")] pub fn blur_radius(&self) -> f32 { unsafe { ffi::gsk_outset_shadow_node_get_blur_radius(self.to_glib_none().0) } } #[doc(alias = "gsk_outset_shadow_node_get_color")] #[doc(alias = "get_color")] pub fn color(&self) -> Option { unsafe { from_glib_none(ffi::gsk_outset_shadow_node_get_color(self.to_glib_none().0)) } } #[doc(alias = "gsk_outset_shadow_node_get_dx")] #[doc(alias = "get_dx")] pub fn dx(&self) -> f32 { unsafe { ffi::gsk_outset_shadow_node_get_dx(self.to_glib_none().0) } } #[doc(alias = "gsk_outset_shadow_node_get_dy")] #[doc(alias = "get_dy")] pub fn dy(&self) -> f32 { unsafe { ffi::gsk_outset_shadow_node_get_dy(self.to_glib_none().0) } } #[doc(alias = "gsk_outset_shadow_node_get_outline")] #[doc(alias = "get_outline")] pub fn outline(&self) -> Option { unsafe { from_glib_none(ffi::gsk_outset_shadow_node_get_outline( self.to_glib_none().0, )) } } #[doc(alias = "gsk_outset_shadow_node_get_spread")] #[doc(alias = "get_spread")] pub fn spread(&self) -> f32 { unsafe { ffi::gsk_outset_shadow_node_get_spread(self.to_glib_none().0) } } } gsk4-0.3.1/src/parse_location.rs000064400000000000000000000015560072674642500146730ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; #[derive(Copy, Clone)] #[repr(transparent)] #[doc(alias = "GskParseLocation")] pub struct ParseLocation(ffi::GskParseLocation); impl ParseLocation { pub fn bytes(&self) -> usize { self.0.bytes } pub fn chars(&self) -> usize { self.0.chars } pub fn lines(&self) -> usize { self.0.lines } pub fn line_bytes(&self) -> usize { self.0.line_bytes } pub fn line_chars(&self) -> usize { self.0.line_chars } } #[doc(hidden)] impl FromGlibPtrBorrow<*const ffi::GskParseLocation> for ParseLocation { unsafe fn from_glib_borrow( ptr: *const ffi::GskParseLocation, ) -> glib::translate::Borrowed { glib::translate::Borrowed::new(*(ptr as *const ParseLocation)) } } gsk4-0.3.1/src/prelude.rs000064400000000000000000000006210072674642500133210ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. // rustdoc-stripper-ignore-next //! Traits intended for blanket imports. pub use crate::auto::traits::*; pub use crate::renderer::RendererExtManual; #[doc(hidden)] pub use gdk::prelude::*; #[doc(hidden)] pub use glib::prelude::*; #[doc(hidden)] pub use graphene::prelude::*; #[doc(hidden)] pub use pango::prelude::*; gsk4-0.3.1/src/radial_gradient_node.rs000064400000000000000000000065100072674642500160020ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ColorStop, RenderNodeType}; use glib::translate::*; use std::mem; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRadialGradientNode")] pub struct RadialGradientNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( RadialGradientNode, ffi::GskRadialGradientNode, ffi::gsk_radial_gradient_node_get_type, RenderNodeType::RadialGradientNode ); impl RadialGradientNode { #[doc(alias = "gsk_radial_gradient_node_new")] pub fn new( bounds: &graphene::Rect, center: &graphene::Point, hradius: f32, vradius: f32, start: f32, end: f32, color_stops: &[ColorStop], ) -> Self { assert_initialized_main_thread!(); let n_color_stops = color_stops.len() as usize; unsafe { from_glib_full(ffi::gsk_radial_gradient_node_new( bounds.to_glib_none().0, center.to_glib_none().0, hradius, vradius, start, end, color_stops.to_glib_none().0, n_color_stops, )) } } #[doc(alias = "gsk_radial_gradient_node_get_center")] #[doc(alias = "get_center")] pub fn center(&self) -> graphene::Point { unsafe { from_glib_none(ffi::gsk_radial_gradient_node_get_center( self.to_glib_none().0, )) } } #[doc(alias = "gsk_radial_gradient_node_get_color_stops")] #[doc(alias = "get_color_stops")] pub fn color_stops(&self) -> Vec { unsafe { let mut n_stops = mem::MaybeUninit::uninit(); let ret = FromGlibContainer::from_glib_none_num( ffi::gsk_radial_gradient_node_get_color_stops( self.to_glib_none().0, n_stops.as_mut_ptr(), ), n_stops.assume_init() as usize, ); ret } } #[doc(alias = "gsk_radial_gradient_node_get_end")] #[doc(alias = "get_end")] pub fn end(&self) -> f32 { unsafe { ffi::gsk_radial_gradient_node_get_end(self.to_glib_none().0) } } #[doc(alias = "gsk_radial_gradient_node_get_hradius")] #[doc(alias = "get_hradius")] pub fn hradius(&self) -> f32 { unsafe { ffi::gsk_radial_gradient_node_get_hradius(self.to_glib_none().0) } } #[doc(alias = "gsk_radial_gradient_node_get_n_color_stops")] #[doc(alias = "get_n_color_stops")] pub fn n_color_stops(&self) -> usize { unsafe { ffi::gsk_radial_gradient_node_get_n_color_stops(self.to_glib_none().0) } } #[doc(alias = "gsk_radial_gradient_node_get_start")] #[doc(alias = "get_start")] pub fn start(&self) -> f32 { unsafe { ffi::gsk_radial_gradient_node_get_start(self.to_glib_none().0) } } #[doc(alias = "gsk_radial_gradient_node_get_vradius")] #[doc(alias = "get_vradius")] pub fn vradius(&self) -> f32 { unsafe { ffi::gsk_radial_gradient_node_get_vradius(self.to_glib_none().0) } } } gsk4-0.3.1/src/render_node.rs000064400000000000000000000147650072674642500141630ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ParseLocation, RenderNodeType}; use glib::translate::*; use glib::{StaticType, Type}; use std::fmt; use std::path::Path; use std::ptr; // Can't use get_type here as this is not a boxed type but another fundamental type glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRenderNode")] pub struct RenderNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr), unref => |ptr| ffi::gsk_render_node_unref(ptr), } } impl StaticType for RenderNode { #[doc(alias = "gsk_render_node_type_get_type")] fn static_type() -> Type { unsafe { from_glib(ffi::gsk_render_node_type_get_type()) } } } impl RenderNode { #[doc(alias = "gsk_render_node_deserialize")] pub fn deserialize(bytes: &glib::Bytes) -> Option { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_render_node_deserialize( bytes.to_glib_none().0, None, std::ptr::null_mut(), )) } } #[doc(alias = "gsk_render_node_deserialize")] pub fn deserialize_with_error_func( bytes: &glib::Bytes, error_func: P, ) -> Option { assert_initialized_main_thread!(); let error_func_data: P = error_func; unsafe extern "C" fn error_func_func< P: FnMut(&ParseLocation, &ParseLocation, &glib::Error), >( start: *const ffi::GskParseLocation, end: *const ffi::GskParseLocation, error: *const glib::ffi::GError, user_data: glib::ffi::gpointer, ) { let start = from_glib_borrow(start); let end = from_glib_borrow(end); let error = from_glib_borrow(error); let callback: *mut P = user_data as *const _ as usize as *mut P; (*callback)(&start, &end, &error); } let error_func = Some(error_func_func::

as _); let super_callback0: &P = &error_func_data; unsafe { from_glib_full(ffi::gsk_render_node_deserialize( bytes.to_glib_none().0, error_func, super_callback0 as *const _ as usize as *mut _, )) } } pub fn downcast(self) -> Result { unsafe { if self.node_type() == T::NODE_TYPE { Ok(from_glib_full(self.to_glib_full())) } else { Err(self) } } } pub fn downcast_ref(&self) -> Option<&T> { unsafe { if self.node_type() == T::NODE_TYPE { Some(&*(self as *const RenderNode as *const T)) } else { None } } } #[doc(alias = "gsk_render_node_draw")] pub fn draw(&self, cr: &cairo::Context) { unsafe { ffi::gsk_render_node_draw(self.to_glib_none().0, mut_override(cr.to_glib_none().0)); } } #[doc(alias = "get_bounds")] #[doc(alias = "gsk_render_node_get_bounds")] pub fn bounds(&self) -> graphene::Rect { unsafe { let mut bounds = graphene::Rect::uninitialized(); ffi::gsk_render_node_get_bounds(self.to_glib_none().0, bounds.to_glib_none_mut().0); bounds } } #[doc(alias = "get_node_type")] #[doc(alias = "gsk_render_node_get_node_type")] pub fn node_type(&self) -> RenderNodeType { unsafe { from_glib(ffi::gsk_render_node_get_node_type(self.to_glib_none().0)) } } #[doc(alias = "gsk_render_node_serialize")] pub fn serialize(&self) -> glib::Bytes { unsafe { from_glib_full(ffi::gsk_render_node_serialize(self.to_glib_none().0)) } } #[doc(alias = "gsk_render_node_write_to_file")] pub fn write_to_file>(&self, filename: P) -> Result<(), glib::Error> { unsafe { let mut error = ptr::null_mut(); let _ = ffi::gsk_render_node_write_to_file( self.to_glib_none().0, filename.as_ref().to_glib_none().0, &mut error, ); if error.is_null() { Ok(()) } else { Err(from_glib_full(error)) } } } } pub unsafe trait IsRenderNode: StaticType + FromGlibPtrFull<*mut ffi::GskRenderNode> + std::convert::AsRef + 'static { const NODE_TYPE: RenderNodeType; fn upcast(self) -> RenderNode; fn upcast_ref(&self) -> &RenderNode; } pub const NONE_RENDER_NODE: Option<&RenderNode> = None; impl fmt::Display for RenderNode { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { f.write_str("RenderNode") } } #[doc(hidden)] impl AsRef for RenderNode { fn as_ref(&self) -> &Self { self } } macro_rules! define_render_node { ($rust_type:ident, $ffi_type:path, $get_type:path, $node_type:path) => { impl ::glib::StaticType for $rust_type { fn static_type() -> ::glib::Type { unsafe { from_glib($get_type()) } } } impl std::convert::AsRef for $rust_type { fn as_ref(&self) -> &crate::RenderNode { &*self } } impl std::ops::Deref for $rust_type { type Target = crate::RenderNode; fn deref(&self) -> &Self::Target { unsafe { &*(self as *const $rust_type as *const crate::RenderNode) } } } unsafe impl crate::render_node::IsRenderNode for $rust_type { const NODE_TYPE: RenderNodeType = $node_type; fn upcast(self) -> crate::RenderNode { unsafe { from_glib_full(self.to_glib_full() as *mut ffi::GskRenderNode) } } fn upcast_ref(&self) -> &crate::RenderNode { &*self } } #[doc(hidden)] impl FromGlibPtrFull<*mut ffi::GskRenderNode> for $rust_type { unsafe fn from_glib_full(ptr: *mut ffi::GskRenderNode) -> Self { from_glib_full(ptr as *mut $ffi_type) } } impl ::std::fmt::Display for $rust_type { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.write_str(::std::stringify!($rust_type)) } } }; } gsk4-0.3.1/src/renderer.rs000064400000000000000000000024240072674642500134720ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, Renderer}; use glib::object::IsA; use glib::translate::*; pub trait RendererExtManual: 'static { #[doc(alias = "gsk_renderer_render")] fn render>(&self, root: &P, region: Option<&cairo::Region>); #[doc(alias = "gsk_renderer_render_texture")] fn render_texture>( &self, root: &P, viewport: Option<&graphene::Rect>, ) -> Option; } impl> RendererExtManual for O { fn render>(&self, root: &P, region: Option<&cairo::Region>) { unsafe { ffi::gsk_renderer_render( self.as_ref().to_glib_none().0, root.as_ref().to_glib_none().0, region.to_glib_none().0, ); } } fn render_texture>( &self, root: &P, viewport: Option<&graphene::Rect>, ) -> Option { unsafe { from_glib_full(ffi::gsk_renderer_render_texture( self.as_ref().to_glib_none().0, root.as_ref().to_glib_none().0, viewport.to_glib_none().0, )) } } } gsk4-0.3.1/src/repeat_node.rs000064400000000000000000000031010072674642500141420ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRepeatNode")] pub struct RepeatNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( RepeatNode, ffi::GskRepeatNode, ffi::gsk_repeat_node_get_type, RenderNodeType::RepeatNode ); impl RepeatNode { #[doc(alias = "gsk_repeat_node_new")] pub fn new>( bounds: &graphene::Rect, child: &P, child_bounds: Option<&graphene::Rect>, ) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_repeat_node_new( bounds.to_glib_none().0, child.as_ref().to_glib_none().0, child_bounds.to_glib_none().0, )) } } #[doc(alias = "gsk_repeat_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_repeat_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_repeat_node_get_child_bounds")] #[doc(alias = "get_child_bounds")] pub fn child_bounds(&self) -> Option { unsafe { from_glib_none(ffi::gsk_repeat_node_get_child_bounds(self.to_glib_none().0)) } } } gsk4-0.3.1/src/repeating_linear_gradient_node.rs000064400000000000000000000025550072674642500200630ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ColorStop, RenderNodeType}; use glib::translate::*; use graphene::{Point, Rect}; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRepeatingLinearGradientNode")] pub struct RepeatingLinearGradientNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( RepeatingLinearGradientNode, ffi::GskRepeatingLinearGradientNode, ffi::gsk_repeating_linear_gradient_node_get_type, RenderNodeType::RepeatingLinearGradientNode ); impl RepeatingLinearGradientNode { #[doc(alias = "gsk_repeating_linear_gradient_node_new")] pub fn new(bounds: &Rect, start: &Point, end: &Point, color_stops: &[ColorStop]) -> Self { assert_initialized_main_thread!(); let n_color_stops = color_stops.len() as usize; unsafe { from_glib_full(ffi::gsk_repeating_linear_gradient_node_new( bounds.to_glib_none().0, start.to_glib_none().0, end.to_glib_none().0, color_stops.to_glib_none().0, n_color_stops, )) } } } gsk4-0.3.1/src/repeating_radial_gradient_node.rs000064400000000000000000000030020072674642500200310ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{ColorStop, RenderNodeType}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRepeatingRadialGradientNode")] pub struct RepeatingRadialGradientNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( RepeatingRadialGradientNode, ffi::GskRepeatingRadialGradientNode, ffi::gsk_repeating_radial_gradient_node_get_type, RenderNodeType::RepeatingRadialGradientNode ); impl RepeatingRadialGradientNode { #[doc(alias = "gsk_repeating_radial_gradient_node_new")] pub fn new( bounds: &graphene::Rect, center: &graphene::Point, hradius: f32, vradius: f32, start: f32, end: f32, color_stops: &[ColorStop], ) -> Self { assert_initialized_main_thread!(); let n_color_stops = color_stops.len() as usize; unsafe { from_glib_full(ffi::gsk_repeating_radial_gradient_node_new( bounds.to_glib_none().0, center.to_glib_none().0, hradius, vradius, start, end, color_stops.to_glib_none().0, n_color_stops, )) } } } gsk4-0.3.1/src/rounded_clip_node.rs000064400000000000000000000027740072674642500153500ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType, RoundedRect}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskRoundedClipNode")] pub struct RoundedClipNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( RoundedClipNode, ffi::GskRoundedClipNode, ffi::gsk_rounded_clip_node_get_type, RenderNodeType::RoundedClipNode ); impl RoundedClipNode { #[doc(alias = "gsk_rounded_clip_node_new")] pub fn new>(child: &P, clip: &RoundedRect) -> Self { skip_assert_initialized!(); unsafe { from_glib_none(ffi::gsk_rounded_clip_node_new( child.as_ref().to_glib_none().0, clip.to_glib_none().0, )) } } #[doc(alias = "gsk_rounded_clip_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_rounded_clip_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_rounded_clip_node_get_clip")] #[doc(alias = "get_clip")] pub fn clip(&self) -> Option { unsafe { from_glib_none(ffi::gsk_rounded_clip_node_get_clip(self.to_glib_none().0)) } } } gsk4-0.3.1/src/rounded_rect.rs000064400000000000000000000103610072674642500143400ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use glib::translate::*; use graphene::{Point, Rect, Size}; use std::mem; #[derive(Clone, Debug)] #[doc(alias = "GskRoundedRect")] pub struct RoundedRect(ffi::GskRoundedRect); impl RoundedRect { #[doc(alias = "gsk_rounded_rect_init")] pub fn new( bounds: Rect, top_left: Size, top_right: Size, bottom_right: Size, bottom_left: Size, ) -> Self { assert_initialized_main_thread!(); unsafe { let mut rounded_rect = mem::MaybeUninit::uninit(); ffi::gsk_rounded_rect_init( rounded_rect.as_mut_ptr(), bounds.to_glib_none().0, top_left.to_glib_none().0, top_right.to_glib_none().0, bottom_right.to_glib_none().0, bottom_left.to_glib_none().0, ); Self(rounded_rect.assume_init()) } } #[doc(alias = "gsk_rounded_rect_init_from_rect")] #[doc(alias = "init_from_rect")] pub fn from_rect(bounds: Rect, radius: f32) -> Self { assert_initialized_main_thread!(); unsafe { let mut rounded_rect = mem::MaybeUninit::uninit(); ffi::gsk_rounded_rect_init_from_rect( rounded_rect.as_mut_ptr(), bounds.to_glib_none().0, radius, ); Self(rounded_rect.assume_init()) } } #[doc(alias = "gsk_rounded_rect_init")] pub fn init( &mut self, bounds: Rect, top_left: Size, top_right: Size, bottom_right: Size, bottom_left: Size, ) { unsafe { ffi::gsk_rounded_rect_init( &mut self.0, bounds.to_glib_none().0, top_left.to_glib_none().0, top_right.to_glib_none().0, bottom_right.to_glib_none().0, bottom_left.to_glib_none().0, ); } } #[doc(alias = "gsk_rounded_rect_init_from_rect")] pub fn init_from_rect(&mut self, bounds: Rect, radius: f32) { unsafe { ffi::gsk_rounded_rect_init_from_rect(&mut self.0, bounds.to_glib_none().0, radius); } } #[doc(alias = "gsk_rounded_rect_normalize")] pub fn normalize(&mut self) { unsafe { ffi::gsk_rounded_rect_normalize(&mut self.0); } } #[doc(alias = "gsk_rounded_rect_offset")] pub fn offset(&mut self, dx: f32, dy: f32) { unsafe { ffi::gsk_rounded_rect_offset(&mut self.0, dx, dy); } } #[doc(alias = "gsk_rounded_rect_shrink")] pub fn shrink(&mut self, top: f32, right: f32, bottom: f32, left: f32) { unsafe { ffi::gsk_rounded_rect_shrink(&mut self.0, top, right, bottom, left); } } #[doc(alias = "gsk_rounded_rect_is_rectilinear")] pub fn is_rectilinear(&self) -> bool { unsafe { from_glib(ffi::gsk_rounded_rect_is_rectilinear(&self.0)) } } #[doc(alias = "gsk_rounded_rect_contains_point")] pub fn contains_point(&self, point: Point) -> bool { unsafe { from_glib(ffi::gsk_rounded_rect_contains_point( &self.0, point.to_glib_none().0, )) } } #[doc(alias = "gsk_rounded_rect_contains_rect")] pub fn contains_rect(&self, rect: Rect) -> bool { unsafe { from_glib(ffi::gsk_rounded_rect_contains_rect( &self.0, rect.to_glib_none().0, )) } } #[doc(alias = "gsk_rounded_rect_intersects_rect")] pub fn intersects_rect(&self, rect: Rect) -> bool { unsafe { from_glib(ffi::gsk_rounded_rect_intersects_rect( &self.0, rect.to_glib_none().0, )) } } } #[doc(hidden)] impl FromGlibPtrNone<*const ffi::GskRoundedRect> for RoundedRect { unsafe fn from_glib_none(ptr: *const ffi::GskRoundedRect) -> Self { Self(*ptr) } } #[doc(hidden)] impl<'a> ToGlibPtr<'a, *const ffi::GskRoundedRect> for RoundedRect { type Storage = &'a Self; fn to_glib_none(&'a self) -> Stash<*const ffi::GskRoundedRect, Self> { Stash(&self.0, self) } } gsk4-0.3.1/src/shadow.rs000064400000000000000000000066060072674642500131570ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use gdk::RGBA; use glib::translate::*; use std::mem; use std::ptr; #[derive(Clone, Copy, Debug)] #[repr(C)] #[doc(alias = "GskShadow")] pub struct Shadow(ffi::GskShadow); impl Shadow { pub fn new(color: RGBA, dx: f32, dy: f32, radius: f32) -> Self { assert_initialized_main_thread!(); Self(ffi::GskShadow { color: unsafe { *color.to_glib_none().0 }, dx, dy, radius, }) } pub fn color(&self) -> RGBA { unsafe { from_glib_none(&self.0.color as *const _) } } pub fn dx(&self) -> f32 { self.0.dx } pub fn dy(&self) -> f32 { self.0.dy } pub fn radius(&self) -> f32 { self.0.radius } } #[doc(hidden)] impl<'a> ToGlibPtr<'a, *const ffi::GskShadow> for Shadow { type Storage = &'a Self; fn to_glib_none(&'a self) -> Stash<*const ffi::GskShadow, Self> { let ptr: *const Shadow = &*self; Stash(ptr as *const ffi::GskShadow, self) } } #[doc(hidden)] impl<'a> ToGlibPtrMut<'a, *mut ffi::GskShadow> for Shadow { type Storage = &'a mut Self; #[inline] fn to_glib_none_mut(&'a mut self) -> StashMut<'a, *mut ffi::GskShadow, Self> { let ptr: *mut Shadow = &mut *self; StashMut(ptr as *mut ffi::GskShadow, self) } } #[doc(hidden)] impl FromGlibPtrNone<*const ffi::GskShadow> for Shadow { unsafe fn from_glib_none(ptr: *const ffi::GskShadow) -> Self { *(ptr as *const Shadow) } } #[doc(hidden)] impl<'a> ToGlibContainerFromSlice<'a, *const ffi::GskShadow> for Shadow { type Storage = &'a [Self]; fn to_glib_none_from_slice(t: &'a [Self]) -> (*const ffi::GskShadow, &'a [Self]) { assert_initialized_main_thread!(); (t.as_ptr() as *const _, t) } fn to_glib_container_from_slice(t: &'a [Self]) -> (*const ffi::GskShadow, &'a [Self]) { assert_initialized_main_thread!(); (ToGlibContainerFromSlice::to_glib_full_from_slice(t), t) } fn to_glib_full_from_slice(t: &[Self]) -> *const ffi::GskShadow { assert_initialized_main_thread!(); if t.is_empty() { return ptr::null_mut(); } unsafe { let res = glib::ffi::g_malloc(mem::size_of::() * t.len()) as *mut ffi::GskShadow; ptr::copy_nonoverlapping(t.as_ptr() as *const _, res, t.len()); res } } } #[doc(hidden)] impl<'a> ToGlibContainerFromSlice<'a, *mut ffi::GskShadow> for Shadow { type Storage = &'a [Self]; fn to_glib_none_from_slice(t: &'a [Self]) -> (*mut ffi::GskShadow, &'a [Self]) { assert_initialized_main_thread!(); (t.as_ptr() as *mut ffi::GskShadow, t) } fn to_glib_container_from_slice(t: &'a [Self]) -> (*mut ffi::GskShadow, &'a [Self]) { assert_initialized_main_thread!(); (ToGlibContainerFromSlice::to_glib_full_from_slice(t), t) } fn to_glib_full_from_slice(t: &[Self]) -> *mut ffi::GskShadow { assert_initialized_main_thread!(); if t.is_empty() { return ptr::null_mut(); } unsafe { let res = glib::ffi::g_malloc(mem::size_of::() * t.len()) as *mut ffi::GskShadow; ptr::copy_nonoverlapping(t.as_ptr() as *const _, res, t.len()); res } } } gsk4-0.3.1/src/shadow_node.rs000064400000000000000000000033720072674642500141610ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType, Shadow}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskShadowNode")] pub struct ShadowNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( ShadowNode, ffi::GskShadowNode, ffi::gsk_shadow_node_get_type, RenderNodeType::ShadowNode ); impl ShadowNode { #[doc(alias = "gsk_shadow_node_new")] pub fn new>(child: &P, shadows: &[Shadow]) -> Self { skip_assert_initialized!(); let n_shadows = shadows.len() as usize; unsafe { from_glib_full(ffi::gsk_shadow_node_new( child.as_ref().to_glib_none().0, shadows.to_glib_none().0, n_shadows, )) } } #[doc(alias = "gsk_shadow_node_get_shadow")] #[doc(alias = "get_shadow")] pub fn shadow(&self, i: usize) -> Option { assert!(i < self.n_shadows()); unsafe { from_glib_none(ffi::gsk_shadow_node_get_shadow(self.to_glib_none().0, i)) } } #[doc(alias = "gsk_shadow_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> RenderNode { unsafe { from_glib_none(ffi::gsk_shadow_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_shadow_node_get_n_shadows")] #[doc(alias = "get_n_shadows")] pub fn n_shadows(&self) -> usize { unsafe { ffi::gsk_shadow_node_get_n_shadows(self.to_glib_none().0) } } } gsk4-0.3.1/src/text_node.rs000064400000000000000000000057540072674642500136660ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::RenderNodeType; use glib::object::IsA; use glib::translate::*; use std::mem; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskTextNode")] pub struct TextNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( TextNode, ffi::GskTextNode, ffi::gsk_text_node_get_type, RenderNodeType::TextNode ); impl TextNode { #[doc(alias = "gsk_text_node_new")] pub fn new>( font: &P, glyphs: &mut pango::GlyphString, color: &gdk::RGBA, offset: &graphene::Point, ) -> Option { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_text_node_new( font.as_ref().to_glib_none().0, glyphs.to_glib_none_mut().0, color.to_glib_none().0, offset.to_glib_none().0, )) } } #[doc(alias = "gsk_text_node_get_color")] #[doc(alias = "get_color")] pub fn color(&self) -> Option { unsafe { from_glib_none(ffi::gsk_text_node_get_color(self.to_glib_none().0)) } } #[doc(alias = "gsk_text_node_get_font")] #[doc(alias = "get_font")] pub fn font(&self) -> Option { unsafe { from_glib_none(ffi::gsk_text_node_get_font(self.to_glib_none().0)) } } #[doc(alias = "gsk_text_node_get_glyphs")] #[doc(alias = "get_glyphs")] pub fn glyphs(&self) -> Vec { unsafe { let mut n_glyphs = mem::MaybeUninit::uninit(); let ret = FromGlibContainer::from_glib_none_num( ffi::gsk_text_node_get_glyphs(self.to_glib_none().0, n_glyphs.as_mut_ptr()), n_glyphs.assume_init() as usize, ); ret } } #[doc(alias = "gsk_text_node_get_num_glyphs")] #[doc(alias = "get_num_glyphs")] pub fn num_glyphs(&self) -> u32 { unsafe { ffi::gsk_text_node_get_num_glyphs(self.to_glib_none().0) } } #[doc(alias = "gsk_text_node_get_offset")] #[doc(alias = "get_offset")] pub fn offset(&self) -> Option { unsafe { from_glib_none(ffi::gsk_text_node_get_offset(self.to_glib_none().0)) } } #[doc(alias = "gsk_text_node_has_color_glyphs")] #[cfg(any(feature = "v4_2", feature = "dox"))] #[cfg_attr(feature = "dox", doc(cfg(feature = "v4_2")))] // rustdoc-stripper-ignore-next // // Due to https://gitlab.gnome.org/GNOME/gtk/-/issues/3675 this function wasn't properly // exported in 4.0.0 and so requires 4.1.2 at least for it to work properly. pub fn has_color_glyphs(&self) -> bool { unsafe { from_glib(ffi::gsk_text_node_has_color_glyphs(self.to_glib_none().0)) } } } gsk4-0.3.1/src/texture_node.rs000064400000000000000000000023660072674642500143760ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::RenderNodeType; use glib::object::IsA; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskTextureNode")] pub struct TextureNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( TextureNode, ffi::GskTextureNode, ffi::gsk_texture_node_get_type, RenderNodeType::TextureNode ); impl TextureNode { #[doc(alias = "gsk_texture_node_new")] pub fn new>(texture: &P, bounds: &graphene::Rect) -> Self { assert_initialized_main_thread!(); unsafe { from_glib_full(ffi::gsk_texture_node_new( texture.as_ref().to_glib_none().0, bounds.to_glib_none().0, )) } } #[doc(alias = "gsk_texture_node_get_texture")] #[doc(alias = "get_texture")] pub fn texture(&self) -> Option { unsafe { from_glib_none(ffi::gsk_texture_node_get_texture(self.to_glib_none().0)) } } } gsk4-0.3.1/src/transform_node.rs000064400000000000000000000027610072674642500147100ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. use crate::{RenderNode, RenderNodeType, Transform}; use glib::translate::*; glib::wrapper! { #[derive(Debug, PartialEq, Eq, PartialOrd, Ord, Hash)] #[doc(alias = "GskTransformNode")] pub struct TransformNode(Shared); match fn { ref => |ptr| ffi::gsk_render_node_ref(ptr as *mut ffi::GskRenderNode), unref => |ptr| ffi::gsk_render_node_unref(ptr as *mut ffi::GskRenderNode), } } define_render_node!( TransformNode, ffi::GskTransformNode, ffi::gsk_transform_node_get_type, RenderNodeType::TransformNode ); impl TransformNode { #[doc(alias = "gsk_transform_node_new")] pub fn new>(child: &P, transform: &Transform) -> Self { skip_assert_initialized!(); unsafe { from_glib_full(ffi::gsk_transform_node_new( child.as_ref().to_glib_none().0, transform.to_glib_none().0, )) } } #[doc(alias = "gsk_transform_node_get_child")] #[doc(alias = "get_child")] pub fn child(&self) -> Option { unsafe { from_glib_none(ffi::gsk_transform_node_get_child(self.to_glib_none().0)) } } #[doc(alias = "gsk_transform_node_get_transform")] #[doc(alias = "get_transform")] pub fn transform(&self) -> Option { unsafe { from_glib_none(ffi::gsk_transform_node_get_transform(self.to_glib_none().0)) } } } gsk4-0.3.1/tests/check_gir.rs000064400000000000000000000003640072674642500141560ustar 00000000000000// Take a look at the license at the top of the repository in the LICENSE file. #[test] fn check_gir_file() { let res = gir_format_check::check_gir_file("Gir.toml"); println!("{}", res.to_string()); assert_eq!(res.nb_errors, 0); }