sourceview5_sys/

lib.rs

// Generated by gir (https://github.com/gtk-rs/gir @ b3d444a058cf)
// from
// from gir-files (https://github.com/gtk-rs/gir-files.git @ 5c1e490fe50a)
// 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;

#[cfg(unix)]
#[allow(unused_imports)]
use libc::{dev_t, gid_t, pid_t, socklen_t, uid_t};
#[allow(unused_imports)]
use libc::{intptr_t, off_t, size_t, ssize_t, time_t, uintptr_t, FILE};
#[allow(unused_imports)]
use std::ffi::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
};

#[allow(unused_imports)]
use glib::{gboolean, gconstpointer, gpointer, GType};

// Enums
pub type GtkSourceAnnotationStyle = c_int;
pub const GTK_SOURCE_ANNOTATION_STYLE_NONE: GtkSourceAnnotationStyle = 0;
pub const GTK_SOURCE_ANNOTATION_STYLE_WARNING: GtkSourceAnnotationStyle = 1;
pub const GTK_SOURCE_ANNOTATION_STYLE_ERROR: GtkSourceAnnotationStyle = 2;
pub const GTK_SOURCE_ANNOTATION_STYLE_ACCENT: GtkSourceAnnotationStyle = 3;

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;
#[cfg(feature = "v5_16")]
#[cfg_attr(docsrs, doc(cfg(feature = "v5_16")))]
pub const GTK_SOURCE_SORT_FLAGS_FILENAME: GtkSourceSortFlags = 8;

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<unsafe extern "C" fn(*mut GtkSourceFile, gpointer) -> *mut gio::GMountOperation>;
pub type GtkSourceSchedulerCallback = Option<unsafe extern "C" fn(i64, gpointer) -> gboolean>;

// Records
#[derive(Copy, Clone)]
#[repr(C)]
pub struct GtkSourceAnnotationClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for GtkSourceAnnotationClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotationClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GtkSourceAnnotationProviderClass {
    pub parent_class: gobject::GObjectClass,
    pub populate_hover_async: Option<
        unsafe extern "C" fn(
            *mut GtkSourceAnnotationProvider,
            *mut GtkSourceAnnotation,
            *mut GtkSourceHoverDisplay,
            *mut gio::GCancellable,
            gio::GAsyncReadyCallback,
            gpointer,
        ),
    >,
    pub populate_hover_finish: Option<
        unsafe extern "C" fn(
            *mut GtkSourceAnnotationProvider,
            *mut gio::GAsyncResult,
            *mut *mut glib::GError,
        ) -> gboolean,
    >,
}

impl ::std::fmt::Debug for GtkSourceAnnotationProviderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotationProviderClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .field("populate_hover_async", &self.populate_hover_async)
            .field("populate_hover_finish", &self.populate_hover_finish)
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GtkSourceAnnotationsClass {
    pub parent_class: gobject::GObjectClass,
}

impl ::std::fmt::Debug for GtkSourceAnnotationsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotationsClass @ {self:p}"))
            .field("parent_class", &self.parent_class)
            .finish()
    }
}

#[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<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *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<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *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)]
#[allow(dead_code)]
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<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut GtkSourceGutterLines)>,
    pub snapshot_line: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut gtk::GtkSnapshot,
            *mut GtkSourceGutterLines,
            c_uint,
        ),
    >,
    pub end: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>,
    pub change_view: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut GtkSourceView)>,
    pub change_buffer:
        Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut GtkSourceBuffer)>,
    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<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser) -> *mut GtkSourceStyleScheme>,
    pub set_style_scheme:
        Option<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser, *mut GtkSourceStyleScheme)>,
    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<unsafe extern "C" fn(*mut GtkSourceView)>,
    pub move_lines: Option<unsafe extern "C" fn(*mut GtkSourceView, gboolean)>,
    pub move_words: Option<unsafe extern "C" fn(*mut GtkSourceView, c_int)>,
    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
