gtk4-layer-shell-sys-0.3.0/.cargo_vcs_info.json0000644000000001620000000000100147370ustar { "git": { "sha1": "97e432b9f377b0e5912a6359e4ae2835c07545d5" }, "path_in_vcs": "gtk4-layer-shell-sys" }gtk4-layer-shell-sys-0.3.0/Cargo.toml0000644000000034130000000000100127370ustar # 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 are reading this file be aware that the original Cargo.toml # will likely look very different (and much more reasonable). # See Cargo.toml.orig for the original contents. [package] edition = "2021" rust-version = "1.70" name = "gtk4-layer-shell-sys" version = "0.3.0" authors = ["pentamassiv "] build = "build.rs" autobins = false autoexamples = false autotests = false autobenches = false description = "Unsave gir-generated FFI bindings for gtk4-layer-shell" documentation = "https://docs.rs/gtk4-layer-shell-sys/" readme = "README.md" keywords = [ "gtk4", "gtk4-layer-shell", "wayland", "FFI", "unsafe", ] categories = [ "external-ffi-bindings", "gui", ] license = "MIT" repository = "https://github.com/pentamassiv/gtk4-layer-shell-gir/tree/main/gtk4-layer-shell-sys" [package.metadata.docs.rs] all-features = true rustc-args = [ "--cfg", "docsrs", ] rustdoc-args = [ "--cfg", "docsrs", "--generate-link-to-definition", ] [package.metadata.system-deps.gtk4_layer_shell_0] name = "gtk4-layer-shell-0" version = "1" [lib] name = "gtk4_layer_shell_sys" path = "src/lib.rs" [[test]] name = "abi" path = "tests/abi.rs" [dependencies.gdk4-sys] version = "0.9" [dependencies.glib-sys] version = "0.20" [dependencies.gtk4-sys] version = "0.9" [dependencies.libc] version = "0.2" [dev-dependencies.shell-words] version = "1.0.0" [dev-dependencies.tempfile] version = "3" [build-dependencies.system-deps] version = "7" [features] gtk4-layer-shell-sys-0.3.0/Cargo.toml.orig000064400000000000000000000021241046102023000164160ustar 00000000000000[package] name = "gtk4-layer-shell-sys" version = "0.3.0" description = "Unsave gir-generated FFI bindings for gtk4-layer-shell" repository = "https://github.com/pentamassiv/gtk4-layer-shell-gir/tree/main/gtk4-layer-shell-sys" documentation = "https://docs.rs/gtk4-layer-shell-sys/" keywords = ["gtk4", "gtk4-layer-shell", "wayland", "FFI", "unsafe"] categories = ["external-ffi-bindings", "gui"] build = "build.rs" [package.authors] workspace = true [package.rust-version] workspace = true [package.edition] workspace = true [package.license] workspace = true [package.metadata.system-deps.gtk4_layer_shell_0] name = "gtk4-layer-shell-0" version = "1" [package.metadata.docs.rs] all-features = true rustc-args = ["--cfg", "docsrs"] rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"] [lib] name = "gtk4_layer_shell_sys" [dependencies] libc = "0.2" [dependencies.glib-sys] workspace = true [dependencies.gdk4-sys] workspace = true [dependencies.gtk4-sys] workspace = true [build-dependencies] system-deps = "7" [dev-dependencies] shell-words = "1.0.0" tempfile = "3" [features] gtk4-layer-shell-sys-0.3.0/Gir.toml000064400000000000000000000004051046102023000151450ustar 00000000000000[options] library = "Gtk4LayerShell" version = "1.0" target_path = "." min_cfg_version = "1.0" work_mode = "sys" girs_directories = ["../gir-files", ".."] single_version_file = true external_libraries = ["GLib"] [external_libraries] gdk4 = "Gdk" gtk4 = "Gtk" gtk4-layer-shell-sys-0.3.0/README.md000064400000000000000000000067401046102023000150160ustar 00000000000000[![maintenance-status: passively-maintained (as of 2022-10-01)](https://img.shields.io/badge/maintenance--status-passively--maintained_%28as_of_2022--10--01%29-forestgreen)](https://gist.github.com/rusty-snake/574a91f1df9f97ec77ca308d6d731e29) ![dependabot status](https://img.shields.io/badge/dependabot-enabled-025e8c?logo=Dependabot) [![Build](https://img.shields.io/github/actions/workflow/status/pentamassiv/gtk4-layer-shell-gir/build.yaml?branch=main)](https://github.com/pentamassiv/gtk4-layer-shell-gir/actions/workflows/build.yaml) gtk4-layer-shell-sys: [![Crate](https://img.shields.io/crates/v/gtk4-layer-shell-sys.svg)](https://crates.io/crates/gtk4-layer-shell-sys) [![docs.rs](https://docs.rs/gtk4-layer-shell-sys/badge.svg)](https://docs.rs/gtk4-layer-shell-sys) [![dependency status](https://deps.rs/crate/gtk4-layer-shell-sys/0.3.0/status.svg)](https://deps.rs/crate/gtk4-layer-shell-sys/0.3.0) # gtk4-layer-shell-sys These are the unsafe FFI bindings for [gtk4-layer-shell](https://github.com/wmww/gtk4-layer-shell). They were automatically generated from its [.gir file](../Gtk4LayerShell-1.0.gir). You need to have gtk4-layer-shell installed on your system to use this crate. Because it is new, you probably have to [build it from source](https://github.com/wmww/gtk4-layer-shell#building-from-source). If you did that, you might also have to set the following two environment variables: ```bash export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig export LD_LIBRARY_PATH=/usr/local/lib ``` This crate is GTK4 only. Checkout [gtk-layer-shell-sys](https://crates.io/crates/gtk-layer-shell-sys) if you want the GTK3 version. ## Usage These are the unsafe bindings. You most likely want to use the safe [wrapper](https://github.com/pentamassiv/gtk4-layer-shell-gir/tree/main/gtk4-layer-shell). ## Generating the bindings Generating the bindings yourself is not necessary to be able to use it. If you want to do it anyways, here are the steps you can follow to generate the bindings yourself. You need to have Rust, Gtk4 and gtk4-layer-shell installed. Clone the repository AND the submodules "gir" and "gir-files". ```bash git clone --recurse-submodules -j8 https://github.com/pentamassiv/gtk4-layer-shell-gir.git cd ./gtk4-layer-shell-gir ``` Then you need to install gir. ```bash cd gir cargo install --path . cd .. ``` If you regenerate the binding, because you have a new version of the Gtk4LayerShell gir file, copy it into the [gir files](../gir-files) folder. Now you can generate, build and test the bindings. ```bash export PKG_CONFIG_PATH=/usr/local/lib/pkgconfig cd gtk4-layer-shell-sys # Needed when the lib is built from source gir -o . # Regenerate the bindings cargo build # Build the created bindings cargo test # Test the created bindings cd .. ``` There should not have been any errors. You should now continue and generate the [safe wrapper](https://github.com/pentamassiv/gtk4-layer-shell-gir/tree/main/gtk4-layer-shell/README.md#generating-the-wrapper). If you want to learn more about gir, have a look at its [repo](https://github.com/gtk-rs/gir) or its [book](https://gtk-rs.org/gir/book/). ## Maintenance status This crate is just an unsafe wrapper for the C library so it is feature complete and not actively worked on. There are Github Actions keeping the dependencies up-to-date. If you encounter any problems, feel free to open a PR. ## Contributing Pull requests are very welcome but please keep the maintenance status in mind. ## License [MIT](https://choosealicense.com/licenses/mit/) gtk4-layer-shell-sys-0.3.0/build.rs000064400000000000000000000006241046102023000151770ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #[cfg(not(docsrs))] use std::process; #[cfg(docsrs)] fn main() {} // prevent linking libraries to avoid documentation failure #[cfg(not(docsrs))] fn main() { if let Err(s) = system_deps::Config::new().probe() { println!("cargo:warning={s}"); process::exit(1); } } gtk4-layer-shell-sys-0.3.0/src/auto/versions.txt000064400000000000000000000001751046102023000177030ustar 00000000000000Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) from .. (@ cce93db83b00+) from ../gir-files (@ 4d1189172a70) gtk4-layer-shell-sys-0.3.0/src/lib.rs000064400000000000000000000100501046102023000154270ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] #![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal, clippy::upper_case_acronyms)] #![cfg_attr(docsrs, feature(doc_cfg))] use glib_sys as glib; use gdk4_sys as gdk; use gtk4_sys as gtk; mod manual; pub use manual::*; #[allow(unused_imports)] use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double, c_short, c_ushort, c_long, c_ulong, c_void, size_t, ssize_t, time_t, off_t, intptr_t, uintptr_t, FILE}; #[cfg(unix)] #[allow(unused_imports)] use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t}; #[allow(unused_imports)] use glib::{gboolean, gconstpointer, gpointer, GType}; // Enums pub type GtkLayerShellEdge = c_int; pub const GTK_LAYER_SHELL_EDGE_LEFT: GtkLayerShellEdge = 0; pub const GTK_LAYER_SHELL_EDGE_RIGHT: GtkLayerShellEdge = 1; pub const GTK_LAYER_SHELL_EDGE_TOP: GtkLayerShellEdge = 2; pub const GTK_LAYER_SHELL_EDGE_BOTTOM: GtkLayerShellEdge = 3; pub const GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER: GtkLayerShellEdge = 4; pub type GtkLayerShellKeyboardMode = c_int; pub const GTK_LAYER_SHELL_KEYBOARD_MODE_NONE: GtkLayerShellKeyboardMode = 0; pub const GTK_LAYER_SHELL_KEYBOARD_MODE_EXCLUSIVE: GtkLayerShellKeyboardMode = 1; pub const GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND: GtkLayerShellKeyboardMode = 2; pub const GTK_LAYER_SHELL_KEYBOARD_MODE_ENTRY_NUMBER: GtkLayerShellKeyboardMode = 3; pub type GtkLayerShellLayer = c_int; pub const GTK_LAYER_SHELL_LAYER_BACKGROUND: GtkLayerShellLayer = 0; pub const GTK_LAYER_SHELL_LAYER_BOTTOM: GtkLayerShellLayer = 1; pub const GTK_LAYER_SHELL_LAYER_TOP: GtkLayerShellLayer = 2; pub const GTK_LAYER_SHELL_LAYER_OVERLAY: GtkLayerShellLayer = 3; pub const GTK_LAYER_SHELL_LAYER_ENTRY_NUMBER: GtkLayerShellLayer = 4; #[link(name = "gtk4-layer-shell")] extern "C" { //========================================================================= // Other functions //========================================================================= pub fn gtk_layer_auto_exclusive_zone_enable(window: *mut gtk::GtkWindow); pub fn gtk_layer_auto_exclusive_zone_is_enabled(window: *mut gtk::GtkWindow) -> gboolean; pub fn gtk_layer_get_anchor(window: *mut gtk::GtkWindow, edge: GtkLayerShellEdge) -> gboolean; pub fn gtk_layer_get_exclusive_zone(window: *mut gtk::GtkWindow) -> c_int; pub fn gtk_layer_get_keyboard_mode(window: *mut gtk::GtkWindow) -> GtkLayerShellKeyboardMode; pub fn gtk_layer_get_layer(window: *mut gtk::GtkWindow) -> GtkLayerShellLayer; pub fn gtk_layer_get_major_version() -> c_uint; pub fn gtk_layer_get_margin(window: *mut gtk::GtkWindow, edge: GtkLayerShellEdge) -> c_int; pub fn gtk_layer_get_micro_version() -> c_uint; pub fn gtk_layer_get_minor_version() -> c_uint; pub fn gtk_layer_get_monitor(window: *mut gtk::GtkWindow) -> *mut gdk::GdkMonitor; pub fn gtk_layer_get_namespace(window: *mut gtk::GtkWindow) -> *const c_char; pub fn gtk_layer_get_protocol_version() -> c_uint; pub fn gtk_layer_get_zwlr_layer_surface_v1(window: *mut gtk::GtkWindow) -> *mut zwlr_layer_surface_v1; pub fn gtk_layer_init_for_window(window: *mut gtk::GtkWindow); pub fn gtk_layer_is_layer_window(window: *mut gtk::GtkWindow) -> gboolean; pub fn gtk_layer_is_supported() -> gboolean; pub fn gtk_layer_set_anchor(window: *mut gtk::GtkWindow, edge: GtkLayerShellEdge, anchor_to_edge: gboolean); pub fn gtk_layer_set_exclusive_zone(window: *mut gtk::GtkWindow, exclusive_zone: c_int); pub fn gtk_layer_set_keyboard_mode(window: *mut gtk::GtkWindow, mode: GtkLayerShellKeyboardMode); pub fn gtk_layer_set_layer(window: *mut gtk::GtkWindow, layer: GtkLayerShellLayer); pub fn gtk_layer_set_margin(window: *mut gtk::GtkWindow, edge: GtkLayerShellEdge, margin_size: c_int); pub fn gtk_layer_set_monitor(window: *mut gtk::GtkWindow, monitor: *mut gdk::GdkMonitor); pub fn gtk_layer_set_namespace(window: *mut gtk::GtkWindow, name_space: *const c_char); } gtk4-layer-shell-sys-0.3.0/src/manual.rs000064400000000000000000000001041046102023000161350ustar 00000000000000use glib_sys::gpointer; pub type zwlr_layer_surface_v1 = gpointer; gtk4-layer-shell-sys-0.3.0/tests/abi.rs000064400000000000000000000163711046102023000160030ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #![cfg(unix)] use gtk4_layer_shell_sys::*; use std::mem::{align_of, size_of}; use std::env; use std::error::Error; use std::ffi::OsString; use std::path::Path; use std::process::{Command, Stdio}; use std::str; use tempfile::Builder; static PACKAGES: &[&str] = &["gtk4-layer-shell-0"]; #[derive(Clone, Debug)] struct Compiler { pub args: Vec, } impl Compiler { pub fn new() -> Result> { let mut args = get_var("CC", "cc")?; args.push("-Wno-deprecated-declarations".to_owned()); // For _Generic args.push("-std=c11".to_owned()); // For %z support in printf when using MinGW. args.push("-D__USE_MINGW_ANSI_STDIO".to_owned()); args.extend(get_var("CFLAGS", "")?); args.extend(get_var("CPPFLAGS", "")?); args.extend(pkg_config_cflags(PACKAGES)?); Ok(Self { args }) } pub fn compile(&self, src: &Path, out: &Path) -> Result<(), Box> { let mut cmd = self.to_command(); cmd.arg(src); cmd.arg("-o"); cmd.arg(out); let status = cmd.spawn()?.wait()?; if !status.success() { return Err(format!("compilation command {cmd:?} failed, {status}").into()); } Ok(()) } fn to_command(&self) -> Command { let mut cmd = Command::new(&self.args[0]); cmd.args(&self.args[1..]); cmd } } fn get_var(name: &str, default: &str) -> Result, Box> { match env::var(name) { Ok(value) => Ok(shell_words::split(&value)?), Err(env::VarError::NotPresent) => Ok(shell_words::split(default)?), Err(err) => Err(format!("{name} {err}").into()), } } fn pkg_config_cflags(packages: &[&str]) -> Result, Box> { if packages.is_empty() { return Ok(Vec::new()); } let pkg_config = env::var_os("PKG_CONFIG") .unwrap_or_else(|| OsString::from("pkg-config")); let mut cmd = Command::new(pkg_config); cmd.arg("--cflags"); cmd.args(packages); cmd.stderr(Stdio::inherit()); let out = cmd.output()?; if !out.status.success() { let (status, stdout) = (out.status, String::from_utf8_lossy(&out.stdout)); return Err(format!("command {cmd:?} failed, {status:?}\nstdout: {stdout}").into()); } let stdout = str::from_utf8(&out.stdout)?; Ok(shell_words::split(stdout.trim())?) } #[derive(Copy, Clone, Debug, Eq, PartialEq)] struct Layout { size: usize, alignment: usize, } #[derive(Copy, Clone, Debug, Default, Eq, PartialEq)] struct Results { /// Number of successfully completed tests. passed: usize, /// Total number of failed tests (including those that failed to compile). failed: usize, } impl Results { fn record_passed(&mut self) { self.passed += 1; } fn record_failed(&mut self) { self.failed += 1; } fn summary(&self) -> String { format!("{} passed; {} failed", self.passed, self.failed) } fn expect_total_success(&self) { if self.failed == 0 { println!("OK: {}", self.summary()); } else { panic!("FAILED: {}", self.summary()); }; } } #[test] fn cross_validate_constants_with_c() { let mut c_constants: Vec<(String, String)> = Vec::new(); for l in get_c_output("constant").unwrap().lines() { let (name, value) = l.split_once(';').expect("Missing ';' separator"); c_constants.push((name.to_owned(), value.to_owned())); } let mut results = Results::default(); for ((rust_name, rust_value), (c_name, c_value)) in RUST_CONSTANTS.iter().zip(c_constants.iter()) { if rust_name != c_name { results.record_failed(); eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}"); continue; } if rust_value != c_value { results.record_failed(); eprintln!( "Constant value mismatch for {rust_name}\nRust: {rust_value:?}\nC: {c_value:?}", ); continue; } results.record_passed(); } results.expect_total_success(); } #[test] fn cross_validate_layout_with_c() { let mut c_layouts = Vec::new(); for l in get_c_output("layout").unwrap().lines() { let (name, value) = l.split_once(';').expect("Missing first ';' separator"); let (size, alignment) = value.split_once(';').expect("Missing second ';' separator"); let size = size.parse().expect("Failed to parse size"); let alignment = alignment.parse().expect("Failed to parse alignment"); c_layouts.push((name.to_owned(), Layout { size, alignment })); } let mut results = Results::default(); for ((rust_name, rust_layout), (c_name, c_layout)) in RUST_LAYOUTS.iter().zip(c_layouts.iter()) { if rust_name != c_name { results.record_failed(); eprintln!("Name mismatch:\nRust: {rust_name:?}\nC: {c_name:?}"); continue; } if rust_layout != c_layout { results.record_failed(); eprintln!( "Layout mismatch for {rust_name}\nRust: {rust_layout:?}\nC: {c_layout:?}", ); continue; } results.record_passed(); } results.expect_total_success(); } fn get_c_output(name: &str) -> Result> { let tmpdir = Builder::new().prefix("abi").tempdir()?; let exe = tmpdir.path().join(name); let c_file = Path::new("tests").join(name).with_extension("c"); let cc = Compiler::new().expect("configured compiler"); cc.compile(&c_file, &exe)?; let mut cmd = Command::new(exe); cmd.stderr(Stdio::inherit()); let out = cmd.output()?; if !out.status.success() { let (status, stdout) = (out.status, String::from_utf8_lossy(&out.stdout)); return Err(format!("command {cmd:?} failed, {status:?}\nstdout: {stdout}").into()); } Ok(String::from_utf8(out.stdout)?) } const RUST_LAYOUTS: &[(&str, Layout)] = &[ ("GtkLayerShellEdge", Layout {size: size_of::(), alignment: align_of::()}), ("GtkLayerShellKeyboardMode", Layout {size: size_of::(), alignment: align_of::()}), ("GtkLayerShellLayer", Layout {size: size_of::(), alignment: align_of::()}), ]; const RUST_CONSTANTS: &[(&str, &str)] = &[ ("(gint) GTK_LAYER_SHELL_EDGE_BOTTOM", "3"), ("(gint) GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER", "4"), ("(gint) GTK_LAYER_SHELL_EDGE_LEFT", "0"), ("(gint) GTK_LAYER_SHELL_EDGE_RIGHT", "1"), ("(gint) GTK_LAYER_SHELL_EDGE_TOP", "2"), ("(gint) GTK_LAYER_SHELL_KEYBOARD_MODE_ENTRY_NUMBER", "3"), ("(gint) GTK_LAYER_SHELL_KEYBOARD_MODE_EXCLUSIVE", "1"), ("(gint) GTK_LAYER_SHELL_KEYBOARD_MODE_NONE", "0"), ("(gint) GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND", "2"), ("(gint) GTK_LAYER_SHELL_LAYER_BACKGROUND", "0"), ("(gint) GTK_LAYER_SHELL_LAYER_BOTTOM", "1"), ("(gint) GTK_LAYER_SHELL_LAYER_ENTRY_NUMBER", "4"), ("(gint) GTK_LAYER_SHELL_LAYER_OVERLAY", "3"), ("(gint) GTK_LAYER_SHELL_LAYER_TOP", "2"), ]; gtk4-layer-shell-sys-0.3.0/tests/constant.c000064400000000000000000000034561046102023000166770ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #include "manual.h" #include #define PRINT_CONSTANT(CONSTANT_NAME) \ printf("%s;", #CONSTANT_NAME); \ printf(_Generic((CONSTANT_NAME), \ char *: "%s", \ const char *: "%s", \ char: "%c", \ signed char: "%hhd", \ unsigned char: "%hhu", \ short int: "%hd", \ unsigned short int: "%hu", \ int: "%d", \ unsigned int: "%u", \ long: "%ld", \ unsigned long: "%lu", \ long long: "%lld", \ unsigned long long: "%llu", \ float: "%f", \ double: "%f", \ long double: "%ld"), \ CONSTANT_NAME); \ printf("\n"); int main() { PRINT_CONSTANT((gint) GTK_LAYER_SHELL_EDGE_BOTTOM); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_EDGE_ENTRY_NUMBER); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_EDGE_LEFT); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_EDGE_RIGHT); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_EDGE_TOP); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_KEYBOARD_MODE_ENTRY_NUMBER); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_KEYBOARD_MODE_EXCLUSIVE); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_KEYBOARD_MODE_NONE); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_KEYBOARD_MODE_ON_DEMAND); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_LAYER_BACKGROUND); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_LAYER_BOTTOM); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_LAYER_ENTRY_NUMBER); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_LAYER_OVERLAY); PRINT_CONSTANT((gint) GTK_LAYER_SHELL_LAYER_TOP); return 0; } gtk4-layer-shell-sys-0.3.0/tests/layout.c000064400000000000000000000010401046102023000163460ustar 00000000000000// This file was generated by gir (https://github.com/gtk-rs/gir) // from .. // from ../gir-files // DO NOT EDIT #include "manual.h" #include #include int main() { printf("%s;%zu;%zu\n", "GtkLayerShellEdge", sizeof(GtkLayerShellEdge), alignof(GtkLayerShellEdge)); printf("%s;%zu;%zu\n", "GtkLayerShellKeyboardMode", sizeof(GtkLayerShellKeyboardMode), alignof(GtkLayerShellKeyboardMode)); printf("%s;%zu;%zu\n", "GtkLayerShellLayer", sizeof(GtkLayerShellLayer), alignof(GtkLayerShellLayer)); return 0; } gtk4-layer-shell-sys-0.3.0/tests/manual.h000064400000000000000000000001701046102023000163160ustar 00000000000000// Feel free to edit this file, it won't be regenerated by gir generator unless removed. #include