sourceview5-sys-0.9.0/.cargo_vcs_info.json0000644000000001550000000000100141370ustar { "git": { "sha1": "01c1049b83e3da22578467d7ec3e57f571239519" }, "path_in_vcs": "sourceview5/sys" }sourceview5-sys-0.9.0/Cargo.toml0000644000000044510000000000100121400ustar # 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" name = "sourceview5-sys" version = "0.9.0" authors = ["Bilal Elmoussaoui "] build = "build.rs" description = "FFI bindings for GtkSourceView 5" homepage = "https://world.pages.gitlab.gnome.org/Rust/sourceview5-rs/" documentation = "https://world.pages.gitlab.gnome.org/Rust/sourceview5-rs/stable/latest/docs/sourceview5_sys" keywords = [ "gtk4-rs", "gnome", "sourceview", "ffi", "GUI", ] categories = [ "api-bindings", "gui", ] license = "MIT" repository = "https://gitlab.gnome.org/World/Rust/sourceview5-rs/" [package.metadata.docs.rs] features = [] rustc-args = [ "--cfg", "docsrs", ] rustdoc-args = [ "--cfg", "docsrs", "--generate-link-to-definition", ] [package.metadata.system-deps.gtksourceview_5] name = "gtksourceview-5" version = "4.90" [package.metadata.system-deps.gtksourceview_5.v5_0] version = "4.90" [package.metadata.system-deps.gtksourceview_5.v5_10] version = "5.9" [package.metadata.system-deps.gtksourceview_5.v5_12] version = "5.12" [package.metadata.system-deps.gtksourceview_5.v5_2] version = "5.2" [package.metadata.system-deps.gtksourceview_5.v5_4] version = "5.4" [package.metadata.system-deps.gtksourceview_5.v5_6] version = "5.6" [dependencies.gdk-pixbuf-sys] version = "0.20" [dependencies.gdk-sys] version = "0.9" package = "gdk4-sys" [dependencies.gio-sys] version = "0.20" [dependencies.glib-sys] version = "0.20" [dependencies.gobject-sys] version = "0.20" [dependencies.gtk-sys] version = "0.9" package = "gtk4-sys" [dependencies.libc] version = "0.2" [dependencies.pango-sys] version = "0.20" [dev-dependencies.shell-words] version = "1.0.0" [dev-dependencies.tempfile] version = "3" [build-dependencies.system-deps] version = "7" [features] v5_10 = ["v5_6"] v5_12 = ["v5_10"] v5_2 = [] v5_4 = ["v5_2"] v5_6 = ["v5_4"] sourceview5-sys-0.9.0/Cargo.toml.orig000064400000000000000000000042521046102023000156200ustar 00000000000000[package] authors = ["Bilal Elmoussaoui "] build = "build.rs" edition = "2021" name = "sourceview5-sys" version = "0.9.0" license = "MIT" homepage = "https://world.pages.gitlab.gnome.org/Rust/sourceview5-rs/" categories = ["api-bindings", "gui"] keywords = ["gtk4-rs", "gnome", "sourceview", "ffi", "GUI"] description = "FFI bindings for GtkSourceView 5" documentation = "https://world.pages.gitlab.gnome.org/Rust/sourceview5-rs/stable/latest/docs/sourceview5_sys" repository = "https://gitlab.gnome.org/World/Rust/sourceview5-rs/" [package.metadata.system-deps.gtksourceview_5] name = "gtksourceview-5" version = "4.90" [package.metadata.system-deps.gtksourceview_5.v5_0] version = "4.90" [package.metadata.system-deps.gtksourceview_5.v5_2] version = "5.2" [package.metadata.system-deps.gtksourceview_5.v5_4] version = "5.4" [package.metadata.system-deps.gtksourceview_5.v5_6] version = "5.6" [package.metadata.system-deps.gtksourceview_5.v5_10] version = "5.9" [package.metadata.system-deps.gtksourceview_5.v5_12] version = "5.12" [package.metadata.docs.rs] features = [] rustc-args = ["--cfg", "docsrs"] rustdoc-args = ["--cfg", "docsrs", "--generate-link-to-definition"] [dependencies] libc = "0.2" [dependencies.glib-sys] git = "https://github.com/gtk-rs/gtk-rs-core.git" branch = "0.20" version = "0.20" [dependencies.pango-sys] git = "https://github.com/gtk-rs/gtk-rs-core.git" branch = "0.20" version = "0.20" [dependencies.gio-sys] git = "https://github.com/gtk-rs/gtk-rs-core.git" branch = "0.20" version = "0.20" [dependencies.gdk-pixbuf-sys] git = "https://github.com/gtk-rs/gtk-rs-core.git" branch = "0.20" version = "0.20" [dependencies.gobject-sys] git = "https://github.com/gtk-rs/gtk-rs-core.git" branch = "0.20" version = "0.20" [dependencies.gtk-sys] package = "gtk4-sys" git = "https://github.com/gtk-rs/gtk4-rs.git" branch = "0.9" version = "0.9" [dependencies.gdk-sys] package = "gdk4-sys" git = "https://github.com/gtk-rs/gtk4-rs.git" branch = "0.9" version = "0.9" [build-dependencies] system-deps = "7" [dev-dependencies] shell-words = "1.0.0" tempfile = "3" [features] v5_2 = [] v5_4 = ["v5_2"] v5_6 = ["v5_4"] v5_10 = ["v5_6"] v5_12 = ["v5_10"] sourceview5-sys-0.9.0/Gir.toml000064400000000000000000000005461046102023000143510ustar 00000000000000[options] external_libraries = [ "GLib", "GObject", "Gdk", "GdkPixbuf", "Gio", "Gtk", "Pango", ] girs_directories = ["../../gir-files", "../../"] library = "GtkSource" min_cfg_version = "5.0" version = "5" work_mode = "sys" ignore = [ "GtkSource.MAJOR_VERSION", "GtkSource.MICRO_VERSION", "GtkSource.MINOR_VERSION", ]sourceview5-sys-0.9.0/build.rs000064400000000000000000000007101046102023000143710ustar 00000000000000// Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) // from // from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70) // 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); } } sourceview5-sys-0.9.0/src/lib.rs000064400000000000000000003756221046102023000146500ustar 00000000000000// Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) // from // from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70) // 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 gdk_pixbuf_sys as gdk_pixbuf; use gdk_sys as gdk; use gio_sys as gio; use glib_sys as glib; use gobject_sys as gobject; use gtk_sys as gtk; use pango_sys as pango; #[allow(unused_imports)] use libc::{ c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void, intptr_t, off_t, size_t, ssize_t, time_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 GtkSourceBackgroundPatternType = c_int; pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE: GtkSourceBackgroundPatternType = 0; pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID: GtkSourceBackgroundPatternType = 1; pub type GtkSourceBracketMatchType = c_int; pub const GTK_SOURCE_BRACKET_MATCH_NONE: GtkSourceBracketMatchType = 0; pub const GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE: GtkSourceBracketMatchType = 1; pub const GTK_SOURCE_BRACKET_MATCH_NOT_FOUND: GtkSourceBracketMatchType = 2; pub const GTK_SOURCE_BRACKET_MATCH_FOUND: GtkSourceBracketMatchType = 3; pub type GtkSourceChangeCaseType = c_int; pub const GTK_SOURCE_CHANGE_CASE_LOWER: GtkSourceChangeCaseType = 0; pub const GTK_SOURCE_CHANGE_CASE_UPPER: GtkSourceChangeCaseType = 1; pub const GTK_SOURCE_CHANGE_CASE_TOGGLE: GtkSourceChangeCaseType = 2; pub const GTK_SOURCE_CHANGE_CASE_TITLE: GtkSourceChangeCaseType = 3; pub type GtkSourceCompletionActivation = c_int; pub const GTK_SOURCE_COMPLETION_ACTIVATION_NONE: GtkSourceCompletionActivation = 0; pub const GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE: GtkSourceCompletionActivation = 1; pub const GTK_SOURCE_COMPLETION_ACTIVATION_USER_REQUESTED: GtkSourceCompletionActivation = 2; pub type GtkSourceCompletionColumn = c_int; pub const GTK_SOURCE_COMPLETION_COLUMN_ICON: GtkSourceCompletionColumn = 0; pub const GTK_SOURCE_COMPLETION_COLUMN_BEFORE: GtkSourceCompletionColumn = 1; pub const GTK_SOURCE_COMPLETION_COLUMN_TYPED_TEXT: GtkSourceCompletionColumn = 2; pub const GTK_SOURCE_COMPLETION_COLUMN_AFTER: GtkSourceCompletionColumn = 3; pub const GTK_SOURCE_COMPLETION_COLUMN_COMMENT: GtkSourceCompletionColumn = 4; pub const GTK_SOURCE_COMPLETION_COLUMN_DETAILS: GtkSourceCompletionColumn = 5; pub type GtkSourceCompressionType = c_int; pub const GTK_SOURCE_COMPRESSION_TYPE_NONE: GtkSourceCompressionType = 0; pub const GTK_SOURCE_COMPRESSION_TYPE_GZIP: GtkSourceCompressionType = 1; pub type GtkSourceFileLoaderError = c_int; pub const GTK_SOURCE_FILE_LOADER_ERROR_TOO_BIG: GtkSourceFileLoaderError = 0; pub const GTK_SOURCE_FILE_LOADER_ERROR_ENCODING_AUTO_DETECTION_FAILED: GtkSourceFileLoaderError = 1; pub const GTK_SOURCE_FILE_LOADER_ERROR_CONVERSION_FALLBACK: GtkSourceFileLoaderError = 2; pub type GtkSourceFileSaverError = c_int; pub const GTK_SOURCE_FILE_SAVER_ERROR_INVALID_CHARS: GtkSourceFileSaverError = 0; pub const GTK_SOURCE_FILE_SAVER_ERROR_EXTERNALLY_MODIFIED: GtkSourceFileSaverError = 1; pub type GtkSourceGutterRendererAlignmentMode = c_int; pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL: GtkSourceGutterRendererAlignmentMode = 0; pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST: GtkSourceGutterRendererAlignmentMode = 1; pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST: GtkSourceGutterRendererAlignmentMode = 2; pub type GtkSourceNewlineType = c_int; pub const GTK_SOURCE_NEWLINE_TYPE_LF: GtkSourceNewlineType = 0; pub const GTK_SOURCE_NEWLINE_TYPE_CR: GtkSourceNewlineType = 1; pub const GTK_SOURCE_NEWLINE_TYPE_CR_LF: GtkSourceNewlineType = 2; pub type GtkSourceSmartHomeEndType = c_int; pub const GTK_SOURCE_SMART_HOME_END_DISABLED: GtkSourceSmartHomeEndType = 0; pub const GTK_SOURCE_SMART_HOME_END_BEFORE: GtkSourceSmartHomeEndType = 1; pub const GTK_SOURCE_SMART_HOME_END_AFTER: GtkSourceSmartHomeEndType = 2; pub const GTK_SOURCE_SMART_HOME_END_ALWAYS: GtkSourceSmartHomeEndType = 3; pub type GtkSourceViewGutterPosition = c_int; pub const GTK_SOURCE_VIEW_GUTTER_POSITION_LINES: GtkSourceViewGutterPosition = -30; pub const GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS: GtkSourceViewGutterPosition = -20; // Constants // Flags pub type GtkSourceFileSaverFlags = c_uint; pub const GTK_SOURCE_FILE_SAVER_FLAGS_NONE: GtkSourceFileSaverFlags = 0; pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_INVALID_CHARS: GtkSourceFileSaverFlags = 1; pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_MODIFICATION_TIME: GtkSourceFileSaverFlags = 2; pub const GTK_SOURCE_FILE_SAVER_FLAGS_CREATE_BACKUP: GtkSourceFileSaverFlags = 4; pub type GtkSourceSortFlags = c_uint; pub const GTK_SOURCE_SORT_FLAGS_NONE: GtkSourceSortFlags = 0; pub const GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE: GtkSourceSortFlags = 1; pub const GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER: GtkSourceSortFlags = 2; pub const GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES: GtkSourceSortFlags = 4; pub type GtkSourceSpaceLocationFlags = c_uint; pub const GTK_SOURCE_SPACE_LOCATION_NONE: GtkSourceSpaceLocationFlags = 0; pub const GTK_SOURCE_SPACE_LOCATION_LEADING: GtkSourceSpaceLocationFlags = 1; pub const GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT: GtkSourceSpaceLocationFlags = 2; pub const GTK_SOURCE_SPACE_LOCATION_TRAILING: GtkSourceSpaceLocationFlags = 4; pub const GTK_SOURCE_SPACE_LOCATION_ALL: GtkSourceSpaceLocationFlags = 7; pub type GtkSourceSpaceTypeFlags = c_uint; pub const GTK_SOURCE_SPACE_TYPE_NONE: GtkSourceSpaceTypeFlags = 0; pub const GTK_SOURCE_SPACE_TYPE_SPACE: GtkSourceSpaceTypeFlags = 1; pub const GTK_SOURCE_SPACE_TYPE_TAB: GtkSourceSpaceTypeFlags = 2; pub const GTK_SOURCE_SPACE_TYPE_NEWLINE: GtkSourceSpaceTypeFlags = 4; pub const GTK_SOURCE_SPACE_TYPE_NBSP: GtkSourceSpaceTypeFlags = 8; pub const GTK_SOURCE_SPACE_TYPE_ALL: GtkSourceSpaceTypeFlags = 15; // Callbacks pub type GtkSourceMountOperationFactory = Option *mut gio::GMountOperation>; pub type GtkSourceSchedulerCallback = Option gboolean>; // Records #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceBufferClass { pub parent_class: gtk::GtkTextBufferClass, pub bracket_matched: Option< unsafe extern "C" fn( *mut GtkSourceBuffer, *mut gtk::GtkTextIter, GtkSourceBracketMatchType, ), >, pub _reserved: [gpointer; 20], } impl ::std::fmt::Debug for GtkSourceBufferClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceBufferClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("bracket_matched", &self.bracket_matched) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionCellClass { pub parent_class: gtk::GtkWidgetClass, } impl ::std::fmt::Debug for GtkSourceCompletionCellClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionCellClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceCompletionClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionContextClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceCompletionContextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionContextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionProposalInterface { pub parent_iface: gobject::GTypeInterface, pub get_typed_text: Option *mut c_char>, } impl ::std::fmt::Debug for GtkSourceCompletionProposalInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionProposalInterface @ {self:p}")) .field("parent_iface", &self.parent_iface) .field("get_typed_text", &self.get_typed_text) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionProviderInterface { pub parent_iface: gobject::GTypeInterface, pub get_title: Option *mut c_char>, pub get_priority: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, ) -> c_int, >, pub is_trigger: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *const gtk::GtkTextIter, u32, ) -> gboolean, >, pub key_activates: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut GtkSourceCompletionProposal, c_uint, gdk::GdkModifierType, ) -> gboolean, >, pub populate: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut *mut glib::GError, ) -> *mut gio::GListModel, >, pub populate_async: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut gio::GCancellable, gio::GAsyncReadyCallback, gpointer, ), >, pub populate_finish: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut gio::GAsyncResult, *mut *mut glib::GError, ) -> *mut gio::GListModel, >, pub refilter: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut gio::GListModel, ), >, pub display: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut GtkSourceCompletionProposal, *mut GtkSourceCompletionCell, ), >, pub activate: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut GtkSourceCompletionProposal, ), >, pub list_alternates: Option< unsafe extern "C" fn( *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut GtkSourceCompletionProposal, ) -> *mut glib::GPtrArray, >, } impl ::std::fmt::Debug for GtkSourceCompletionProviderInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionProviderInterface @ {self:p}")) .field("parent_iface", &self.parent_iface) .field("get_title", &self.get_title) .field("get_priority", &self.get_priority) .field("is_trigger", &self.is_trigger) .field("key_activates", &self.key_activates) .field("populate", &self.populate) .field("populate_async", &self.populate_async) .field("populate_finish", &self.populate_finish) .field("refilter", &self.refilter) .field("display", &self.display) .field("activate", &self.activate) .field("list_alternates", &self.list_alternates) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionSnippetsClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceCompletionSnippetsClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionSnippetsClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionWordsClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceCompletionWordsClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionWordsClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[repr(C)] pub struct GtkSourceEncoding { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceEncoding { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceEncoding @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceFileClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceFileClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFileClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceFileLoaderClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceFileLoaderClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFileLoaderClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceFileSaverClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceFileSaverClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFileSaverClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterClass { pub parent_class: gtk::GtkWidgetClass, } impl ::std::fmt::Debug for GtkSourceGutterClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterLinesClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceGutterLinesClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterLinesClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRendererClass { pub parent_class: gtk::GtkWidgetClass, pub query_data: Option< unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut GtkSourceGutterLines, c_uint), >, pub begin: Option, pub snapshot_line: Option< unsafe extern "C" fn( *mut GtkSourceGutterRenderer, *mut gtk::GtkSnapshot, *mut GtkSourceGutterLines, c_uint, ), >, pub end: Option, pub change_view: Option, pub change_buffer: Option, pub query_activatable: Option< unsafe extern "C" fn( *mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gdk::GdkRectangle, ) -> gboolean, >, pub activate: Option< unsafe extern "C" fn( *mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gdk::GdkRectangle, c_uint, gdk::GdkModifierType, c_int, ), >, pub _reserved: [gpointer; 20], } impl ::std::fmt::Debug for GtkSourceGutterRendererClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRendererClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("query_data", &self.query_data) .field("begin", &self.begin) .field("snapshot_line", &self.snapshot_line) .field("end", &self.end) .field("change_view", &self.change_view) .field("change_buffer", &self.change_buffer) .field("query_activatable", &self.query_activatable) .field("activate", &self.activate) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRendererPixbufClass { pub parent_class: GtkSourceGutterRendererClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceGutterRendererPixbufClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRendererPixbufClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRendererTextClass { pub parent_class: GtkSourceGutterRendererClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceGutterRendererTextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRendererTextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceHoverClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceHoverClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceHoverContextClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceHoverContextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverContextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceHoverDisplayClass { pub parent_class: gtk::GtkWidgetClass, } impl ::std::fmt::Debug for GtkSourceHoverDisplayClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverDisplayClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceHoverProviderInterface { pub parent_iface: gobject::GTypeInterface, pub populate: Option< unsafe extern "C" fn( *mut GtkSourceHoverProvider, *mut GtkSourceHoverContext, *mut GtkSourceHoverDisplay, *mut *mut glib::GError, ) -> gboolean, >, pub populate_async: Option< unsafe extern "C" fn( *mut GtkSourceHoverProvider, *mut GtkSourceHoverContext, *mut GtkSourceHoverDisplay, *mut gio::GCancellable, gio::GAsyncReadyCallback, gpointer, ), >, pub populate_finish: Option< unsafe extern "C" fn( *mut GtkSourceHoverProvider, *mut gio::GAsyncResult, *mut *mut glib::GError, ) -> gboolean, >, } impl ::std::fmt::Debug for GtkSourceHoverProviderInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverProviderInterface @ {self:p}")) .field("parent_iface", &self.parent_iface) .field("populate", &self.populate) .field("populate_async", &self.populate_async) .field("populate_finish", &self.populate_finish) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceIndenterInterface { pub parent_iface: gobject::GTypeInterface, pub is_trigger: Option< unsafe extern "C" fn( *mut GtkSourceIndenter, *mut GtkSourceView, *const gtk::GtkTextIter, gdk::GdkModifierType, c_uint, ) -> gboolean, >, pub indent: Option< unsafe extern "C" fn(*mut GtkSourceIndenter, *mut GtkSourceView, *mut gtk::GtkTextIter), >, } impl ::std::fmt::Debug for GtkSourceIndenterInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceIndenterInterface @ {self:p}")) .field("parent_iface", &self.parent_iface) .field("is_trigger", &self.is_trigger) .field("indent", &self.indent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceLanguageClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceLanguageClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceLanguageClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceLanguageManagerClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceLanguageManagerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceLanguageManagerClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceMapClass { pub parent_class: GtkSourceViewClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceMapClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMapClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceMarkAttributesClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceMarkAttributesClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMarkAttributesClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceMarkClass { pub parent_class: gtk::GtkTextMarkClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceMarkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMarkClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourcePrintCompositorClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourcePrintCompositorClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourcePrintCompositorClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceRegionClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceRegionClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceRegionClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceRegionIter { pub dummy1: gpointer, pub dummy2: u32, pub dummy3: gpointer, } impl ::std::fmt::Debug for GtkSourceRegionIter { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceRegionIter @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSearchContextClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceSearchContextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSearchContextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSearchSettingsClass { pub parent_class: gobject::GObjectClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceSearchSettingsClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSearchSettingsClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSnippetChunkClass { pub parent_class: gobject::GInitiallyUnownedClass, } impl ::std::fmt::Debug for GtkSourceSnippetChunkClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetChunkClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSnippetClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceSnippetClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSnippetContextClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceSnippetContextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetContextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSnippetManagerClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceSnippetManagerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetManagerClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSpaceDrawerClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceSpaceDrawerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSpaceDrawerClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceStyleClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeChooserButtonClass { pub parent: gtk::GtkButtonClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButtonClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!( "GtkSourceStyleSchemeChooserButtonClass @ {self:p}" )) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeChooserInterface { pub base_interface: gobject::GTypeInterface, pub get_style_scheme: Option *mut GtkSourceStyleScheme>, pub set_style_scheme: Option, pub _reserved: [gpointer; 12], } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserInterface { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeChooserInterface @ {self:p}")) .field("base_interface", &self.base_interface) .field("get_style_scheme", &self.get_style_scheme) .field("set_style_scheme", &self.set_style_scheme) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeChooserWidgetClass { pub parent: gtk::GtkWidgetClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidgetClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!( "GtkSourceStyleSchemeChooserWidgetClass @ {self:p}" )) .field("parent", &self.parent) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceStyleSchemeClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeManagerClass { pub parent_class: gobject::GObjectClass, } impl ::std::fmt::Debug for GtkSourceStyleSchemeManagerClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeManagerClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemePreviewClass { pub parent_class: gtk::GtkWidgetClass, } impl ::std::fmt::Debug for GtkSourceStyleSchemePreviewClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemePreviewClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceTagClass { pub parent_class: gtk::GtkTextTagClass, pub _reserved: [gpointer; 10], } impl ::std::fmt::Debug for GtkSourceTagClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceTagClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceViewClass { pub parent_class: gtk::GtkTextViewClass, pub line_mark_activated: Option< unsafe extern "C" fn( *mut GtkSourceView, *const gtk::GtkTextIter, c_uint, gdk::GdkModifierType, c_int, ), >, pub show_completion: Option, pub move_lines: Option, pub move_words: Option, pub push_snippet: Option< unsafe extern "C" fn(*mut GtkSourceView, *mut GtkSourceSnippet, *mut gtk::GtkTextIter), >, pub _reserved: [gpointer; 20], } impl ::std::fmt::Debug for GtkSourceViewClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceViewClass @ {self:p}")) .field("parent_class", &self.parent_class) .field("line_mark_activated", &self.line_mark_activated) .field("show_completion", &self.show_completion) .field("move_lines", &self.move_lines) .field("move_words", &self.move_words) .field("push_snippet", &self.push_snippet) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceVimIMContextClass { pub parent_class: gtk::GtkIMContextClass, } impl ::std::fmt::Debug for GtkSourceVimIMContextClass { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceVimIMContextClass @ {self:p}")) .field("parent_class", &self.parent_class) .finish() } } // Classes #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceBuffer { pub parent_instance: gtk::GtkTextBuffer, } impl ::std::fmt::Debug for GtkSourceBuffer { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceBuffer @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceCompletion { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceCompletion { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletion @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceCompletionCell { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceCompletionCell { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionCell @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceCompletionContext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceCompletionContext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionContext @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionSnippets { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourceCompletionSnippets { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionSnippets @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceCompletionWords { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourceCompletionWords { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceCompletionWords @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceFile { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourceFile { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFile @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceFileLoader { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceFileLoader { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFileLoader @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceFileSaver { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceFileSaver { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceFileSaver @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceGutter { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceGutter { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutter @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceGutterLines { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceGutterLines { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterLines @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRenderer { pub parent_instance: gtk::GtkWidget, } impl ::std::fmt::Debug for GtkSourceGutterRenderer { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRenderer @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRendererPixbuf { pub parent_instance: GtkSourceGutterRenderer, } impl ::std::fmt::Debug for GtkSourceGutterRendererPixbuf { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRendererPixbuf @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceGutterRendererText { pub parent_instance: GtkSourceGutterRenderer, } impl ::std::fmt::Debug for GtkSourceGutterRendererText { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceGutterRendererText @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceHover { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceHover { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHover @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceHoverContext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceHoverContext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverContext @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceHoverDisplay { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceHoverDisplay { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceHoverDisplay @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceLanguage { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceLanguage { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceLanguage @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceLanguageManager { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceLanguageManager { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceLanguageManager @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceMap { pub parent_instance: GtkSourceView, } impl ::std::fmt::Debug for GtkSourceMap { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMap @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceMark { pub parent_instance: gtk::GtkTextMark, } impl ::std::fmt::Debug for GtkSourceMark { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMark @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceMarkAttributes { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceMarkAttributes { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceMarkAttributes @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourcePrintCompositor { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourcePrintCompositor { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourcePrintCompositor @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceRegion { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourceRegion { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceRegion @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceSearchContext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSearchContext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSearchContext @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceSearchSettings { pub parent_instance: gobject::GObject, } impl ::std::fmt::Debug for GtkSourceSearchSettings { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSearchSettings @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceSnippet { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSnippet { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippet @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceSnippetChunk { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSnippetChunk { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetChunk @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceSnippetContext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSnippetContext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetContext @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceSnippetManager { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSnippetManager { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSnippetManager @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceSpaceDrawer { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceSpaceDrawer { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceSpaceDrawer @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceStyle { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceStyle { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyle @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceStyleScheme { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceStyleScheme { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleScheme @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeChooserButton { pub parent_instance: gtk::GtkButton, } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButton { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeChooserButton @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceStyleSchemeChooserWidget { pub parent_instance: gtk::GtkWidget, } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidget { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeChooserWidget @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceStyleSchemeManager { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceStyleSchemeManager { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemeManager @ {self:p}")) .finish() } } #[repr(C)] pub struct GtkSourceStyleSchemePreview { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceStyleSchemePreview { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceStyleSchemePreview @ {self:p}")) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceTag { pub parent_instance: gtk::GtkTextTag, } impl ::std::fmt::Debug for GtkSourceTag { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceTag @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[derive(Copy, Clone)] #[repr(C)] pub struct GtkSourceView { pub parent_instance: gtk::GtkTextView, } impl ::std::fmt::Debug for GtkSourceView { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceView @ {self:p}")) .field("parent_instance", &self.parent_instance) .finish() } } #[repr(C)] pub struct GtkSourceVimIMContext { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceVimIMContext { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { f.debug_struct(&format!("GtkSourceVimIMContext @ {self:p}")) .finish() } } // Interfaces #[repr(C)] pub struct GtkSourceCompletionProposal { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceCompletionProposal { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "GtkSourceCompletionProposal @ {self:p}") } } #[repr(C)] pub struct GtkSourceCompletionProvider { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceCompletionProvider { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "GtkSourceCompletionProvider @ {self:p}") } } #[repr(C)] pub struct GtkSourceHoverProvider { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceHoverProvider { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "GtkSourceHoverProvider @ {self:p}") } } #[repr(C)] pub struct GtkSourceIndenter { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceIndenter { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "GtkSourceIndenter @ {self:p}") } } #[repr(C)] pub struct GtkSourceStyleSchemeChooser { _data: [u8; 0], _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>, } impl ::std::fmt::Debug for GtkSourceStyleSchemeChooser { fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { write!(f, "GtkSourceStyleSchemeChooser @ {self:p}") } } #[link(name = "gtksourceview-5")] extern "C" { //========================================================================= // GtkSourceBackgroundPatternType //========================================================================= pub fn gtk_source_background_pattern_type_get_type() -> GType; //========================================================================= // GtkSourceBracketMatchType //========================================================================= pub fn gtk_source_bracket_match_type_get_type() -> GType; //========================================================================= // GtkSourceChangeCaseType //========================================================================= pub fn gtk_source_change_case_type_get_type() -> GType; //========================================================================= // GtkSourceCompletionActivation //========================================================================= pub fn gtk_source_completion_activation_get_type() -> GType; //========================================================================= // GtkSourceCompletionColumn //========================================================================= pub fn gtk_source_completion_column_get_type() -> GType; //========================================================================= // GtkSourceCompressionType //========================================================================= pub fn gtk_source_compression_type_get_type() -> GType; //========================================================================= // GtkSourceFileLoaderError //========================================================================= pub fn gtk_source_file_loader_error_get_type() -> GType; pub fn gtk_source_file_loader_error_quark() -> glib::GQuark; //========================================================================= // GtkSourceFileSaverError //========================================================================= pub fn gtk_source_file_saver_error_get_type() -> GType; pub fn gtk_source_file_saver_error_quark() -> glib::GQuark; //========================================================================= // GtkSourceGutterRendererAlignmentMode //========================================================================= pub fn gtk_source_gutter_renderer_alignment_mode_get_type() -> GType; //========================================================================= // GtkSourceNewlineType //========================================================================= pub fn gtk_source_newline_type_get_type() -> GType; //========================================================================= // GtkSourceSmartHomeEndType //========================================================================= pub fn gtk_source_smart_home_end_type_get_type() -> GType; //========================================================================= // GtkSourceViewGutterPosition //========================================================================= pub fn gtk_source_view_gutter_position_get_type() -> GType; //========================================================================= // GtkSourceFileSaverFlags //========================================================================= pub fn gtk_source_file_saver_flags_get_type() -> GType; //========================================================================= // GtkSourceSortFlags //========================================================================= pub fn gtk_source_sort_flags_get_type() -> GType; //========================================================================= // GtkSourceSpaceLocationFlags //========================================================================= pub fn gtk_source_space_location_flags_get_type() -> GType; //========================================================================= // GtkSourceSpaceTypeFlags //========================================================================= pub fn gtk_source_space_type_flags_get_type() -> GType; //========================================================================= // GtkSourceEncoding //========================================================================= pub fn gtk_source_encoding_get_type() -> GType; pub fn gtk_source_encoding_copy(enc: *const GtkSourceEncoding) -> *mut GtkSourceEncoding; pub fn gtk_source_encoding_free(enc: *mut GtkSourceEncoding); pub fn gtk_source_encoding_get_charset(enc: *const GtkSourceEncoding) -> *const c_char; pub fn gtk_source_encoding_get_name(enc: *const GtkSourceEncoding) -> *const c_char; pub fn gtk_source_encoding_to_string(enc: *const GtkSourceEncoding) -> *mut c_char; pub fn gtk_source_encoding_get_all() -> *mut glib::GSList; pub fn gtk_source_encoding_get_current() -> *const GtkSourceEncoding; pub fn gtk_source_encoding_get_default_candidates() -> *mut glib::GSList; pub fn gtk_source_encoding_get_from_charset(charset: *const c_char) -> *const GtkSourceEncoding; pub fn gtk_source_encoding_get_utf8() -> *const GtkSourceEncoding; //========================================================================= // GtkSourceRegionIter //========================================================================= pub fn gtk_source_region_iter_get_subregion( iter: *mut GtkSourceRegionIter, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ) -> gboolean; pub fn gtk_source_region_iter_is_end(iter: *mut GtkSourceRegionIter) -> gboolean; pub fn gtk_source_region_iter_next(iter: *mut GtkSourceRegionIter) -> gboolean; //========================================================================= // GtkSourceBuffer //========================================================================= pub fn gtk_source_buffer_get_type() -> GType; pub fn gtk_source_buffer_new(table: *mut gtk::GtkTextTagTable) -> *mut GtkSourceBuffer; pub fn gtk_source_buffer_new_with_language( language: *mut GtkSourceLanguage, ) -> *mut GtkSourceBuffer; pub fn gtk_source_buffer_backward_iter_to_source_mark( buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char, ) -> gboolean; pub fn gtk_source_buffer_change_case( buffer: *mut GtkSourceBuffer, case_type: GtkSourceChangeCaseType, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ); pub fn gtk_source_buffer_create_source_mark( buffer: *mut GtkSourceBuffer, name: *const c_char, category: *const c_char, where_: *const gtk::GtkTextIter, ) -> *mut GtkSourceMark; pub fn gtk_source_buffer_create_source_tag( buffer: *mut GtkSourceBuffer, tag_name: *const c_char, first_property_name: *const c_char, ... ) -> *mut gtk::GtkTextTag; pub fn gtk_source_buffer_ensure_highlight( buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter, ); pub fn gtk_source_buffer_forward_iter_to_source_mark( buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char, ) -> gboolean; pub fn gtk_source_buffer_get_context_classes_at_iter( buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter, ) -> *mut *mut c_char; pub fn gtk_source_buffer_get_highlight_matching_brackets( buffer: *mut GtkSourceBuffer, ) -> gboolean; pub fn gtk_source_buffer_get_highlight_syntax(buffer: *mut GtkSourceBuffer) -> gboolean; pub fn gtk_source_buffer_get_implicit_trailing_newline( buffer: *mut GtkSourceBuffer, ) -> gboolean; pub fn gtk_source_buffer_get_language(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceLanguage; pub fn gtk_source_buffer_get_loading(buffer: *mut GtkSourceBuffer) -> gboolean; pub fn gtk_source_buffer_get_source_marks_at_iter( buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char, ) -> *mut glib::GSList; pub fn gtk_source_buffer_get_source_marks_at_line( buffer: *mut GtkSourceBuffer, line: c_int, category: *const c_char, ) -> *mut glib::GSList; pub fn gtk_source_buffer_get_style_scheme( buffer: *mut GtkSourceBuffer, ) -> *mut GtkSourceStyleScheme; pub fn gtk_source_buffer_iter_backward_to_context_class_toggle( buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char, ) -> gboolean; pub fn gtk_source_buffer_iter_forward_to_context_class_toggle( buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char, ) -> gboolean; pub fn gtk_source_buffer_iter_has_context_class( buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter, context_class: *const c_char, ) -> gboolean; pub fn gtk_source_buffer_join_lines( buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ); pub fn gtk_source_buffer_remove_source_marks( buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter, category: *const c_char, ); pub fn gtk_source_buffer_set_highlight_matching_brackets( buffer: *mut GtkSourceBuffer, highlight: gboolean, ); pub fn gtk_source_buffer_set_highlight_syntax( buffer: *mut GtkSourceBuffer, highlight: gboolean, ); pub fn gtk_source_buffer_set_implicit_trailing_newline( buffer: *mut GtkSourceBuffer, implicit_trailing_newline: gboolean, ); pub fn gtk_source_buffer_set_language( buffer: *mut GtkSourceBuffer, language: *mut GtkSourceLanguage, ); pub fn gtk_source_buffer_set_style_scheme( buffer: *mut GtkSourceBuffer, scheme: *mut GtkSourceStyleScheme, ); pub fn gtk_source_buffer_sort_lines( buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, flags: GtkSourceSortFlags, column: c_int, ); //========================================================================= // GtkSourceCompletion //========================================================================= pub fn gtk_source_completion_get_type() -> GType; pub fn gtk_source_completion_fuzzy_highlight( haystack: *const c_char, casefold_query: *const c_char, ) -> *mut pango::PangoAttrList; pub fn gtk_source_completion_fuzzy_match( haystack: *const c_char, casefold_needle: *const c_char, priority: *mut c_uint, ) -> gboolean; pub fn gtk_source_completion_add_provider( self_: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, ); pub fn gtk_source_completion_block_interactive(self_: *mut GtkSourceCompletion); pub fn gtk_source_completion_get_buffer( self_: *mut GtkSourceCompletion, ) -> *mut GtkSourceBuffer; pub fn gtk_source_completion_get_page_size(self_: *mut GtkSourceCompletion) -> c_uint; pub fn gtk_source_completion_get_view(self_: *mut GtkSourceCompletion) -> *mut GtkSourceView; pub fn gtk_source_completion_hide(self_: *mut GtkSourceCompletion); pub fn gtk_source_completion_remove_provider( self_: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, ); pub fn gtk_source_completion_set_page_size(self_: *mut GtkSourceCompletion, page_size: c_uint); pub fn gtk_source_completion_show(self_: *mut GtkSourceCompletion); pub fn gtk_source_completion_unblock_interactive(self_: *mut GtkSourceCompletion); //========================================================================= // GtkSourceCompletionCell //========================================================================= pub fn gtk_source_completion_cell_get_type() -> GType; pub fn gtk_source_completion_cell_get_column( self_: *mut GtkSourceCompletionCell, ) -> GtkSourceCompletionColumn; pub fn gtk_source_completion_cell_get_widget( self_: *mut GtkSourceCompletionCell, ) -> *mut gtk::GtkWidget; pub fn gtk_source_completion_cell_set_gicon( self_: *mut GtkSourceCompletionCell, gicon: *mut gio::GIcon, ); pub fn gtk_source_completion_cell_set_icon_name( self_: *mut GtkSourceCompletionCell, icon_name: *const c_char, ); pub fn gtk_source_completion_cell_set_markup( self_: *mut GtkSourceCompletionCell, markup: *const c_char, ); pub fn gtk_source_completion_cell_set_paintable( self_: *mut GtkSourceCompletionCell, paintable: *mut gdk::GdkPaintable, ); pub fn gtk_source_completion_cell_set_text( self_: *mut GtkSourceCompletionCell, text: *const c_char, ); pub fn gtk_source_completion_cell_set_text_with_attributes( self_: *mut GtkSourceCompletionCell, text: *const c_char, attrs: *mut pango::PangoAttrList, ); pub fn gtk_source_completion_cell_set_widget( self_: *mut GtkSourceCompletionCell, child: *mut gtk::GtkWidget, ); //========================================================================= // GtkSourceCompletionContext //========================================================================= pub fn gtk_source_completion_context_get_type() -> GType; pub fn gtk_source_completion_context_get_activation( self_: *mut GtkSourceCompletionContext, ) -> GtkSourceCompletionActivation; pub fn gtk_source_completion_context_get_bounds( self_: *mut GtkSourceCompletionContext, begin: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ) -> gboolean; pub fn gtk_source_completion_context_get_buffer( self_: *mut GtkSourceCompletionContext, ) -> *mut GtkSourceBuffer; pub fn gtk_source_completion_context_get_busy( self_: *mut GtkSourceCompletionContext, ) -> gboolean; pub fn gtk_source_completion_context_get_completion( self_: *mut GtkSourceCompletionContext, ) -> *mut GtkSourceCompletion; pub fn gtk_source_completion_context_get_empty( self_: *mut GtkSourceCompletionContext, ) -> gboolean; pub fn gtk_source_completion_context_get_language( self_: *mut GtkSourceCompletionContext, ) -> *mut GtkSourceLanguage; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_completion_context_get_proposals_for_provider( self_: *mut GtkSourceCompletionContext, provider: *mut GtkSourceCompletionProvider, ) -> *mut gio::GListModel; pub fn gtk_source_completion_context_get_view( self_: *mut GtkSourceCompletionContext, ) -> *mut GtkSourceView; pub fn gtk_source_completion_context_get_word( self_: *mut GtkSourceCompletionContext, ) -> *mut c_char; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_completion_context_list_providers( self_: *mut GtkSourceCompletionContext, ) -> *mut gio::GListModel; pub fn gtk_source_completion_context_set_proposals_for_provider( self_: *mut GtkSourceCompletionContext, provider: *mut GtkSourceCompletionProvider, results: *mut gio::GListModel, ); //========================================================================= // GtkSourceCompletionSnippets //========================================================================= pub fn gtk_source_completion_snippets_get_type() -> GType; pub fn gtk_source_completion_snippets_new() -> *mut GtkSourceCompletionSnippets; //========================================================================= // GtkSourceCompletionWords //========================================================================= pub fn gtk_source_completion_words_get_type() -> GType; pub fn gtk_source_completion_words_new(title: *const c_char) -> *mut GtkSourceCompletionWords; pub fn gtk_source_completion_words_register( words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer, ); pub fn gtk_source_completion_words_unregister( words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer, ); //========================================================================= // GtkSourceFile //========================================================================= pub fn gtk_source_file_get_type() -> GType; pub fn gtk_source_file_new() -> *mut GtkSourceFile; pub fn gtk_source_file_check_file_on_disk(file: *mut GtkSourceFile); pub fn gtk_source_file_get_compression_type( file: *mut GtkSourceFile, ) -> GtkSourceCompressionType; pub fn gtk_source_file_get_encoding(file: *mut GtkSourceFile) -> *const GtkSourceEncoding; pub fn gtk_source_file_get_location(file: *mut GtkSourceFile) -> *mut gio::GFile; pub fn gtk_source_file_get_newline_type(file: *mut GtkSourceFile) -> GtkSourceNewlineType; pub fn gtk_source_file_is_deleted(file: *mut GtkSourceFile) -> gboolean; pub fn gtk_source_file_is_externally_modified(file: *mut GtkSourceFile) -> gboolean; pub fn gtk_source_file_is_local(file: *mut GtkSourceFile) -> gboolean; pub fn gtk_source_file_is_readonly(file: *mut GtkSourceFile) -> gboolean; pub fn gtk_source_file_set_location(file: *mut GtkSourceFile, location: *mut gio::GFile); pub fn gtk_source_file_set_mount_operation_factory( file: *mut GtkSourceFile, callback: GtkSourceMountOperationFactory, user_data: gpointer, notify: glib::GDestroyNotify, ); //========================================================================= // GtkSourceFileLoader //========================================================================= pub fn gtk_source_file_loader_get_type() -> GType; pub fn gtk_source_file_loader_new( buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, ) -> *mut GtkSourceFileLoader; pub fn gtk_source_file_loader_new_from_stream( buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, stream: *mut gio::GInputStream, ) -> *mut GtkSourceFileLoader; pub fn gtk_source_file_loader_get_buffer( loader: *mut GtkSourceFileLoader, ) -> *mut GtkSourceBuffer; pub fn gtk_source_file_loader_get_compression_type( loader: *mut GtkSourceFileLoader, ) -> GtkSourceCompressionType; pub fn gtk_source_file_loader_get_encoding( loader: *mut GtkSourceFileLoader, ) -> *const GtkSourceEncoding; pub fn gtk_source_file_loader_get_file(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceFile; pub fn gtk_source_file_loader_get_input_stream( loader: *mut GtkSourceFileLoader, ) -> *mut gio::GInputStream; pub fn gtk_source_file_loader_get_location(loader: *mut GtkSourceFileLoader) -> *mut gio::GFile; pub fn gtk_source_file_loader_get_newline_type( loader: *mut GtkSourceFileLoader, ) -> GtkSourceNewlineType; pub fn gtk_source_file_loader_load_async( loader: *mut GtkSourceFileLoader, io_priority: c_int, cancellable: *mut gio::GCancellable, progress_callback: gio::GFileProgressCallback, progress_callback_data: gpointer, progress_callback_notify: glib::GDestroyNotify, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_file_loader_load_finish( loader: *mut GtkSourceFileLoader, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError, ) -> gboolean; pub fn gtk_source_file_loader_set_candidate_encodings( loader: *mut GtkSourceFileLoader, candidate_encodings: *mut glib::GSList, ); //========================================================================= // GtkSourceFileSaver //========================================================================= pub fn gtk_source_file_saver_get_type() -> GType; pub fn gtk_source_file_saver_new( buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, ) -> *mut GtkSourceFileSaver; pub fn gtk_source_file_saver_new_with_target( buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, target_location: *mut gio::GFile, ) -> *mut GtkSourceFileSaver; pub fn gtk_source_file_saver_get_buffer(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceBuffer; pub fn gtk_source_file_saver_get_compression_type( saver: *mut GtkSourceFileSaver, ) -> GtkSourceCompressionType; pub fn gtk_source_file_saver_get_encoding( saver: *mut GtkSourceFileSaver, ) -> *const GtkSourceEncoding; pub fn gtk_source_file_saver_get_file(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceFile; pub fn gtk_source_file_saver_get_flags( saver: *mut GtkSourceFileSaver, ) -> GtkSourceFileSaverFlags; pub fn gtk_source_file_saver_get_location(saver: *mut GtkSourceFileSaver) -> *mut gio::GFile; pub fn gtk_source_file_saver_get_newline_type( saver: *mut GtkSourceFileSaver, ) -> GtkSourceNewlineType; pub fn gtk_source_file_saver_save_async( saver: *mut GtkSourceFileSaver, io_priority: c_int, cancellable: *mut gio::GCancellable, progress_callback: gio::GFileProgressCallback, progress_callback_data: gpointer, progress_callback_notify: glib::GDestroyNotify, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_file_saver_save_finish( saver: *mut GtkSourceFileSaver, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError, ) -> gboolean; pub fn gtk_source_file_saver_set_compression_type( saver: *mut GtkSourceFileSaver, compression_type: GtkSourceCompressionType, ); pub fn gtk_source_file_saver_set_encoding( saver: *mut GtkSourceFileSaver, encoding: *const GtkSourceEncoding, ); pub fn gtk_source_file_saver_set_flags( saver: *mut GtkSourceFileSaver, flags: GtkSourceFileSaverFlags, ); pub fn gtk_source_file_saver_set_newline_type( saver: *mut GtkSourceFileSaver, newline_type: GtkSourceNewlineType, ); //========================================================================= // GtkSourceGutter //========================================================================= pub fn gtk_source_gutter_get_type() -> GType; pub fn gtk_source_gutter_get_view(gutter: *mut GtkSourceGutter) -> *mut GtkSourceView; pub fn gtk_source_gutter_insert( gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int, ) -> gboolean; pub fn gtk_source_gutter_remove( gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, ); pub fn gtk_source_gutter_reorder( gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int, ); //========================================================================= // GtkSourceGutterLines //========================================================================= pub fn gtk_source_gutter_lines_get_type() -> GType; pub fn gtk_source_gutter_lines_add_class( lines: *mut GtkSourceGutterLines, line: c_uint, name: *const c_char, ); pub fn gtk_source_gutter_lines_add_qclass( lines: *mut GtkSourceGutterLines, line: c_uint, qname: glib::GQuark, ); pub fn gtk_source_gutter_lines_get_buffer( lines: *mut GtkSourceGutterLines, ) -> *mut gtk::GtkTextBuffer; pub fn gtk_source_gutter_lines_get_first(lines: *mut GtkSourceGutterLines) -> c_uint; pub fn gtk_source_gutter_lines_get_iter_at_line( lines: *mut GtkSourceGutterLines, iter: *mut gtk::GtkTextIter, line: c_uint, ); pub fn gtk_source_gutter_lines_get_last(lines: *mut GtkSourceGutterLines) -> c_uint; pub fn gtk_source_gutter_lines_get_line_yrange( lines: *mut GtkSourceGutterLines, line: c_uint, mode: GtkSourceGutterRendererAlignmentMode, y: *mut c_int, height: *mut c_int, ); pub fn gtk_source_gutter_lines_get_view( lines: *mut GtkSourceGutterLines, ) -> *mut gtk::GtkTextView; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_gutter_lines_has_any_class( lines: *mut GtkSourceGutterLines, line: c_uint, ) -> gboolean; pub fn gtk_source_gutter_lines_has_class( lines: *mut GtkSourceGutterLines, line: c_uint, name: *const c_char, ) -> gboolean; pub fn gtk_source_gutter_lines_has_qclass( lines: *mut GtkSourceGutterLines, line: c_uint, qname: glib::GQuark, ) -> gboolean; pub fn gtk_source_gutter_lines_is_cursor( lines: *mut GtkSourceGutterLines, line: c_uint, ) -> gboolean; pub fn gtk_source_gutter_lines_is_prelit( lines: *mut GtkSourceGutterLines, line: c_uint, ) -> gboolean; pub fn gtk_source_gutter_lines_is_selected( lines: *mut GtkSourceGutterLines, line: c_uint, ) -> gboolean; pub fn gtk_source_gutter_lines_remove_class( lines: *mut GtkSourceGutterLines, line: c_uint, name: *const c_char, ); pub fn gtk_source_gutter_lines_remove_qclass( lines: *mut GtkSourceGutterLines, line: c_uint, qname: glib::GQuark, ); //========================================================================= // GtkSourceGutterRenderer //========================================================================= pub fn gtk_source_gutter_renderer_get_type() -> GType; pub fn gtk_source_gutter_renderer_activate( renderer: *mut GtkSourceGutterRenderer, iter: *const gtk::GtkTextIter, area: *const gdk::GdkRectangle, button: c_uint, state: gdk::GdkModifierType, n_presses: c_int, ); pub fn gtk_source_gutter_renderer_align_cell( renderer: *mut GtkSourceGutterRenderer, line: c_uint, width: c_float, height: c_float, x: *mut c_float, y: *mut c_float, ); pub fn gtk_source_gutter_renderer_get_alignment_mode( renderer: *mut GtkSourceGutterRenderer, ) -> GtkSourceGutterRendererAlignmentMode; pub fn gtk_source_gutter_renderer_get_buffer( renderer: *mut GtkSourceGutterRenderer, ) -> *mut GtkSourceBuffer; pub fn gtk_source_gutter_renderer_get_view( renderer: *mut GtkSourceGutterRenderer, ) -> *mut GtkSourceView; pub fn gtk_source_gutter_renderer_get_xalign(renderer: *mut GtkSourceGutterRenderer) -> c_float; pub fn gtk_source_gutter_renderer_get_xpad(renderer: *mut GtkSourceGutterRenderer) -> c_int; pub fn gtk_source_gutter_renderer_get_yalign(renderer: *mut GtkSourceGutterRenderer) -> c_float; pub fn gtk_source_gutter_renderer_get_ypad(renderer: *mut GtkSourceGutterRenderer) -> c_int; pub fn gtk_source_gutter_renderer_query_activatable( renderer: *mut GtkSourceGutterRenderer, iter: *const gtk::GtkTextIter, area: *const gdk::GdkRectangle, ) -> gboolean; pub fn gtk_source_gutter_renderer_set_alignment_mode( renderer: *mut GtkSourceGutterRenderer, mode: GtkSourceGutterRendererAlignmentMode, ); pub fn gtk_source_gutter_renderer_set_xalign( renderer: *mut GtkSourceGutterRenderer, xalign: c_float, ); pub fn gtk_source_gutter_renderer_set_xpad(renderer: *mut GtkSourceGutterRenderer, xpad: c_int); pub fn gtk_source_gutter_renderer_set_yalign( renderer: *mut GtkSourceGutterRenderer, yalign: c_float, ); pub fn gtk_source_gutter_renderer_set_ypad(renderer: *mut GtkSourceGutterRenderer, ypad: c_int); //========================================================================= // GtkSourceGutterRendererPixbuf //========================================================================= pub fn gtk_source_gutter_renderer_pixbuf_get_type() -> GType; pub fn gtk_source_gutter_renderer_pixbuf_new() -> *mut GtkSourceGutterRenderer; pub fn gtk_source_gutter_renderer_pixbuf_get_gicon( renderer: *mut GtkSourceGutterRendererPixbuf, ) -> *mut gio::GIcon; pub fn gtk_source_gutter_renderer_pixbuf_get_icon_name( renderer: *mut GtkSourceGutterRendererPixbuf, ) -> *const c_char; pub fn gtk_source_gutter_renderer_pixbuf_get_paintable( renderer: *mut GtkSourceGutterRendererPixbuf, ) -> *mut gdk::GdkPaintable; pub fn gtk_source_gutter_renderer_pixbuf_get_pixbuf( renderer: *mut GtkSourceGutterRendererPixbuf, ) -> *mut gdk_pixbuf::GdkPixbuf; pub fn gtk_source_gutter_renderer_pixbuf_overlay_paintable( renderer: *mut GtkSourceGutterRendererPixbuf, paintable: *mut gdk::GdkPaintable, ); pub fn gtk_source_gutter_renderer_pixbuf_set_gicon( renderer: *mut GtkSourceGutterRendererPixbuf, icon: *mut gio::GIcon, ); pub fn gtk_source_gutter_renderer_pixbuf_set_icon_name( renderer: *mut GtkSourceGutterRendererPixbuf, icon_name: *const c_char, ); pub fn gtk_source_gutter_renderer_pixbuf_set_paintable( renderer: *mut GtkSourceGutterRendererPixbuf, paintable: *mut gdk::GdkPaintable, ); pub fn gtk_source_gutter_renderer_pixbuf_set_pixbuf( renderer: *mut GtkSourceGutterRendererPixbuf, pixbuf: *mut gdk_pixbuf::GdkPixbuf, ); //========================================================================= // GtkSourceGutterRendererText //========================================================================= pub fn gtk_source_gutter_renderer_text_get_type() -> GType; pub fn gtk_source_gutter_renderer_text_new() -> *mut GtkSourceGutterRenderer; pub fn gtk_source_gutter_renderer_text_measure( renderer: *mut GtkSourceGutterRendererText, text: *const c_char, width: *mut c_int, height: *mut c_int, ); pub fn gtk_source_gutter_renderer_text_measure_markup( renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, width: *mut c_int, height: *mut c_int, ); pub fn gtk_source_gutter_renderer_text_set_markup( renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, length: c_int, ); pub fn gtk_source_gutter_renderer_text_set_text( renderer: *mut GtkSourceGutterRendererText, text: *const c_char, length: c_int, ); //========================================================================= // GtkSourceHover //========================================================================= pub fn gtk_source_hover_get_type() -> GType; pub fn gtk_source_hover_add_provider( self_: *mut GtkSourceHover, provider: *mut GtkSourceHoverProvider, ); pub fn gtk_source_hover_remove_provider( self_: *mut GtkSourceHover, provider: *mut GtkSourceHoverProvider, ); //========================================================================= // GtkSourceHoverContext //========================================================================= pub fn gtk_source_hover_context_get_type() -> GType; pub fn gtk_source_hover_context_get_bounds( self_: *mut GtkSourceHoverContext, begin: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ) -> gboolean; pub fn gtk_source_hover_context_get_buffer( self_: *mut GtkSourceHoverContext, ) -> *mut GtkSourceBuffer; pub fn gtk_source_hover_context_get_iter( self_: *mut GtkSourceHoverContext, iter: *mut gtk::GtkTextIter, ) -> gboolean; pub fn gtk_source_hover_context_get_view( self_: *mut GtkSourceHoverContext, ) -> *mut GtkSourceView; //========================================================================= // GtkSourceHoverDisplay //========================================================================= pub fn gtk_source_hover_display_get_type() -> GType; pub fn gtk_source_hover_display_append( self_: *mut GtkSourceHoverDisplay, child: *mut gtk::GtkWidget, ); pub fn gtk_source_hover_display_insert_after( self_: *mut GtkSourceHoverDisplay, child: *mut gtk::GtkWidget, sibling: *mut gtk::GtkWidget, ); pub fn gtk_source_hover_display_prepend( self_: *mut GtkSourceHoverDisplay, child: *mut gtk::GtkWidget, ); pub fn gtk_source_hover_display_remove( self_: *mut GtkSourceHoverDisplay, child: *mut gtk::GtkWidget, ); //========================================================================= // GtkSourceLanguage //========================================================================= pub fn gtk_source_language_get_type() -> GType; pub fn gtk_source_language_get_globs(language: *mut GtkSourceLanguage) -> *mut *mut c_char; pub fn gtk_source_language_get_hidden(language: *mut GtkSourceLanguage) -> gboolean; pub fn gtk_source_language_get_id(language: *mut GtkSourceLanguage) -> *const c_char; pub fn gtk_source_language_get_metadata( language: *mut GtkSourceLanguage, name: *const c_char, ) -> *const c_char; pub fn gtk_source_language_get_mime_types(language: *mut GtkSourceLanguage) -> *mut *mut c_char; pub fn gtk_source_language_get_name(language: *mut GtkSourceLanguage) -> *const c_char; pub fn gtk_source_language_get_section(language: *mut GtkSourceLanguage) -> *const c_char; pub fn gtk_source_language_get_style_fallback( language: *mut GtkSourceLanguage, style_id: *const c_char, ) -> *const c_char; pub fn gtk_source_language_get_style_ids(language: *mut GtkSourceLanguage) -> *mut *mut c_char; pub fn gtk_source_language_get_style_name( language: *mut GtkSourceLanguage, style_id: *const c_char, ) -> *const c_char; //========================================================================= // GtkSourceLanguageManager //========================================================================= pub fn gtk_source_language_manager_get_type() -> GType; pub fn gtk_source_language_manager_new() -> *mut GtkSourceLanguageManager; pub fn gtk_source_language_manager_get_default() -> *mut GtkSourceLanguageManager; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_language_manager_append_search_path( lm: *mut GtkSourceLanguageManager, path: *const c_char, ); pub fn gtk_source_language_manager_get_language( lm: *mut GtkSourceLanguageManager, id: *const c_char, ) -> *mut GtkSourceLanguage; pub fn gtk_source_language_manager_get_language_ids( lm: *mut GtkSourceLanguageManager, ) -> *const *const c_char; pub fn gtk_source_language_manager_get_search_path( lm: *mut GtkSourceLanguageManager, ) -> *const *const c_char; pub fn gtk_source_language_manager_guess_language( lm: *mut GtkSourceLanguageManager, filename: *const c_char, content_type: *const c_char, ) -> *mut GtkSourceLanguage; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_language_manager_prepend_search_path( lm: *mut GtkSourceLanguageManager, path: *const c_char, ); pub fn gtk_source_language_manager_set_search_path( lm: *mut GtkSourceLanguageManager, dirs: *const *const c_char, ); //========================================================================= // GtkSourceMap //========================================================================= pub fn gtk_source_map_get_type() -> GType; pub fn gtk_source_map_new() -> *mut gtk::GtkWidget; pub fn gtk_source_map_get_view(map: *mut GtkSourceMap) -> *mut GtkSourceView; pub fn gtk_source_map_set_view(map: *mut GtkSourceMap, view: *mut GtkSourceView); //========================================================================= // GtkSourceMark //========================================================================= pub fn gtk_source_mark_get_type() -> GType; pub fn gtk_source_mark_new(name: *const c_char, category: *const c_char) -> *mut GtkSourceMark; pub fn gtk_source_mark_get_category(mark: *mut GtkSourceMark) -> *const c_char; pub fn gtk_source_mark_next( mark: *mut GtkSourceMark, category: *const c_char, ) -> *mut GtkSourceMark; pub fn gtk_source_mark_prev( mark: *mut GtkSourceMark, category: *const c_char, ) -> *mut GtkSourceMark; //========================================================================= // GtkSourceMarkAttributes //========================================================================= pub fn gtk_source_mark_attributes_get_type() -> GType; pub fn gtk_source_mark_attributes_new() -> *mut GtkSourceMarkAttributes; pub fn gtk_source_mark_attributes_get_background( attributes: *mut GtkSourceMarkAttributes, background: *mut gdk::GdkRGBA, ) -> gboolean; pub fn gtk_source_mark_attributes_get_gicon( attributes: *mut GtkSourceMarkAttributes, ) -> *mut gio::GIcon; pub fn gtk_source_mark_attributes_get_icon_name( attributes: *mut GtkSourceMarkAttributes, ) -> *const c_char; pub fn gtk_source_mark_attributes_get_pixbuf( attributes: *mut GtkSourceMarkAttributes, ) -> *const gdk_pixbuf::GdkPixbuf; pub fn gtk_source_mark_attributes_get_tooltip_markup( attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark, ) -> *mut c_char; pub fn gtk_source_mark_attributes_get_tooltip_text( attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark, ) -> *mut c_char; pub fn gtk_source_mark_attributes_render_icon( attributes: *mut GtkSourceMarkAttributes, widget: *mut gtk::GtkWidget, size: c_int, ) -> *mut gdk::GdkPaintable; pub fn gtk_source_mark_attributes_set_background( attributes: *mut GtkSourceMarkAttributes, background: *const gdk::GdkRGBA, ); pub fn gtk_source_mark_attributes_set_gicon( attributes: *mut GtkSourceMarkAttributes, gicon: *mut gio::GIcon, ); pub fn gtk_source_mark_attributes_set_icon_name( attributes: *mut GtkSourceMarkAttributes, icon_name: *const c_char, ); pub fn gtk_source_mark_attributes_set_pixbuf( attributes: *mut GtkSourceMarkAttributes, pixbuf: *const gdk_pixbuf::GdkPixbuf, ); //========================================================================= // GtkSourcePrintCompositor //========================================================================= pub fn gtk_source_print_compositor_get_type() -> GType; pub fn gtk_source_print_compositor_new( buffer: *mut GtkSourceBuffer, ) -> *mut GtkSourcePrintCompositor; pub fn gtk_source_print_compositor_new_from_view( view: *mut GtkSourceView, ) -> *mut GtkSourcePrintCompositor; pub fn gtk_source_print_compositor_draw_page( compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext, page_nr: c_int, ); pub fn gtk_source_print_compositor_get_body_font_name( compositor: *mut GtkSourcePrintCompositor, ) -> *mut c_char; pub fn gtk_source_print_compositor_get_bottom_margin( compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit, ) -> c_double; pub fn gtk_source_print_compositor_get_buffer( compositor: *mut GtkSourcePrintCompositor, ) -> *mut GtkSourceBuffer; pub fn gtk_source_print_compositor_get_footer_font_name( compositor: *mut GtkSourcePrintCompositor, ) -> *mut c_char; pub fn gtk_source_print_compositor_get_header_font_name( compositor: *mut GtkSourcePrintCompositor, ) -> *mut c_char; pub fn gtk_source_print_compositor_get_highlight_syntax( compositor: *mut GtkSourcePrintCompositor, ) -> gboolean; pub fn gtk_source_print_compositor_get_left_margin( compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit, ) -> c_double; pub fn gtk_source_print_compositor_get_line_numbers_font_name( compositor: *mut GtkSourcePrintCompositor, ) -> *mut c_char; pub fn gtk_source_print_compositor_get_n_pages( compositor: *mut GtkSourcePrintCompositor, ) -> c_int; pub fn gtk_source_print_compositor_get_pagination_progress( compositor: *mut GtkSourcePrintCompositor, ) -> c_double; pub fn gtk_source_print_compositor_get_print_footer( compositor: *mut GtkSourcePrintCompositor, ) -> gboolean; pub fn gtk_source_print_compositor_get_print_header( compositor: *mut GtkSourcePrintCompositor, ) -> gboolean; pub fn gtk_source_print_compositor_get_print_line_numbers( compositor: *mut GtkSourcePrintCompositor, ) -> c_uint; pub fn gtk_source_print_compositor_get_right_margin( compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit, ) -> c_double; pub fn gtk_source_print_compositor_get_tab_width( compositor: *mut GtkSourcePrintCompositor, ) -> c_uint; pub fn gtk_source_print_compositor_get_top_margin( compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit, ) -> c_double; pub fn gtk_source_print_compositor_get_wrap_mode( compositor: *mut GtkSourcePrintCompositor, ) -> gtk::GtkWrapMode; #[cfg(feature = "v5_2")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_2")))] pub fn gtk_source_print_compositor_ignore_tag( compositor: *mut GtkSourcePrintCompositor, tag: *mut gtk::GtkTextTag, ); pub fn gtk_source_print_compositor_paginate( compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext, ) -> gboolean; pub fn gtk_source_print_compositor_set_body_font_name( compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char, ); pub fn gtk_source_print_compositor_set_bottom_margin( compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit, ); pub fn gtk_source_print_compositor_set_footer_font_name( compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char, ); pub fn gtk_source_print_compositor_set_footer_format( compositor: *mut GtkSourcePrintCompositor, separator: gboolean, left: *const c_char, center: *const c_char, right: *const c_char, ); pub fn gtk_source_print_compositor_set_header_font_name( compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char, ); pub fn gtk_source_print_compositor_set_header_format( compositor: *mut GtkSourcePrintCompositor, separator: gboolean, left: *const c_char, center: *const c_char, right: *const c_char, ); pub fn gtk_source_print_compositor_set_highlight_syntax( compositor: *mut GtkSourcePrintCompositor, highlight: gboolean, ); pub fn gtk_source_print_compositor_set_left_margin( compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit, ); pub fn gtk_source_print_compositor_set_line_numbers_font_name( compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char, ); pub fn gtk_source_print_compositor_set_print_footer( compositor: *mut GtkSourcePrintCompositor, print: gboolean, ); pub fn gtk_source_print_compositor_set_print_header( compositor: *mut GtkSourcePrintCompositor, print: gboolean, ); pub fn gtk_source_print_compositor_set_print_line_numbers( compositor: *mut GtkSourcePrintCompositor, interval: c_uint, ); pub fn gtk_source_print_compositor_set_right_margin( compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit, ); pub fn gtk_source_print_compositor_set_tab_width( compositor: *mut GtkSourcePrintCompositor, width: c_uint, ); pub fn gtk_source_print_compositor_set_top_margin( compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit, ); pub fn gtk_source_print_compositor_set_wrap_mode( compositor: *mut GtkSourcePrintCompositor, wrap_mode: gtk::GtkWrapMode, ); //========================================================================= // GtkSourceRegion //========================================================================= pub fn gtk_source_region_get_type() -> GType; pub fn gtk_source_region_new(buffer: *mut gtk::GtkTextBuffer) -> *mut GtkSourceRegion; pub fn gtk_source_region_add_region( region: *mut GtkSourceRegion, region_to_add: *mut GtkSourceRegion, ); pub fn gtk_source_region_add_subregion( region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter, ); pub fn gtk_source_region_get_bounds( region: *mut GtkSourceRegion, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ) -> gboolean; pub fn gtk_source_region_get_buffer(region: *mut GtkSourceRegion) -> *mut gtk::GtkTextBuffer; pub fn gtk_source_region_get_start_region_iter( region: *mut GtkSourceRegion, iter: *mut GtkSourceRegionIter, ); pub fn gtk_source_region_intersect_region( region1: *mut GtkSourceRegion, region2: *mut GtkSourceRegion, ) -> *mut GtkSourceRegion; pub fn gtk_source_region_intersect_subregion( region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter, ) -> *mut GtkSourceRegion; pub fn gtk_source_region_is_empty(region: *mut GtkSourceRegion) -> gboolean; pub fn gtk_source_region_subtract_region( region: *mut GtkSourceRegion, region_to_subtract: *mut GtkSourceRegion, ); pub fn gtk_source_region_subtract_subregion( region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter, ); pub fn gtk_source_region_to_string(region: *mut GtkSourceRegion) -> *mut c_char; //========================================================================= // GtkSourceSearchContext //========================================================================= pub fn gtk_source_search_context_get_type() -> GType; pub fn gtk_source_search_context_new( buffer: *mut GtkSourceBuffer, settings: *mut GtkSourceSearchSettings, ) -> *mut GtkSourceSearchContext; pub fn gtk_source_search_context_backward( search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, match_start: *mut gtk::GtkTextIter, match_end: *mut gtk::GtkTextIter, has_wrapped_around: *mut gboolean, ) -> gboolean; pub fn gtk_source_search_context_backward_async( search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_search_context_backward_finish( search: *mut GtkSourceSearchContext, result: *mut gio::GAsyncResult, match_start: *mut gtk::GtkTextIter, match_end: *mut gtk::GtkTextIter, has_wrapped_around: *mut gboolean, error: *mut *mut glib::GError, ) -> gboolean; pub fn gtk_source_search_context_forward( search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, match_start: *mut gtk::GtkTextIter, match_end: *mut gtk::GtkTextIter, has_wrapped_around: *mut gboolean, ) -> gboolean; pub fn gtk_source_search_context_forward_async( search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_search_context_forward_finish( search: *mut GtkSourceSearchContext, result: *mut gio::GAsyncResult, match_start: *mut gtk::GtkTextIter, match_end: *mut gtk::GtkTextIter, has_wrapped_around: *mut gboolean, error: *mut *mut glib::GError, ) -> gboolean; pub fn gtk_source_search_context_get_buffer( search: *mut GtkSourceSearchContext, ) -> *mut GtkSourceBuffer; pub fn gtk_source_search_context_get_highlight(search: *mut GtkSourceSearchContext) -> gboolean; pub fn gtk_source_search_context_get_match_style( search: *mut GtkSourceSearchContext, ) -> *mut GtkSourceStyle; pub fn gtk_source_search_context_get_occurrence_position( search: *mut GtkSourceSearchContext, match_start: *const gtk::GtkTextIter, match_end: *const gtk::GtkTextIter, ) -> c_int; pub fn gtk_source_search_context_get_occurrences_count( search: *mut GtkSourceSearchContext, ) -> c_int; pub fn gtk_source_search_context_get_regex_error( search: *mut GtkSourceSearchContext, ) -> *mut glib::GError; pub fn gtk_source_search_context_get_settings( search: *mut GtkSourceSearchContext, ) -> *mut GtkSourceSearchSettings; pub fn gtk_source_search_context_replace( search: *mut GtkSourceSearchContext, match_start: *mut gtk::GtkTextIter, match_end: *mut gtk::GtkTextIter, replace: *const c_char, replace_length: c_int, error: *mut *mut glib::GError, ) -> gboolean; pub fn gtk_source_search_context_replace_all( search: *mut GtkSourceSearchContext, replace: *const c_char, replace_length: c_int, error: *mut *mut glib::GError, ) -> c_uint; pub fn gtk_source_search_context_set_highlight( search: *mut GtkSourceSearchContext, highlight: gboolean, ); pub fn gtk_source_search_context_set_match_style( search: *mut GtkSourceSearchContext, match_style: *mut GtkSourceStyle, ); //========================================================================= // GtkSourceSearchSettings //========================================================================= pub fn gtk_source_search_settings_get_type() -> GType; pub fn gtk_source_search_settings_new() -> *mut GtkSourceSearchSettings; pub fn gtk_source_search_settings_get_at_word_boundaries( settings: *mut GtkSourceSearchSettings, ) -> gboolean; pub fn gtk_source_search_settings_get_case_sensitive( settings: *mut GtkSourceSearchSettings, ) -> gboolean; pub fn gtk_source_search_settings_get_regex_enabled( settings: *mut GtkSourceSearchSettings, ) -> gboolean; pub fn gtk_source_search_settings_get_search_text( settings: *mut GtkSourceSearchSettings, ) -> *const c_char; #[cfg(feature = "v5_12")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_12")))] pub fn gtk_source_search_settings_get_visible_only( settings: *mut GtkSourceSearchSettings, ) -> gboolean; pub fn gtk_source_search_settings_get_wrap_around( settings: *mut GtkSourceSearchSettings, ) -> gboolean; pub fn gtk_source_search_settings_set_at_word_boundaries( settings: *mut GtkSourceSearchSettings, at_word_boundaries: gboolean, ); pub fn gtk_source_search_settings_set_case_sensitive( settings: *mut GtkSourceSearchSettings, case_sensitive: gboolean, ); pub fn gtk_source_search_settings_set_regex_enabled( settings: *mut GtkSourceSearchSettings, regex_enabled: gboolean, ); pub fn gtk_source_search_settings_set_search_text( settings: *mut GtkSourceSearchSettings, search_text: *const c_char, ); #[cfg(feature = "v5_12")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_12")))] pub fn gtk_source_search_settings_set_visible_only( settings: *mut GtkSourceSearchSettings, visible_only: gboolean, ); pub fn gtk_source_search_settings_set_wrap_around( settings: *mut GtkSourceSearchSettings, wrap_around: gboolean, ); //========================================================================= // GtkSourceSnippet //========================================================================= pub fn gtk_source_snippet_get_type() -> GType; pub fn gtk_source_snippet_new( trigger: *const c_char, language_id: *const c_char, ) -> *mut GtkSourceSnippet; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_snippet_new_parsed( text: *const c_char, error: *mut *mut glib::GError, ) -> *mut GtkSourceSnippet; pub fn gtk_source_snippet_add_chunk( snippet: *mut GtkSourceSnippet, chunk: *mut GtkSourceSnippetChunk, ); pub fn gtk_source_snippet_copy(snippet: *mut GtkSourceSnippet) -> *mut GtkSourceSnippet; pub fn gtk_source_snippet_get_context( snippet: *mut GtkSourceSnippet, ) -> *mut GtkSourceSnippetContext; pub fn gtk_source_snippet_get_description(snippet: *mut GtkSourceSnippet) -> *const c_char; pub fn gtk_source_snippet_get_focus_position(snippet: *mut GtkSourceSnippet) -> c_int; pub fn gtk_source_snippet_get_language_id(snippet: *mut GtkSourceSnippet) -> *const c_char; pub fn gtk_source_snippet_get_n_chunks(snippet: *mut GtkSourceSnippet) -> c_uint; pub fn gtk_source_snippet_get_name(snippet: *mut GtkSourceSnippet) -> *const c_char; pub fn gtk_source_snippet_get_nth_chunk( snippet: *mut GtkSourceSnippet, nth: c_uint, ) -> *mut GtkSourceSnippetChunk; pub fn gtk_source_snippet_get_trigger(snippet: *mut GtkSourceSnippet) -> *const c_char; pub fn gtk_source_snippet_set_description( snippet: *mut GtkSourceSnippet, description: *const c_char, ); pub fn gtk_source_snippet_set_language_id( snippet: *mut GtkSourceSnippet, language_id: *const c_char, ); pub fn gtk_source_snippet_set_name(snippet: *mut GtkSourceSnippet, name: *const c_char); pub fn gtk_source_snippet_set_trigger(snippet: *mut GtkSourceSnippet, trigger: *const c_char); //========================================================================= // GtkSourceSnippetChunk //========================================================================= pub fn gtk_source_snippet_chunk_get_type() -> GType; pub fn gtk_source_snippet_chunk_new() -> *mut GtkSourceSnippetChunk; pub fn gtk_source_snippet_chunk_copy( chunk: *mut GtkSourceSnippetChunk, ) -> *mut GtkSourceSnippetChunk; pub fn gtk_source_snippet_chunk_get_context( chunk: *mut GtkSourceSnippetChunk, ) -> *mut GtkSourceSnippetContext; pub fn gtk_source_snippet_chunk_get_focus_position(chunk: *mut GtkSourceSnippetChunk) -> c_int; pub fn gtk_source_snippet_chunk_get_spec(chunk: *mut GtkSourceSnippetChunk) -> *const c_char; pub fn gtk_source_snippet_chunk_get_text(chunk: *mut GtkSourceSnippetChunk) -> *const c_char; pub fn gtk_source_snippet_chunk_get_text_set(chunk: *mut GtkSourceSnippetChunk) -> gboolean; pub fn gtk_source_snippet_chunk_get_tooltip_text( chunk: *mut GtkSourceSnippetChunk, ) -> *const c_char; pub fn gtk_source_snippet_chunk_set_context( chunk: *mut GtkSourceSnippetChunk, context: *mut GtkSourceSnippetContext, ); pub fn gtk_source_snippet_chunk_set_focus_position( chunk: *mut GtkSourceSnippetChunk, focus_position: c_int, ); pub fn gtk_source_snippet_chunk_set_spec( chunk: *mut GtkSourceSnippetChunk, spec: *const c_char, ); pub fn gtk_source_snippet_chunk_set_text( chunk: *mut GtkSourceSnippetChunk, text: *const c_char, ); pub fn gtk_source_snippet_chunk_set_text_set( chunk: *mut GtkSourceSnippetChunk, text_set: gboolean, ); pub fn gtk_source_snippet_chunk_set_tooltip_text( chunk: *mut GtkSourceSnippetChunk, tooltip_text: *const c_char, ); //========================================================================= // GtkSourceSnippetContext //========================================================================= pub fn gtk_source_snippet_context_get_type() -> GType; pub fn gtk_source_snippet_context_new() -> *mut GtkSourceSnippetContext; pub fn gtk_source_snippet_context_clear_variables(self_: *mut GtkSourceSnippetContext); pub fn gtk_source_snippet_context_expand( self_: *mut GtkSourceSnippetContext, input: *const c_char, ) -> *mut c_char; pub fn gtk_source_snippet_context_get_variable( self_: *mut GtkSourceSnippetContext, key: *const c_char, ) -> *const c_char; pub fn gtk_source_snippet_context_set_constant( self_: *mut GtkSourceSnippetContext, key: *const c_char, value: *const c_char, ); pub fn gtk_source_snippet_context_set_line_prefix( self_: *mut GtkSourceSnippetContext, line_prefix: *const c_char, ); pub fn gtk_source_snippet_context_set_tab_width( self_: *mut GtkSourceSnippetContext, tab_width: c_int, ); pub fn gtk_source_snippet_context_set_use_spaces( self_: *mut GtkSourceSnippetContext, use_spaces: gboolean, ); pub fn gtk_source_snippet_context_set_variable( self_: *mut GtkSourceSnippetContext, key: *const c_char, value: *const c_char, ); //========================================================================= // GtkSourceSnippetManager //========================================================================= pub fn gtk_source_snippet_manager_get_type() -> GType; pub fn gtk_source_snippet_manager_get_default() -> *mut GtkSourceSnippetManager; pub fn gtk_source_snippet_manager_get_search_path( self_: *mut GtkSourceSnippetManager, ) -> *const *const c_char; pub fn gtk_source_snippet_manager_get_snippet( self_: *mut GtkSourceSnippetManager, group: *const c_char, language_id: *const c_char, trigger: *const c_char, ) -> *mut GtkSourceSnippet; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_snippet_manager_list_all( self_: *mut GtkSourceSnippetManager, ) -> *mut gio::GListModel; pub fn gtk_source_snippet_manager_list_groups( self_: *mut GtkSourceSnippetManager, ) -> *mut *const c_char; pub fn gtk_source_snippet_manager_list_matching( self_: *mut GtkSourceSnippetManager, group: *const c_char, language_id: *const c_char, trigger_prefix: *const c_char, ) -> *mut gio::GListModel; pub fn gtk_source_snippet_manager_set_search_path( self_: *mut GtkSourceSnippetManager, dirs: *const *const c_char, ); //========================================================================= // GtkSourceSpaceDrawer //========================================================================= pub fn gtk_source_space_drawer_get_type() -> GType; pub fn gtk_source_space_drawer_new() -> *mut GtkSourceSpaceDrawer; pub fn gtk_source_space_drawer_bind_matrix_setting( drawer: *mut GtkSourceSpaceDrawer, settings: *mut gio::GSettings, key: *const c_char, flags: gio::GSettingsBindFlags, ); pub fn gtk_source_space_drawer_get_enable_matrix(drawer: *mut GtkSourceSpaceDrawer) -> gboolean; pub fn gtk_source_space_drawer_get_matrix( drawer: *mut GtkSourceSpaceDrawer, ) -> *mut glib::GVariant; pub fn gtk_source_space_drawer_get_types_for_locations( drawer: *mut GtkSourceSpaceDrawer, locations: GtkSourceSpaceLocationFlags, ) -> GtkSourceSpaceTypeFlags; pub fn gtk_source_space_drawer_set_enable_matrix( drawer: *mut GtkSourceSpaceDrawer, enable_matrix: gboolean, ); pub fn gtk_source_space_drawer_set_matrix( drawer: *mut GtkSourceSpaceDrawer, matrix: *mut glib::GVariant, ); pub fn gtk_source_space_drawer_set_types_for_locations( drawer: *mut GtkSourceSpaceDrawer, locations: GtkSourceSpaceLocationFlags, types: GtkSourceSpaceTypeFlags, ); //========================================================================= // GtkSourceStyle //========================================================================= pub fn gtk_source_style_get_type() -> GType; pub fn gtk_source_style_apply(style: *const GtkSourceStyle, tag: *mut gtk::GtkTextTag); pub fn gtk_source_style_copy(style: *const GtkSourceStyle) -> *mut GtkSourceStyle; //========================================================================= // GtkSourceStyleScheme //========================================================================= pub fn gtk_source_style_scheme_get_type() -> GType; pub fn gtk_source_style_scheme_get_authors( scheme: *mut GtkSourceStyleScheme, ) -> *const *const c_char; pub fn gtk_source_style_scheme_get_description( scheme: *mut GtkSourceStyleScheme, ) -> *const c_char; pub fn gtk_source_style_scheme_get_filename(scheme: *mut GtkSourceStyleScheme) -> *const c_char; pub fn gtk_source_style_scheme_get_id(scheme: *mut GtkSourceStyleScheme) -> *const c_char; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_get_metadata( scheme: *mut GtkSourceStyleScheme, name: *const c_char, ) -> *const c_char; pub fn gtk_source_style_scheme_get_name(scheme: *mut GtkSourceStyleScheme) -> *const c_char; pub fn gtk_source_style_scheme_get_style( scheme: *mut GtkSourceStyleScheme, style_id: *const c_char, ) -> *mut GtkSourceStyle; //========================================================================= // GtkSourceStyleSchemeChooserButton //========================================================================= pub fn gtk_source_style_scheme_chooser_button_get_type() -> GType; pub fn gtk_source_style_scheme_chooser_button_new() -> *mut gtk::GtkWidget; //========================================================================= // GtkSourceStyleSchemeChooserWidget //========================================================================= pub fn gtk_source_style_scheme_chooser_widget_get_type() -> GType; pub fn gtk_source_style_scheme_chooser_widget_new() -> *mut gtk::GtkWidget; //========================================================================= // GtkSourceStyleSchemeManager //========================================================================= pub fn gtk_source_style_scheme_manager_get_type() -> GType; pub fn gtk_source_style_scheme_manager_new() -> *mut GtkSourceStyleSchemeManager; pub fn gtk_source_style_scheme_manager_get_default() -> *mut GtkSourceStyleSchemeManager; pub fn gtk_source_style_scheme_manager_append_search_path( manager: *mut GtkSourceStyleSchemeManager, path: *const c_char, ); pub fn gtk_source_style_scheme_manager_force_rescan(manager: *mut GtkSourceStyleSchemeManager); pub fn gtk_source_style_scheme_manager_get_scheme( manager: *mut GtkSourceStyleSchemeManager, scheme_id: *const c_char, ) -> *mut GtkSourceStyleScheme; pub fn gtk_source_style_scheme_manager_get_scheme_ids( manager: *mut GtkSourceStyleSchemeManager, ) -> *const *const c_char; pub fn gtk_source_style_scheme_manager_get_search_path( manager: *mut GtkSourceStyleSchemeManager, ) -> *const *const c_char; pub fn gtk_source_style_scheme_manager_prepend_search_path( manager: *mut GtkSourceStyleSchemeManager, path: *const c_char, ); pub fn gtk_source_style_scheme_manager_set_search_path( manager: *mut GtkSourceStyleSchemeManager, path: *const *const c_char, ); //========================================================================= // GtkSourceStyleSchemePreview //========================================================================= #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_preview_get_type() -> GType; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_preview_new( scheme: *mut GtkSourceStyleScheme, ) -> *mut gtk::GtkWidget; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_preview_get_scheme( self_: *mut GtkSourceStyleSchemePreview, ) -> *mut GtkSourceStyleScheme; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_preview_get_selected( self_: *mut GtkSourceStyleSchemePreview, ) -> gboolean; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_style_scheme_preview_set_selected( self_: *mut GtkSourceStyleSchemePreview, selected: gboolean, ); //========================================================================= // GtkSourceTag //========================================================================= pub fn gtk_source_tag_get_type() -> GType; pub fn gtk_source_tag_new(name: *const c_char) -> *mut gtk::GtkTextTag; //========================================================================= // GtkSourceView //========================================================================= pub fn gtk_source_view_get_type() -> GType; pub fn gtk_source_view_new() -> *mut gtk::GtkWidget; pub fn gtk_source_view_new_with_buffer(buffer: *mut GtkSourceBuffer) -> *mut gtk::GtkWidget; pub fn gtk_source_view_get_auto_indent(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_background_pattern( view: *mut GtkSourceView, ) -> GtkSourceBackgroundPatternType; pub fn gtk_source_view_get_completion(view: *mut GtkSourceView) -> *mut GtkSourceCompletion; pub fn gtk_source_view_get_enable_snippets(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_gutter( view: *mut GtkSourceView, window_type: gtk::GtkTextWindowType, ) -> *mut GtkSourceGutter; pub fn gtk_source_view_get_highlight_current_line(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_hover(view: *mut GtkSourceView) -> *mut GtkSourceHover; pub fn gtk_source_view_get_indent_on_tab(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_indent_width(view: *mut GtkSourceView) -> c_int; pub fn gtk_source_view_get_indenter(view: *mut GtkSourceView) -> *mut GtkSourceIndenter; pub fn gtk_source_view_get_insert_spaces_instead_of_tabs(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_mark_attributes( view: *mut GtkSourceView, category: *const c_char, priority: *mut c_int, ) -> *mut GtkSourceMarkAttributes; pub fn gtk_source_view_get_right_margin_position(view: *mut GtkSourceView) -> c_uint; pub fn gtk_source_view_get_show_line_marks(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_show_line_numbers(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_show_right_margin(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_smart_backspace(view: *mut GtkSourceView) -> gboolean; pub fn gtk_source_view_get_smart_home_end( view: *mut GtkSourceView, ) -> GtkSourceSmartHomeEndType; pub fn gtk_source_view_get_space_drawer(view: *mut GtkSourceView) -> *mut GtkSourceSpaceDrawer; pub fn gtk_source_view_get_tab_width(view: *mut GtkSourceView) -> c_uint; pub fn gtk_source_view_get_visual_column( view: *mut GtkSourceView, iter: *const gtk::GtkTextIter, ) -> c_uint; pub fn gtk_source_view_indent_lines( view: *mut GtkSourceView, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ); pub fn gtk_source_view_push_snippet( view: *mut GtkSourceView, snippet: *mut GtkSourceSnippet, location: *mut gtk::GtkTextIter, ); pub fn gtk_source_view_set_auto_indent(view: *mut GtkSourceView, enable: gboolean); pub fn gtk_source_view_set_background_pattern( view: *mut GtkSourceView, background_pattern: GtkSourceBackgroundPatternType, ); pub fn gtk_source_view_set_enable_snippets(view: *mut GtkSourceView, enable_snippets: gboolean); pub fn gtk_source_view_set_highlight_current_line( view: *mut GtkSourceView, highlight: gboolean, ); pub fn gtk_source_view_set_indent_on_tab(view: *mut GtkSourceView, enable: gboolean); pub fn gtk_source_view_set_indent_width(view: *mut GtkSourceView, width: c_int); pub fn gtk_source_view_set_indenter(view: *mut GtkSourceView, indenter: *mut GtkSourceIndenter); pub fn gtk_source_view_set_insert_spaces_instead_of_tabs( view: *mut GtkSourceView, enable: gboolean, ); pub fn gtk_source_view_set_mark_attributes( view: *mut GtkSourceView, category: *const c_char, attributes: *mut GtkSourceMarkAttributes, priority: c_int, ); pub fn gtk_source_view_set_right_margin_position(view: *mut GtkSourceView, pos: c_uint); pub fn gtk_source_view_set_show_line_marks(view: *mut GtkSourceView, show: gboolean); pub fn gtk_source_view_set_show_line_numbers(view: *mut GtkSourceView, show: gboolean); pub fn gtk_source_view_set_show_right_margin(view: *mut GtkSourceView, show: gboolean); pub fn gtk_source_view_set_smart_backspace(view: *mut GtkSourceView, smart_backspace: gboolean); pub fn gtk_source_view_set_smart_home_end( view: *mut GtkSourceView, smart_home_end: GtkSourceSmartHomeEndType, ); pub fn gtk_source_view_set_tab_width(view: *mut GtkSourceView, width: c_uint); pub fn gtk_source_view_unindent_lines( view: *mut GtkSourceView, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, ); //========================================================================= // GtkSourceVimIMContext //========================================================================= #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_vim_im_context_get_type() -> GType; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_vim_im_context_new() -> *mut gtk::GtkIMContext; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_vim_im_context_execute_command( self_: *mut GtkSourceVimIMContext, command: *const c_char, ); #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_vim_im_context_get_command_bar_text( self_: *mut GtkSourceVimIMContext, ) -> *const c_char; #[cfg(feature = "v5_4")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_4")))] pub fn gtk_source_vim_im_context_get_command_text( self_: *mut GtkSourceVimIMContext, ) -> *const c_char; //========================================================================= // GtkSourceCompletionProposal //========================================================================= pub fn gtk_source_completion_proposal_get_type() -> GType; #[cfg(feature = "v5_6")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_6")))] pub fn gtk_source_completion_proposal_get_typed_text( proposal: *mut GtkSourceCompletionProposal, ) -> *mut c_char; //========================================================================= // GtkSourceCompletionProvider //========================================================================= pub fn gtk_source_completion_provider_get_type() -> GType; pub fn gtk_source_completion_provider_activate( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, proposal: *mut GtkSourceCompletionProposal, ); pub fn gtk_source_completion_provider_display( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, proposal: *mut GtkSourceCompletionProposal, cell: *mut GtkSourceCompletionCell, ); pub fn gtk_source_completion_provider_get_priority( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, ) -> c_int; pub fn gtk_source_completion_provider_get_title( self_: *mut GtkSourceCompletionProvider, ) -> *mut c_char; pub fn gtk_source_completion_provider_is_trigger( self_: *mut GtkSourceCompletionProvider, iter: *const gtk::GtkTextIter, ch: u32, ) -> gboolean; pub fn gtk_source_completion_provider_key_activates( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, proposal: *mut GtkSourceCompletionProposal, keyval: c_uint, state: gdk::GdkModifierType, ) -> gboolean; pub fn gtk_source_completion_provider_list_alternates( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, proposal: *mut GtkSourceCompletionProposal, ) -> *mut glib::GPtrArray; pub fn gtk_source_completion_provider_populate_async( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_completion_provider_populate_finish( self_: *mut GtkSourceCompletionProvider, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError, ) -> *mut gio::GListModel; pub fn gtk_source_completion_provider_refilter( self_: *mut GtkSourceCompletionProvider, context: *mut GtkSourceCompletionContext, model: *mut gio::GListModel, ); //========================================================================= // GtkSourceHoverProvider //========================================================================= pub fn gtk_source_hover_provider_get_type() -> GType; pub fn gtk_source_hover_provider_populate_async( self_: *mut GtkSourceHoverProvider, context: *mut GtkSourceHoverContext, display: *mut GtkSourceHoverDisplay, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer, ); pub fn gtk_source_hover_provider_populate_finish( self_: *mut GtkSourceHoverProvider, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError, ) -> gboolean; //========================================================================= // GtkSourceIndenter //========================================================================= pub fn gtk_source_indenter_get_type() -> GType; pub fn gtk_source_indenter_indent( self_: *mut GtkSourceIndenter, view: *mut GtkSourceView, iter: *mut gtk::GtkTextIter, ); pub fn gtk_source_indenter_is_trigger( self_: *mut GtkSourceIndenter, view: *mut GtkSourceView, location: *const gtk::GtkTextIter, state: gdk::GdkModifierType, keyval: c_uint, ) -> gboolean; //========================================================================= // GtkSourceStyleSchemeChooser //========================================================================= pub fn gtk_source_style_scheme_chooser_get_type() -> GType; pub fn gtk_source_style_scheme_chooser_get_style_scheme( chooser: *mut GtkSourceStyleSchemeChooser, ) -> *mut GtkSourceStyleScheme; pub fn gtk_source_style_scheme_chooser_set_style_scheme( chooser: *mut GtkSourceStyleSchemeChooser, scheme: *mut GtkSourceStyleScheme, ); //========================================================================= // Other functions //========================================================================= pub fn gtk_source_check_version(major: c_uint, minor: c_uint, micro: c_uint) -> gboolean; pub fn gtk_source_finalize(); pub fn gtk_source_get_major_version() -> c_uint; pub fn gtk_source_get_micro_version() -> c_uint; pub fn gtk_source_get_minor_version() -> c_uint; pub fn gtk_source_init(); #[cfg(feature = "v5_2")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_2")))] pub fn gtk_source_scheduler_add( callback: GtkSourceSchedulerCallback, user_data: gpointer, ) -> size_t; #[cfg(feature = "v5_2")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_2")))] pub fn gtk_source_scheduler_add_full( callback: GtkSourceSchedulerCallback, user_data: gpointer, notify: glib::GDestroyNotify, ) -> size_t; #[cfg(feature = "v5_2")] #[cfg_attr(docsrs, doc(cfg(feature = "v5_2")))] pub fn gtk_source_scheduler_remove(handler_id: size_t); pub fn gtk_source_utils_escape_search_text(text: *const c_char) -> *mut c_char; pub fn gtk_source_utils_unescape_search_text(text: *const c_char) -> *mut c_char; } sourceview5-sys-0.9.0/tests/abi.rs000064400000000000000000000613741046102023000152040ustar 00000000000000// Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) // from // from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70) // DO NOT EDIT #![cfg(unix)] use sourceview5_sys::*; use std::env; use std::error::Error; use std::ffi::OsString; use std::mem::{align_of, size_of}; use std::path::Path; use std::process::{Command, Stdio}; use std::str; use tempfile::Builder; static PACKAGES: &[&str] = &["gtksourceview-5"]; #[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)] = &[ ( "GtkSourceBackgroundPatternType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceBracketMatchType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceBuffer", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceBufferClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceChangeCaseType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionActivation", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionCellClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionColumn", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionContextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionProposalInterface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionProviderInterface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionSnippets", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionSnippetsClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionWords", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompletionWordsClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceCompressionType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFile", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileLoaderClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileLoaderError", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileSaverClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileSaverError", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceFileSaverFlags", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterLinesClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRenderer", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererAlignmentMode", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererPixbuf", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererPixbufClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererText", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceGutterRendererTextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceHoverClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceHoverContextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceHoverDisplayClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceHoverProviderInterface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceIndenterInterface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceLanguageClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceLanguageManagerClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceMap", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceMapClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceMark", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceMarkAttributesClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceMarkClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceNewlineType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourcePrintCompositor", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourcePrintCompositorClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceRegion", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceRegionClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceRegionIter", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSearchContextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSearchSettings", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSearchSettingsClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSmartHomeEndType", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSnippetChunkClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSnippetClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSnippetContextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSnippetManagerClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSortFlags", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSpaceDrawerClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSpaceLocationFlags", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceSpaceTypeFlags", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeChooserButton", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeChooserButtonClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeChooserInterface", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeChooserWidget", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeChooserWidgetClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemeManagerClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceStyleSchemePreviewClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceTag", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceTagClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceView", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceViewClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceViewGutterPosition", Layout { size: size_of::(), alignment: align_of::(), }, ), ( "GtkSourceVimIMContextClass", Layout { size: size_of::(), alignment: align_of::(), }, ), ]; const RUST_CONSTANTS: &[(&str, &str)] = &[ ("(gint) GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID", "1"), ("(gint) GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE", "0"), ("(gint) GTK_SOURCE_BRACKET_MATCH_FOUND", "3"), ("(gint) GTK_SOURCE_BRACKET_MATCH_NONE", "0"), ("(gint) GTK_SOURCE_BRACKET_MATCH_NOT_FOUND", "2"), ("(gint) GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE", "1"), ("(gint) GTK_SOURCE_CHANGE_CASE_LOWER", "0"), ("(gint) GTK_SOURCE_CHANGE_CASE_TITLE", "3"), ("(gint) GTK_SOURCE_CHANGE_CASE_TOGGLE", "2"), ("(gint) GTK_SOURCE_CHANGE_CASE_UPPER", "1"), ("(gint) GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE", "1"), ("(gint) GTK_SOURCE_COMPLETION_ACTIVATION_NONE", "0"), ( "(gint) GTK_SOURCE_COMPLETION_ACTIVATION_USER_REQUESTED", "2", ), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_AFTER", "3"), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_BEFORE", "1"), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_COMMENT", "4"), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_DETAILS", "5"), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_ICON", "0"), ("(gint) GTK_SOURCE_COMPLETION_COLUMN_TYPED_TEXT", "2"), ("(gint) GTK_SOURCE_COMPRESSION_TYPE_GZIP", "1"), ("(gint) GTK_SOURCE_COMPRESSION_TYPE_NONE", "0"), ( "(gint) GTK_SOURCE_FILE_LOADER_ERROR_CONVERSION_FALLBACK", "2", ), ( "(gint) GTK_SOURCE_FILE_LOADER_ERROR_ENCODING_AUTO_DETECTION_FAILED", "1", ), ("(gint) GTK_SOURCE_FILE_LOADER_ERROR_TOO_BIG", "0"), ( "(gint) GTK_SOURCE_FILE_SAVER_ERROR_EXTERNALLY_MODIFIED", "1", ), ("(gint) GTK_SOURCE_FILE_SAVER_ERROR_INVALID_CHARS", "0"), ("(guint) GTK_SOURCE_FILE_SAVER_FLAGS_CREATE_BACKUP", "4"), ( "(guint) GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_INVALID_CHARS", "1", ), ( "(guint) GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_MODIFICATION_TIME", "2", ), ("(guint) GTK_SOURCE_FILE_SAVER_FLAGS_NONE", "0"), ("(gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL", "0"), ( "(gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST", "1", ), ("(gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST", "2"), ("(gint) GTK_SOURCE_NEWLINE_TYPE_CR", "1"), ("(gint) GTK_SOURCE_NEWLINE_TYPE_CR_LF", "2"), ("(gint) GTK_SOURCE_NEWLINE_TYPE_LF", "0"), ("(gint) GTK_SOURCE_SMART_HOME_END_AFTER", "2"), ("(gint) GTK_SOURCE_SMART_HOME_END_ALWAYS", "3"), ("(gint) GTK_SOURCE_SMART_HOME_END_BEFORE", "1"), ("(gint) GTK_SOURCE_SMART_HOME_END_DISABLED", "0"), ("(guint) GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE", "1"), ("(guint) GTK_SOURCE_SORT_FLAGS_NONE", "0"), ("(guint) GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES", "4"), ("(guint) GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER", "2"), ("(guint) GTK_SOURCE_SPACE_LOCATION_ALL", "7"), ("(guint) GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT", "2"), ("(guint) GTK_SOURCE_SPACE_LOCATION_LEADING", "1"), ("(guint) GTK_SOURCE_SPACE_LOCATION_NONE", "0"), ("(guint) GTK_SOURCE_SPACE_LOCATION_TRAILING", "4"), ("(guint) GTK_SOURCE_SPACE_TYPE_ALL", "15"), ("(guint) GTK_SOURCE_SPACE_TYPE_NBSP", "8"), ("(guint) GTK_SOURCE_SPACE_TYPE_NEWLINE", "4"), ("(guint) GTK_SOURCE_SPACE_TYPE_NONE", "0"), ("(guint) GTK_SOURCE_SPACE_TYPE_SPACE", "1"), ("(guint) GTK_SOURCE_SPACE_TYPE_TAB", "2"), ("(gint) GTK_SOURCE_VIEW_GUTTER_POSITION_LINES", "-30"), ("(gint) GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS", "-20"), ]; sourceview5-sys-0.9.0/tests/constant.c000064400000000000000000000111721046102023000160670ustar 00000000000000// Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) // from // from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70) // 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_SOURCE_BACKGROUND_PATTERN_TYPE_GRID); PRINT_CONSTANT((gint) GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE); PRINT_CONSTANT((gint) GTK_SOURCE_BRACKET_MATCH_FOUND); PRINT_CONSTANT((gint) GTK_SOURCE_BRACKET_MATCH_NONE); PRINT_CONSTANT((gint) GTK_SOURCE_BRACKET_MATCH_NOT_FOUND); PRINT_CONSTANT((gint) GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE); PRINT_CONSTANT((gint) GTK_SOURCE_CHANGE_CASE_LOWER); PRINT_CONSTANT((gint) GTK_SOURCE_CHANGE_CASE_TITLE); PRINT_CONSTANT((gint) GTK_SOURCE_CHANGE_CASE_TOGGLE); PRINT_CONSTANT((gint) GTK_SOURCE_CHANGE_CASE_UPPER); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_ACTIVATION_NONE); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_ACTIVATION_USER_REQUESTED); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_AFTER); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_BEFORE); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_COMMENT); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_DETAILS); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_ICON); PRINT_CONSTANT((gint) GTK_SOURCE_COMPLETION_COLUMN_TYPED_TEXT); PRINT_CONSTANT((gint) GTK_SOURCE_COMPRESSION_TYPE_GZIP); PRINT_CONSTANT((gint) GTK_SOURCE_COMPRESSION_TYPE_NONE); PRINT_CONSTANT((gint) GTK_SOURCE_FILE_LOADER_ERROR_CONVERSION_FALLBACK); PRINT_CONSTANT((gint) GTK_SOURCE_FILE_LOADER_ERROR_ENCODING_AUTO_DETECTION_FAILED); PRINT_CONSTANT((gint) GTK_SOURCE_FILE_LOADER_ERROR_TOO_BIG); PRINT_CONSTANT((gint) GTK_SOURCE_FILE_SAVER_ERROR_EXTERNALLY_MODIFIED); PRINT_CONSTANT((gint) GTK_SOURCE_FILE_SAVER_ERROR_INVALID_CHARS); PRINT_CONSTANT((guint) GTK_SOURCE_FILE_SAVER_FLAGS_CREATE_BACKUP); PRINT_CONSTANT((guint) GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_INVALID_CHARS); PRINT_CONSTANT((guint) GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_MODIFICATION_TIME); PRINT_CONSTANT((guint) GTK_SOURCE_FILE_SAVER_FLAGS_NONE); PRINT_CONSTANT((gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL); PRINT_CONSTANT((gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST); PRINT_CONSTANT((gint) GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST); PRINT_CONSTANT((gint) GTK_SOURCE_NEWLINE_TYPE_CR); PRINT_CONSTANT((gint) GTK_SOURCE_NEWLINE_TYPE_CR_LF); PRINT_CONSTANT((gint) GTK_SOURCE_NEWLINE_TYPE_LF); PRINT_CONSTANT((gint) GTK_SOURCE_SMART_HOME_END_AFTER); PRINT_CONSTANT((gint) GTK_SOURCE_SMART_HOME_END_ALWAYS); PRINT_CONSTANT((gint) GTK_SOURCE_SMART_HOME_END_BEFORE); PRINT_CONSTANT((gint) GTK_SOURCE_SMART_HOME_END_DISABLED); PRINT_CONSTANT((guint) GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE); PRINT_CONSTANT((guint) GTK_SOURCE_SORT_FLAGS_NONE); PRINT_CONSTANT((guint) GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES); PRINT_CONSTANT((guint) GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_LOCATION_ALL); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_LOCATION_LEADING); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_LOCATION_NONE); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_LOCATION_TRAILING); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_ALL); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_NBSP); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_NEWLINE); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_NONE); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_SPACE); PRINT_CONSTANT((guint) GTK_SOURCE_SPACE_TYPE_TAB); PRINT_CONSTANT((gint) GTK_SOURCE_VIEW_GUTTER_POSITION_LINES); PRINT_CONSTANT((gint) GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS); return 0; } sourceview5-sys-0.9.0/tests/layout.c000064400000000000000000000240101046102023000155460ustar 00000000000000// Generated by gir (https://github.com/gtk-rs/gir @ d7c0763cacbc) // from // from gir-files (https://github.com/gtk-rs/gir-files.git @ 4d1189172a70) // DO NOT EDIT #include "manual.h" #include #include int main() { printf("%s;%zu;%zu\n", "GtkSourceBackgroundPatternType", sizeof(GtkSourceBackgroundPatternType), alignof(GtkSourceBackgroundPatternType)); printf("%s;%zu;%zu\n", "GtkSourceBracketMatchType", sizeof(GtkSourceBracketMatchType), alignof(GtkSourceBracketMatchType)); printf("%s;%zu;%zu\n", "GtkSourceBuffer", sizeof(GtkSourceBuffer), alignof(GtkSourceBuffer)); printf("%s;%zu;%zu\n", "GtkSourceBufferClass", sizeof(GtkSourceBufferClass), alignof(GtkSourceBufferClass)); printf("%s;%zu;%zu\n", "GtkSourceChangeCaseType", sizeof(GtkSourceChangeCaseType), alignof(GtkSourceChangeCaseType)); printf("%s;%zu;%zu\n", "GtkSourceCompletionActivation", sizeof(GtkSourceCompletionActivation), alignof(GtkSourceCompletionActivation)); printf("%s;%zu;%zu\n", "GtkSourceCompletionCellClass", sizeof(GtkSourceCompletionCellClass), alignof(GtkSourceCompletionCellClass)); printf("%s;%zu;%zu\n", "GtkSourceCompletionClass", sizeof(GtkSourceCompletionClass), alignof(GtkSourceCompletionClass)); printf("%s;%zu;%zu\n", "GtkSourceCompletionColumn", sizeof(GtkSourceCompletionColumn), alignof(GtkSourceCompletionColumn)); printf("%s;%zu;%zu\n", "GtkSourceCompletionContextClass", sizeof(GtkSourceCompletionContextClass), alignof(GtkSourceCompletionContextClass)); printf("%s;%zu;%zu\n", "GtkSourceCompletionProposalInterface", sizeof(GtkSourceCompletionProposalInterface), alignof(GtkSourceCompletionProposalInterface)); printf("%s;%zu;%zu\n", "GtkSourceCompletionProviderInterface", sizeof(GtkSourceCompletionProviderInterface), alignof(GtkSourceCompletionProviderInterface)); printf("%s;%zu;%zu\n", "GtkSourceCompletionSnippets", sizeof(GtkSourceCompletionSnippets), alignof(GtkSourceCompletionSnippets)); printf("%s;%zu;%zu\n", "GtkSourceCompletionSnippetsClass", sizeof(GtkSourceCompletionSnippetsClass), alignof(GtkSourceCompletionSnippetsClass)); printf("%s;%zu;%zu\n", "GtkSourceCompletionWords", sizeof(GtkSourceCompletionWords), alignof(GtkSourceCompletionWords)); printf("%s;%zu;%zu\n", "GtkSourceCompletionWordsClass", sizeof(GtkSourceCompletionWordsClass), alignof(GtkSourceCompletionWordsClass)); printf("%s;%zu;%zu\n", "GtkSourceCompressionType", sizeof(GtkSourceCompressionType), alignof(GtkSourceCompressionType)); printf("%s;%zu;%zu\n", "GtkSourceFile", sizeof(GtkSourceFile), alignof(GtkSourceFile)); printf("%s;%zu;%zu\n", "GtkSourceFileClass", sizeof(GtkSourceFileClass), alignof(GtkSourceFileClass)); printf("%s;%zu;%zu\n", "GtkSourceFileLoaderClass", sizeof(GtkSourceFileLoaderClass), alignof(GtkSourceFileLoaderClass)); printf("%s;%zu;%zu\n", "GtkSourceFileLoaderError", sizeof(GtkSourceFileLoaderError), alignof(GtkSourceFileLoaderError)); printf("%s;%zu;%zu\n", "GtkSourceFileSaverClass", sizeof(GtkSourceFileSaverClass), alignof(GtkSourceFileSaverClass)); printf("%s;%zu;%zu\n", "GtkSourceFileSaverError", sizeof(GtkSourceFileSaverError), alignof(GtkSourceFileSaverError)); printf("%s;%zu;%zu\n", "GtkSourceFileSaverFlags", sizeof(GtkSourceFileSaverFlags), alignof(GtkSourceFileSaverFlags)); printf("%s;%zu;%zu\n", "GtkSourceGutterClass", sizeof(GtkSourceGutterClass), alignof(GtkSourceGutterClass)); printf("%s;%zu;%zu\n", "GtkSourceGutterLinesClass", sizeof(GtkSourceGutterLinesClass), alignof(GtkSourceGutterLinesClass)); printf("%s;%zu;%zu\n", "GtkSourceGutterRenderer", sizeof(GtkSourceGutterRenderer), alignof(GtkSourceGutterRenderer)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererAlignmentMode", sizeof(GtkSourceGutterRendererAlignmentMode), alignof(GtkSourceGutterRendererAlignmentMode)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererClass", sizeof(GtkSourceGutterRendererClass), alignof(GtkSourceGutterRendererClass)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererPixbuf", sizeof(GtkSourceGutterRendererPixbuf), alignof(GtkSourceGutterRendererPixbuf)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererPixbufClass", sizeof(GtkSourceGutterRendererPixbufClass), alignof(GtkSourceGutterRendererPixbufClass)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererText", sizeof(GtkSourceGutterRendererText), alignof(GtkSourceGutterRendererText)); printf("%s;%zu;%zu\n", "GtkSourceGutterRendererTextClass", sizeof(GtkSourceGutterRendererTextClass), alignof(GtkSourceGutterRendererTextClass)); printf("%s;%zu;%zu\n", "GtkSourceHoverClass", sizeof(GtkSourceHoverClass), alignof(GtkSourceHoverClass)); printf("%s;%zu;%zu\n", "GtkSourceHoverContextClass", sizeof(GtkSourceHoverContextClass), alignof(GtkSourceHoverContextClass)); printf("%s;%zu;%zu\n", "GtkSourceHoverDisplayClass", sizeof(GtkSourceHoverDisplayClass), alignof(GtkSourceHoverDisplayClass)); printf("%s;%zu;%zu\n", "GtkSourceHoverProviderInterface", sizeof(GtkSourceHoverProviderInterface), alignof(GtkSourceHoverProviderInterface)); printf("%s;%zu;%zu\n", "GtkSourceIndenterInterface", sizeof(GtkSourceIndenterInterface), alignof(GtkSourceIndenterInterface)); printf("%s;%zu;%zu\n", "GtkSourceLanguageClass", sizeof(GtkSourceLanguageClass), alignof(GtkSourceLanguageClass)); printf("%s;%zu;%zu\n", "GtkSourceLanguageManagerClass", sizeof(GtkSourceLanguageManagerClass), alignof(GtkSourceLanguageManagerClass)); printf("%s;%zu;%zu\n", "GtkSourceMap", sizeof(GtkSourceMap), alignof(GtkSourceMap)); printf("%s;%zu;%zu\n", "GtkSourceMapClass", sizeof(GtkSourceMapClass), alignof(GtkSourceMapClass)); printf("%s;%zu;%zu\n", "GtkSourceMark", sizeof(GtkSourceMark), alignof(GtkSourceMark)); printf("%s;%zu;%zu\n", "GtkSourceMarkAttributesClass", sizeof(GtkSourceMarkAttributesClass), alignof(GtkSourceMarkAttributesClass)); printf("%s;%zu;%zu\n", "GtkSourceMarkClass", sizeof(GtkSourceMarkClass), alignof(GtkSourceMarkClass)); printf("%s;%zu;%zu\n", "GtkSourceNewlineType", sizeof(GtkSourceNewlineType), alignof(GtkSourceNewlineType)); printf("%s;%zu;%zu\n", "GtkSourcePrintCompositor", sizeof(GtkSourcePrintCompositor), alignof(GtkSourcePrintCompositor)); printf("%s;%zu;%zu\n", "GtkSourcePrintCompositorClass", sizeof(GtkSourcePrintCompositorClass), alignof(GtkSourcePrintCompositorClass)); printf("%s;%zu;%zu\n", "GtkSourceRegion", sizeof(GtkSourceRegion), alignof(GtkSourceRegion)); printf("%s;%zu;%zu\n", "GtkSourceRegionClass", sizeof(GtkSourceRegionClass), alignof(GtkSourceRegionClass)); printf("%s;%zu;%zu\n", "GtkSourceRegionIter", sizeof(GtkSourceRegionIter), alignof(GtkSourceRegionIter)); printf("%s;%zu;%zu\n", "GtkSourceSearchContextClass", sizeof(GtkSourceSearchContextClass), alignof(GtkSourceSearchContextClass)); printf("%s;%zu;%zu\n", "GtkSourceSearchSettings", sizeof(GtkSourceSearchSettings), alignof(GtkSourceSearchSettings)); printf("%s;%zu;%zu\n", "GtkSourceSearchSettingsClass", sizeof(GtkSourceSearchSettingsClass), alignof(GtkSourceSearchSettingsClass)); printf("%s;%zu;%zu\n", "GtkSourceSmartHomeEndType", sizeof(GtkSourceSmartHomeEndType), alignof(GtkSourceSmartHomeEndType)); printf("%s;%zu;%zu\n", "GtkSourceSnippetChunkClass", sizeof(GtkSourceSnippetChunkClass), alignof(GtkSourceSnippetChunkClass)); printf("%s;%zu;%zu\n", "GtkSourceSnippetClass", sizeof(GtkSourceSnippetClass), alignof(GtkSourceSnippetClass)); printf("%s;%zu;%zu\n", "GtkSourceSnippetContextClass", sizeof(GtkSourceSnippetContextClass), alignof(GtkSourceSnippetContextClass)); printf("%s;%zu;%zu\n", "GtkSourceSnippetManagerClass", sizeof(GtkSourceSnippetManagerClass), alignof(GtkSourceSnippetManagerClass)); printf("%s;%zu;%zu\n", "GtkSourceSortFlags", sizeof(GtkSourceSortFlags), alignof(GtkSourceSortFlags)); printf("%s;%zu;%zu\n", "GtkSourceSpaceDrawerClass", sizeof(GtkSourceSpaceDrawerClass), alignof(GtkSourceSpaceDrawerClass)); printf("%s;%zu;%zu\n", "GtkSourceSpaceLocationFlags", sizeof(GtkSourceSpaceLocationFlags), alignof(GtkSourceSpaceLocationFlags)); printf("%s;%zu;%zu\n", "GtkSourceSpaceTypeFlags", sizeof(GtkSourceSpaceTypeFlags), alignof(GtkSourceSpaceTypeFlags)); printf("%s;%zu;%zu\n", "GtkSourceStyleClass", sizeof(GtkSourceStyleClass), alignof(GtkSourceStyleClass)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeChooserButton", sizeof(GtkSourceStyleSchemeChooserButton), alignof(GtkSourceStyleSchemeChooserButton)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeChooserButtonClass", sizeof(GtkSourceStyleSchemeChooserButtonClass), alignof(GtkSourceStyleSchemeChooserButtonClass)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeChooserInterface", sizeof(GtkSourceStyleSchemeChooserInterface), alignof(GtkSourceStyleSchemeChooserInterface)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeChooserWidget", sizeof(GtkSourceStyleSchemeChooserWidget), alignof(GtkSourceStyleSchemeChooserWidget)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeChooserWidgetClass", sizeof(GtkSourceStyleSchemeChooserWidgetClass), alignof(GtkSourceStyleSchemeChooserWidgetClass)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeClass", sizeof(GtkSourceStyleSchemeClass), alignof(GtkSourceStyleSchemeClass)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemeManagerClass", sizeof(GtkSourceStyleSchemeManagerClass), alignof(GtkSourceStyleSchemeManagerClass)); printf("%s;%zu;%zu\n", "GtkSourceStyleSchemePreviewClass", sizeof(GtkSourceStyleSchemePreviewClass), alignof(GtkSourceStyleSchemePreviewClass)); printf("%s;%zu;%zu\n", "GtkSourceTag", sizeof(GtkSourceTag), alignof(GtkSourceTag)); printf("%s;%zu;%zu\n", "GtkSourceTagClass", sizeof(GtkSourceTagClass), alignof(GtkSourceTagClass)); printf("%s;%zu;%zu\n", "GtkSourceView", sizeof(GtkSourceView), alignof(GtkSourceView)); printf("%s;%zu;%zu\n", "GtkSourceViewClass", sizeof(GtkSourceViewClass), alignof(GtkSourceViewClass)); printf("%s;%zu;%zu\n", "GtkSourceViewGutterPosition", sizeof(GtkSourceViewGutterPosition), alignof(GtkSourceViewGutterPosition)); printf("%s;%zu;%zu\n", "GtkSourceVimIMContextClass", sizeof(GtkSourceVimIMContextClass), alignof(GtkSourceVimIMContextClass)); return 0; } sourceview5-sys-0.9.0/tests/manual.h000064400000000000000000000001771046102023000155230ustar 00000000000000// Feel free to edit this file, it won't be regenerated by gir generator unless removed. #include