#[repr(C)]
#[allow(dead_code)]
pub struct GtkSourceAnnotation {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GtkSourceAnnotation {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotation @ {self:p}"))
            .finish()
    }
}

#[derive(Copy, Clone)]
#[repr(C)]
pub struct GtkSourceAnnotationProvider {
    pub parent_instance: gobject::GObject,
}

impl ::std::fmt::Debug for GtkSourceAnnotationProvider {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotationProvider @ {self:p}"))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[allow(dead_code)]
pub struct GtkSourceAnnotations {
    _data: [u8; 0],
    _marker: core::marker::PhantomData<(*mut u8, core::marker::PhantomPinned)>,
}

impl ::std::fmt::Debug for GtkSourceAnnotations {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceAnnotations @ {self:p}"))
            .finish()
    }
}

#[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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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)]
#[allow(dead_code)]
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}")
    }
}

extern "C" {

    //=========================================================================
    // GtkSourceAnnotationStyle
    //=========================================================================
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_style_get_type() -> GType;

    //=========================================================================
    // 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;

    //=========================================================================
    // GtkSourceAnnotation
    //=========================================================================
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_get_type() -> GType;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_new(
        description: *const c_char,
        icon: *mut gio::GIcon,
        line: c_int,
        style: GtkSourceAnnotationStyle,
    ) -> *mut GtkSourceAnnotation;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_get_description(self_: *mut GtkSourceAnnotation) -> *const c_char;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_get_icon(self_: *mut GtkSourceAnnotation) -> *mut gio::GIcon;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_get_line(self_: *mut GtkSourceAnnotation) -> c_int;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_get_style(
        self_: *mut GtkSourceAnnotation,
    ) -> GtkSourceAnnotationStyle;

    //=========================================================================
    // GtkSourceAnnotationProvider
    //=========================================================================
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_get_type() -> GType;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_new() -> *mut GtkSourceAnnotationProvider;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_add_annotation(
        self_: *mut GtkSourceAnnotationProvider,
        annotation: *mut GtkSourceAnnotation,
    );
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_populate_hover_async(
        self_: *mut GtkSourceAnnotationProvider,
        annotation: *mut GtkSourceAnnotation,
        display: *mut GtkSourceHoverDisplay,
        cancellable: *mut gio::GCancellable,
        callback: gio::GAsyncReadyCallback,
        user_data: gpointer,
    );
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_populate_hover_finish(
        self_: *mut GtkSourceAnnotationProvider,
        result: *mut gio::GAsyncResult,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_remove_all(self_: *mut GtkSourceAnnotationProvider);
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotation_provider_remove_annotation(
        self_: *mut GtkSourceAnnotationProvider,
        annotation: *mut GtkSourceAnnotation,
    ) -> gboolean;

    //=========================================================================
    // GtkSourceAnnotations
    //=========================================================================
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotations_get_type() -> GType;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotations_add_provider(
        self_: *mut GtkSourceAnnotations,
        provider: *mut GtkSourceAnnotationProvider,
    );
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_annotations_remove_provider(
        self_: *mut GtkSourceAnnotations,
        provider: *mut GtkSourceAnnotationProvider,
    ) -> 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;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_buffer_get_markup(
        buffer: *mut GtkSourceBuffer,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
    ) -> *mut c_char;
    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;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_gutter_lines_get_line_extent(
        lines: *mut GtkSourceGutterLines,
        line: c_uint,
        mode: GtkSourceGutterRendererAlignmentMode,
        y: *mut c_double,
        height: *mut c_double,
    );
    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;
    #[cfg(feature = "v5_18")]
    #[cfg_attr(docsrs, doc(cfg(feature = "v5_18")))]
    pub fn gtk_source_view_get_annotations(view: *mut GtkSourceView) -> *mut GtkSourceAnnotations;
    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;

}