// This file was generated by gir (https://github.com/gtk-rs/gir @ 60cbef0)
// from gir-files (https://github.com/gtk-rs/gir-files @ 3043b14)
// 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
)]

extern crate cairo_sys as cairo;
extern crate gdk_pixbuf_sys as gdk_pixbuf;
extern crate gdk_sys as gdk;
extern crate gio_sys as gio;
extern crate glib_sys as glib;
extern crate gobject_sys as gobject;
extern crate gtk_sys as gtk;
extern crate libc;

#[allow(unused_imports)]
use libc::{
    c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
    intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
};

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

// Enums
pub type GtkSourceBackgroundPatternType = c_int;
pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE: GtkSourceBackgroundPatternType = 0;
pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID: GtkSourceBackgroundPatternType = 1;

pub type GtkSourceBracketMatchType = c_int;
pub const GTK_SOURCE_BRACKET_MATCH_NONE: GtkSourceBracketMatchType = 0;
pub const GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE: GtkSourceBracketMatchType = 1;
pub const GTK_SOURCE_BRACKET_MATCH_NOT_FOUND: GtkSourceBracketMatchType = 2;
pub const GTK_SOURCE_BRACKET_MATCH_FOUND: GtkSourceBracketMatchType = 3;

pub type GtkSourceChangeCaseType = c_int;
pub const GTK_SOURCE_CHANGE_CASE_LOWER: GtkSourceChangeCaseType = 0;
pub const GTK_SOURCE_CHANGE_CASE_UPPER: GtkSourceChangeCaseType = 1;
pub const GTK_SOURCE_CHANGE_CASE_TOGGLE: GtkSourceChangeCaseType = 2;
pub const GTK_SOURCE_CHANGE_CASE_TITLE: GtkSourceChangeCaseType = 3;

pub type GtkSourceCompletionError = c_int;
pub const GTK_SOURCE_COMPLETION_ERROR_ALREADY_BOUND: GtkSourceCompletionError = 0;
pub const GTK_SOURCE_COMPLETION_ERROR_NOT_BOUND: GtkSourceCompletionError = 1;

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;

// Flags
pub type GtkSourceCompletionActivation = c_uint;
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 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 GtkSourceGutterRendererState = c_uint;
pub const GTK_SOURCE_GUTTER_RENDERER_STATE_NORMAL: GtkSourceGutterRendererState = 0;
pub const GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR: GtkSourceGutterRendererState = 1;
pub const GTK_SOURCE_GUTTER_RENDERER_STATE_PRELIT: GtkSourceGutterRendererState = 2;
pub const GTK_SOURCE_GUTTER_RENDERER_STATE_SELECTED: GtkSourceGutterRendererState = 4;

pub type GtkSourceSortFlags = c_uint;
pub const GTK_SOURCE_SORT_FLAGS_NONE: GtkSourceSortFlags = 0;
pub const GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE: GtkSourceSortFlags = 1;
pub const GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER: GtkSourceSortFlags = 2;
pub const GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES: GtkSourceSortFlags = 4;

pub type GtkSourceSpaceLocationFlags = c_uint;
pub const GTK_SOURCE_SPACE_LOCATION_NONE: GtkSourceSpaceLocationFlags = 0;
pub const GTK_SOURCE_SPACE_LOCATION_LEADING: GtkSourceSpaceLocationFlags = 1;
pub const GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT: GtkSourceSpaceLocationFlags = 2;
pub const GTK_SOURCE_SPACE_LOCATION_TRAILING: GtkSourceSpaceLocationFlags = 4;
pub const GTK_SOURCE_SPACE_LOCATION_ALL: GtkSourceSpaceLocationFlags = 7;

pub type GtkSourceSpaceTypeFlags = c_uint;
pub const GTK_SOURCE_SPACE_TYPE_NONE: GtkSourceSpaceTypeFlags = 0;
pub const GTK_SOURCE_SPACE_TYPE_SPACE: GtkSourceSpaceTypeFlags = 1;
pub const GTK_SOURCE_SPACE_TYPE_TAB: GtkSourceSpaceTypeFlags = 2;
pub const GTK_SOURCE_SPACE_TYPE_NEWLINE: GtkSourceSpaceTypeFlags = 4;
pub const GTK_SOURCE_SPACE_TYPE_NBSP: GtkSourceSpaceTypeFlags = 8;
pub const GTK_SOURCE_SPACE_TYPE_ALL: GtkSourceSpaceTypeFlags = 15;

// Callbacks
pub type GtkSourceMountOperationFactory =
    Option<unsafe extern "C" fn(*mut GtkSourceFile, gpointer) -> *mut gio::GMountOperation>;

// Records
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceBufferClass {
    pub parent_class: gtk::GtkTextBufferClass,
    pub undo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>,
    pub redo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>,
    pub bracket_matched: Option<
        unsafe extern "C" fn(
            *mut GtkSourceBuffer,
            *mut gtk::GtkTextIter,
            GtkSourceBracketMatchType,
        ),
    >,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("undo", &self.undo)
            .field("redo", &self.redo)
            .field("bracket_matched", &self.bracket_matched)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceBufferPrivate(c_void);

pub type GtkSourceBufferPrivate = *mut _GtkSourceBufferPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionClass {
    pub parent_class: gobject::GObjectClass,
    pub proposal_activated: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletion,
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionProposal,
        ) -> gboolean,
    >,
    pub show: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
    pub hide: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
    pub populate_context:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletion, *mut GtkSourceCompletionContext)>,
    pub move_cursor:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>,
    pub move_page:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>,
    pub activate_proposal: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
    pub padding: [gpointer; 20],
}

impl ::std::fmt::Debug for GtkSourceCompletionClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("proposal_activated", &self.proposal_activated)
        .field("show", &self.show)
        .field("hide", &self.hide)
        .field("populate_context", &self.populate_context)
        .field("move_cursor", &self.move_cursor)
        .field("move_page", &self.move_page)
        .field("activate_proposal", &self.activate_proposal)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionContextClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub cancelled: Option<unsafe extern "C" fn(*mut GtkSourceCompletionContext)>,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceCompletionContextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionContextClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("cancelled", &self.cancelled)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceCompletionContextPrivate(c_void);

pub type GtkSourceCompletionContextPrivate = *mut _GtkSourceCompletionContextPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionInfoClass {
    pub parent_class: gtk::GtkWindowClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceCompletionInfoClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionInfoClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceCompletionInfoPrivate(c_void);

pub type GtkSourceCompletionInfoPrivate = *mut _GtkSourceCompletionInfoPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionItemClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceCompletionItemClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionItemClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceCompletionItemPrivate(c_void);

pub type GtkSourceCompletionItemPrivate = *mut _GtkSourceCompletionItemPrivate;

#[repr(C)]
pub struct _GtkSourceCompletionPrivate(c_void);

pub type GtkSourceCompletionPrivate = *mut _GtkSourceCompletionPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionProposalIface {
    pub parent: gobject::GTypeInterface,
    pub get_label: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
    pub get_markup: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
    pub get_text: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
    pub get_icon: Option<
        unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gdk_pixbuf::GdkPixbuf,
    >,
    pub get_icon_name:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
    pub get_gicon:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gio::GIcon>,
    pub get_info: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
    pub hash: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> c_uint>,
    pub equal: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProposal,
            *mut GtkSourceCompletionProposal,
        ) -> gboolean,
    >,
    pub changed: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal)>,
}

impl ::std::fmt::Debug for GtkSourceCompletionProposalIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionProposalIface @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .field("get_label", &self.get_label)
        .field("get_markup", &self.get_markup)
        .field("get_text", &self.get_text)
        .field("get_icon", &self.get_icon)
        .field("get_icon_name", &self.get_icon_name)
        .field("get_gicon", &self.get_gicon)
        .field("get_info", &self.get_info)
        .field("hash", &self.hash)
        .field("equal", &self.equal)
        .field("changed", &self.changed)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionProviderIface {
    pub g_iface: gobject::GTypeInterface,
    pub get_name: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>,
    pub get_icon: Option<
        unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gdk_pixbuf::GdkPixbuf,
    >,
    pub get_icon_name:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>,
    pub get_gicon:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gio::GIcon>,
    pub populate: Option<
        unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext),
    >,
    pub match_: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionContext,
        ) -> gboolean,
    >,
    pub get_activation: Option<
        unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> GtkSourceCompletionActivation,
    >,
    pub get_info_widget: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionProposal,
        ) -> *mut gtk::GtkWidget,
    >,
    pub update_info: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionProposal,
            *mut GtkSourceCompletionInfo,
        ),
    >,
    pub get_start_iter: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionContext,
            *mut GtkSourceCompletionProposal,
            *mut gtk::GtkTextIter,
        ) -> gboolean,
    >,
    pub activate_proposal: Option<
        unsafe extern "C" fn(
            *mut GtkSourceCompletionProvider,
            *mut GtkSourceCompletionProposal,
            *mut gtk::GtkTextIter,
        ) -> gboolean,
    >,
    pub get_interactive_delay:
        Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>,
    pub get_priority: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>,
}

impl ::std::fmt::Debug for GtkSourceCompletionProviderIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionProviderIface @ {:?}",
            self as *const _
        ))
        .field("g_iface", &self.g_iface)
        .field("get_name", &self.get_name)
        .field("get_icon", &self.get_icon)
        .field("get_icon_name", &self.get_icon_name)
        .field("get_gicon", &self.get_gicon)
        .field("populate", &self.populate)
        .field("match_", &self.match_)
        .field("get_activation", &self.get_activation)
        .field("get_info_widget", &self.get_info_widget)
        .field("update_info", &self.update_info)
        .field("get_start_iter", &self.get_start_iter)
        .field("activate_proposal", &self.activate_proposal)
        .field("get_interactive_delay", &self.get_interactive_delay)
        .field("get_priority", &self.get_priority)
        .finish()
    }
}

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

impl ::std::fmt::Debug for GtkSourceCompletionWordsClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionWordsClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceCompletionWordsPrivate(c_void);

pub type GtkSourceCompletionWordsPrivate = *mut _GtkSourceCompletionWordsPrivate;

#[repr(C)]
pub struct GtkSourceEncoding(c_void);

impl ::std::fmt::Debug for GtkSourceEncoding {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceEncoding @ {:?}", self as *const _))
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFileClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFileLoaderClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceFileLoaderClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceFileLoaderClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceFileLoaderPrivate(c_void);

pub type GtkSourceFileLoaderPrivate = *mut _GtkSourceFileLoaderPrivate;

#[repr(C)]
pub struct _GtkSourceFilePrivate(c_void);

pub type GtkSourceFilePrivate = *mut _GtkSourceFilePrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFileSaverClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceFileSaverClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceFileSaverClass @ {:?}", self as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceFileSaverPrivate(c_void);

pub type GtkSourceFileSaverPrivate = *mut _GtkSourceFileSaverPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceGutterClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceGutterClass @ {:?}", self as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceGutterPrivate(c_void);

pub type GtkSourceGutterPrivate = *mut _GtkSourceGutterPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRendererClass {
    pub parent_class: gobject::GInitiallyUnownedClass,
    pub begin: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut cairo::cairo_t,
            *mut gdk::GdkRectangle,
            *mut gdk::GdkRectangle,
            *mut gtk::GtkTextIter,
            *mut gtk::GtkTextIter,
        ),
    >,
    pub draw: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut cairo::cairo_t,
            *mut gdk::GdkRectangle,
            *mut gdk::GdkRectangle,
            *mut gtk::GtkTextIter,
            *mut gtk::GtkTextIter,
            GtkSourceGutterRendererState,
        ),
    >,
    pub end: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>,
    pub change_view:
        Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextView)>,
    pub change_buffer:
        Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextBuffer)>,
    pub query_activatable: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut gtk::GtkTextIter,
            *mut gdk::GdkRectangle,
            *mut gdk::GdkEvent,
        ) -> gboolean,
    >,
    pub activate: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut gtk::GtkTextIter,
            *mut gdk::GdkRectangle,
            *mut gdk::GdkEvent,
        ),
    >,
    pub queue_draw: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>,
    pub query_tooltip: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut gtk::GtkTextIter,
            *mut gdk::GdkRectangle,
            c_int,
            c_int,
            *mut gtk::GtkTooltip,
        ) -> gboolean,
    >,
    pub query_data: Option<
        unsafe extern "C" fn(
            *mut GtkSourceGutterRenderer,
            *mut gtk::GtkTextIter,
            *mut gtk::GtkTextIter,
            GtkSourceGutterRendererState,
        ),
    >,
    pub padding: [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 as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("begin", &self.begin)
        .field("draw", &self.draw)
        .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)
        .field("queue_draw", &self.queue_draw)
        .field("query_tooltip", &self.query_tooltip)
        .field("query_data", &self.query_data)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRendererPixbufClass {
    pub parent_class: GtkSourceGutterRendererClass,
    pub padding: [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 as *const _
        ))
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceGutterRendererPixbufPrivate(c_void);

pub type GtkSourceGutterRendererPixbufPrivate = *mut _GtkSourceGutterRendererPixbufPrivate;

#[repr(C)]
pub struct _GtkSourceGutterRendererPrivate(c_void);

pub type GtkSourceGutterRendererPrivate = *mut _GtkSourceGutterRendererPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRendererTextClass {
    pub parent_class: GtkSourceGutterRendererClass,
    pub padding: [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 as *const _
        ))
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceGutterRendererTextPrivate(c_void);

pub type GtkSourceGutterRendererTextPrivate = *mut _GtkSourceGutterRendererTextPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceLanguageClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceLanguageClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceLanguageClass @ {:?}", self as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceLanguageManagerClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceLanguageManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceLanguageManagerClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceLanguageManagerPrivate(c_void);

pub type GtkSourceLanguageManagerPrivate = *mut _GtkSourceLanguageManagerPrivate;

#[repr(C)]
pub struct _GtkSourceLanguagePrivate(c_void);

pub type GtkSourceLanguagePrivate = *mut _GtkSourceLanguagePrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceMapClass {
    pub parent_class: GtkSourceViewClass,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceMarkAttributesClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceMarkAttributesClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceMarkAttributesClass @ {:?}",
            self as *const _
        ))
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceMarkAttributesPrivate(c_void);

pub type GtkSourceMarkAttributesPrivate = *mut _GtkSourceMarkAttributesPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceMarkClass {
    pub parent_class: gtk::GtkTextMarkClass,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceMarkPrivate(c_void);

pub type GtkSourceMarkPrivate = *mut _GtkSourceMarkPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourcePrintCompositorClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [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 as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourcePrintCompositorPrivate(c_void);

pub type GtkSourcePrintCompositorPrivate = *mut _GtkSourcePrintCompositorPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceRegionClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSearchContextClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceSearchContextClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceSearchContextClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceSearchContextPrivate(c_void);

pub type GtkSourceSearchContextPrivate = *mut _GtkSourceSearchContextPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSearchSettingsClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [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 as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceSearchSettingsPrivate(c_void);

pub type GtkSourceSearchSettingsPrivate = *mut _GtkSourceSearchSettingsPrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSpaceDrawerClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 20],
}

impl ::std::fmt::Debug for GtkSourceSpaceDrawerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceSpaceDrawerClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceSpaceDrawerPrivate(c_void);

pub type GtkSourceSpaceDrawerPrivate = *mut _GtkSourceSpaceDrawerPrivate;

#[repr(C)]
pub struct _GtkSourceStyleClass(c_void);

pub type GtkSourceStyleClass = *mut _GtkSourceStyleClass;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeChooserButtonClass {
    pub parent: gtk::GtkButtonClass,
    pub padding: [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 as *const _
        ))
        .field("parent", &self.parent)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 padding: [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 as *const _
        ))
        .field("base_interface", &self.base_interface)
        .field("get_style_scheme", &self.get_style_scheme)
        .field("set_style_scheme", &self.set_style_scheme)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeChooserWidgetClass {
    pub parent: gtk::GtkBinClass,
    pub padding: [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 as *const _
        ))
        .field("parent", &self.parent)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeClass {
    pub base_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceStyleSchemeClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceStyleSchemeClass @ {:?}",
            self as *const _
        ))
        .field("base_class", &self.base_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeManagerClass {
    pub parent_class: gobject::GObjectClass,
    pub padding: [gpointer; 10],
}

impl ::std::fmt::Debug for GtkSourceStyleSchemeManagerClass {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceStyleSchemeManagerClass @ {:?}",
            self as *const _
        ))
        .field("parent_class", &self.parent_class)
        .field("padding", &self.padding)
        .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceStyleSchemeManagerPrivate(c_void);

pub type GtkSourceStyleSchemeManagerPrivate = *mut _GtkSourceStyleSchemeManagerPrivate;

#[repr(C)]
pub struct _GtkSourceStyleSchemePrivate(c_void);

pub type GtkSourceStyleSchemePrivate = *mut _GtkSourceStyleSchemePrivate;

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceTagClass {
    pub parent_class: gtk::GtkTextTagClass,
    pub padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceUndoManagerIface {
    pub parent: gobject::GTypeInterface,
    pub can_undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>,
    pub can_redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>,
    pub undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
    pub redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
    pub begin_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
    pub end_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
    pub can_undo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
    pub can_redo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
}

impl ::std::fmt::Debug for GtkSourceUndoManagerIface {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceUndoManagerIface @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .field("can_undo", &self.can_undo)
        .field("can_redo", &self.can_redo)
        .field("undo", &self.undo)
        .field("redo", &self.redo)
        .field("begin_not_undoable_action", &self.begin_not_undoable_action)
        .field("end_not_undoable_action", &self.end_not_undoable_action)
        .field("can_undo_changed", &self.can_undo_changed)
        .field("can_redo_changed", &self.can_redo_changed)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceViewClass {
    pub parent_class: gtk::GtkTextViewClass,
    pub undo: Option<unsafe extern "C" fn(*mut GtkSourceView)>,
    pub redo: Option<unsafe extern "C" fn(*mut GtkSourceView)>,
    pub line_mark_activated:
        Option<unsafe extern "C" fn(*mut GtkSourceView, *mut gtk::GtkTextIter, *mut gdk::GdkEvent)>,
    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 padding: [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 as *const _))
            .field("parent_class", &self.parent_class)
            .field("undo", &self.undo)
            .field("redo", &self.redo)
            .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("padding", &self.padding)
            .finish()
    }
}

#[repr(C)]
pub struct _GtkSourceViewPrivate(c_void);

pub type GtkSourceViewPrivate = *mut _GtkSourceViewPrivate;

// Classes
#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceBuffer {
    pub parent_instance: gtk::GtkTextBuffer,
    pub priv_: *mut GtkSourceBufferPrivate,
}

impl ::std::fmt::Debug for GtkSourceBuffer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceBuffer @ {:?}", self as *const _))
            .field("parent_instance", &self.parent_instance)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletion {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut GtkSourceCompletionPrivate,
}

impl ::std::fmt::Debug for GtkSourceCompletion {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceCompletion @ {:?}", self as *const _))
            .field("parent_instance", &self.parent_instance)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionContext {
    pub parent: gobject::GInitiallyUnowned,
    pub priv_: *mut GtkSourceCompletionContextPrivate,
}

impl ::std::fmt::Debug for GtkSourceCompletionContext {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionContext @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .field("priv_", &self.priv_)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionInfo {
    pub parent: gtk::GtkWindow,
    pub priv_: *mut GtkSourceCompletionInfoPrivate,
}

impl ::std::fmt::Debug for GtkSourceCompletionInfo {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceCompletionInfo @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionItem {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceCompletionItemPrivate,
}

impl ::std::fmt::Debug for GtkSourceCompletionItem {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceCompletionItem @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceCompletionWords {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceCompletionWordsPrivate,
}

impl ::std::fmt::Debug for GtkSourceCompletionWords {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceCompletionWords @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .field("priv_", &self.priv_)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFile {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceFilePrivate,
}

impl ::std::fmt::Debug for GtkSourceFile {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceFile @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFileLoader {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceFileLoaderPrivate,
}

impl ::std::fmt::Debug for GtkSourceFileLoader {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceFileLoader @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceFileSaver {
    pub object: gobject::GObject,
    pub priv_: *mut GtkSourceFileSaverPrivate,
}

impl ::std::fmt::Debug for GtkSourceFileSaver {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceFileSaver @ {:?}", self as *const _))
            .field("object", &self.object)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutter {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceGutterPrivate,
}

impl ::std::fmt::Debug for GtkSourceGutter {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceGutter @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRenderer {
    pub parent: gobject::GInitiallyUnowned,
    pub priv_: *mut GtkSourceGutterRendererPrivate,
}

impl ::std::fmt::Debug for GtkSourceGutterRenderer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceGutterRenderer @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRendererPixbuf {
    pub parent: GtkSourceGutterRenderer,
    pub priv_: *mut GtkSourceGutterRendererPixbufPrivate,
}

impl ::std::fmt::Debug for GtkSourceGutterRendererPixbuf {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceGutterRendererPixbuf @ {:?}",
            self as *const _
        ))
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceGutterRendererText {
    pub parent: GtkSourceGutterRenderer,
    pub priv_: *mut GtkSourceGutterRendererTextPrivate,
}

impl ::std::fmt::Debug for GtkSourceGutterRendererText {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceGutterRendererText @ {:?}",
            self as *const _
        ))
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceLanguage {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut GtkSourceLanguagePrivate,
}

impl ::std::fmt::Debug for GtkSourceLanguage {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceLanguage @ {:?}", self as *const _))
            .field("parent_instance", &self.parent_instance)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceLanguageManager {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut GtkSourceLanguageManagerPrivate,
}

impl ::std::fmt::Debug for GtkSourceLanguageManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceLanguageManager @ {:?}",
            self as *const _
        ))
        .field("parent_instance", &self.parent_instance)
        .field("priv_", &self.priv_)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceMark {
    pub parent_instance: gtk::GtkTextMark,
    pub priv_: *mut GtkSourceMarkPrivate,
}

impl ::std::fmt::Debug for GtkSourceMark {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceMark @ {:?}", self as *const _))
            .field("parent_instance", &self.parent_instance)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceMarkAttributes {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceMarkAttributesPrivate,
}

impl ::std::fmt::Debug for GtkSourceMarkAttributes {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceMarkAttributes @ {:?}", self as *const _))
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourcePrintCompositor {
    pub parent_instance: gobject::GObject,
    pub priv_: *mut GtkSourcePrintCompositorPrivate,
}

impl ::std::fmt::Debug for GtkSourcePrintCompositor {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourcePrintCompositor @ {:?}",
            self as *const _
        ))
        .field("parent_instance", &self.parent_instance)
        .field("priv_", &self.priv_)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSearchContext {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceSearchContextPrivate,
}

impl ::std::fmt::Debug for GtkSourceSearchContext {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceSearchContext @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSearchSettings {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceSearchSettingsPrivate,
}

impl ::std::fmt::Debug for GtkSourceSearchSettings {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceSearchSettings @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceSpaceDrawer {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceSpaceDrawerPrivate,
}

impl ::std::fmt::Debug for GtkSourceSpaceDrawer {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceSpaceDrawer @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
pub struct GtkSourceStyle(c_void);

impl ::std::fmt::Debug for GtkSourceStyle {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceStyle @ {:?}", self as *const _))
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleScheme {
    pub base: gobject::GObject,
    pub priv_: *mut GtkSourceStyleSchemePrivate,
}

impl ::std::fmt::Debug for GtkSourceStyleScheme {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceStyleScheme @ {:?}", self as *const _))
            .field("base", &self.base)
            .field("priv_", &self.priv_)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeChooserButton {
    pub parent: 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 as *const _
        ))
        .field("parent", &self.parent)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeChooserWidget {
    pub parent: gtk::GtkBin,
}

impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidget {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceStyleSchemeChooserWidget @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceStyleSchemeManager {
    pub parent: gobject::GObject,
    pub priv_: *mut GtkSourceStyleSchemeManagerPrivate,
}

impl ::std::fmt::Debug for GtkSourceStyleSchemeManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!(
            "GtkSourceStyleSchemeManager @ {:?}",
            self as *const _
        ))
        .field("parent", &self.parent)
        .field("priv_", &self.priv_)
        .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
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 as *const _))
            .field("parent_instance", &self.parent_instance)
            .finish()
    }
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct GtkSourceView {
    pub parent: gtk::GtkTextView,
    pub priv_: *mut GtkSourceViewPrivate,
}

impl ::std::fmt::Debug for GtkSourceView {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        f.debug_struct(&format!("GtkSourceView @ {:?}", self as *const _))
            .field("parent", &self.parent)
            .field("priv_", &self.priv_)
            .finish()
    }
}

// Interfaces
#[repr(C)]
pub struct GtkSourceCompletionProposal(c_void);

impl ::std::fmt::Debug for GtkSourceCompletionProposal {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GtkSourceCompletionProposal @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GtkSourceCompletionProvider(c_void);

impl ::std::fmt::Debug for GtkSourceCompletionProvider {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GtkSourceCompletionProvider @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GtkSourceStyleSchemeChooser(c_void);

impl ::std::fmt::Debug for GtkSourceStyleSchemeChooser {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GtkSourceStyleSchemeChooser @ {:?}", self as *const _)
    }
}

#[repr(C)]
pub struct GtkSourceUndoManager(c_void);

impl ::std::fmt::Debug for GtkSourceUndoManager {
    fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
        write!(f, "GtkSourceUndoManager @ {:?}", self as *const _)
    }
}

extern "C" {

    //=========================================================================
    // GtkSourceBackgroundPatternType
    //=========================================================================
    pub fn gtk_source_background_pattern_type_get_type() -> GType;

    //=========================================================================
    // GtkSourceBracketMatchType
    //=========================================================================
    pub fn gtk_source_bracket_match_type_get_type() -> GType;

    //=========================================================================
    // GtkSourceChangeCaseType
    //=========================================================================
    pub fn gtk_source_change_case_type_get_type() -> GType;

    //=========================================================================
    // GtkSourceCompletionError
    //=========================================================================
    pub fn gtk_source_completion_error_get_type() -> GType;
    pub fn gtk_source_completion_error_quark() -> glib::GQuark;

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

    //=========================================================================
    // GtkSourceCompletionActivation
    //=========================================================================
    pub fn gtk_source_completion_activation_get_type() -> GType;

    //=========================================================================
    // GtkSourceFileSaverFlags
    //=========================================================================
    pub fn gtk_source_file_saver_flags_get_type() -> GType;

    //=========================================================================
    // GtkSourceGutterRendererState
    //=========================================================================
    pub fn gtk_source_gutter_renderer_state_get_type() -> GType;

    //=========================================================================
    // GtkSourceSortFlags
    //=========================================================================
    pub fn gtk_source_sort_flags_get_type() -> GType;

    //=========================================================================
    // GtkSourceSpaceLocationFlags
    //=========================================================================
    pub fn gtk_source_space_location_flags_get_type() -> GType;

    //=========================================================================
    // GtkSourceSpaceTypeFlags
    //=========================================================================
    pub fn gtk_source_space_type_flags_get_type() -> GType;

    //=========================================================================
    // GtkSourceEncoding
    //=========================================================================
    pub fn gtk_source_encoding_get_type() -> GType;
    pub fn gtk_source_encoding_copy(enc: *const GtkSourceEncoding) -> *mut GtkSourceEncoding;
    pub fn gtk_source_encoding_free(enc: *mut GtkSourceEncoding);
    pub fn gtk_source_encoding_get_charset(enc: *const GtkSourceEncoding) -> *const c_char;
    pub fn gtk_source_encoding_get_name(enc: *const GtkSourceEncoding) -> *const c_char;
    pub fn gtk_source_encoding_to_string(enc: *const GtkSourceEncoding) -> *mut c_char;
    pub fn gtk_source_encoding_get_all() -> *mut glib::GSList;
    pub fn gtk_source_encoding_get_current() -> *const GtkSourceEncoding;
    pub fn gtk_source_encoding_get_default_candidates() -> *mut glib::GSList;
    pub fn gtk_source_encoding_get_from_charset(charset: *const c_char)
        -> *const GtkSourceEncoding;
    pub fn gtk_source_encoding_get_utf8() -> *const GtkSourceEncoding;

    //=========================================================================
    // GtkSourceRegionIter
    //=========================================================================
    pub fn gtk_source_region_iter_get_subregion(
        iter: *mut GtkSourceRegionIter,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
    ) -> gboolean;
    pub fn gtk_source_region_iter_is_end(iter: *mut GtkSourceRegionIter) -> gboolean;
    pub fn gtk_source_region_iter_next(iter: *mut GtkSourceRegionIter) -> gboolean;

    //=========================================================================
    // GtkSourceBuffer
    //=========================================================================
    pub fn gtk_source_buffer_get_type() -> GType;
    pub fn gtk_source_buffer_new(table: *mut gtk::GtkTextTagTable) -> *mut GtkSourceBuffer;
    pub fn gtk_source_buffer_new_with_language(
        language: *mut GtkSourceLanguage,
    ) -> *mut GtkSourceBuffer;
    pub fn gtk_source_buffer_backward_iter_to_source_mark(
        buffer: *mut GtkSourceBuffer,
        iter: *mut gtk::GtkTextIter,
        category: *const c_char,
    ) -> gboolean;
    pub fn gtk_source_buffer_begin_not_undoable_action(buffer: *mut GtkSourceBuffer);
    pub fn gtk_source_buffer_can_redo(buffer: *mut GtkSourceBuffer) -> gboolean;
    pub fn gtk_source_buffer_can_undo(buffer: *mut GtkSourceBuffer) -> 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_end_not_undoable_action(buffer: *mut GtkSourceBuffer);
    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_max_undo_levels(buffer: *mut GtkSourceBuffer) -> c_int;
    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_get_undo_manager(
        buffer: *mut GtkSourceBuffer,
    ) -> *mut GtkSourceUndoManager;
    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_redo(buffer: *mut GtkSourceBuffer);
    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_max_undo_levels(
        buffer: *mut GtkSourceBuffer,
        max_undo_levels: c_int,
    );
    pub fn gtk_source_buffer_set_style_scheme(
        buffer: *mut GtkSourceBuffer,
        scheme: *mut GtkSourceStyleScheme,
    );
    pub fn gtk_source_buffer_set_undo_manager(
        buffer: *mut GtkSourceBuffer,
        manager: *mut GtkSourceUndoManager,
    );
    pub fn gtk_source_buffer_sort_lines(
        buffer: *mut GtkSourceBuffer,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
        flags: GtkSourceSortFlags,
        column: c_int,
    );
    pub fn gtk_source_buffer_undo(buffer: *mut GtkSourceBuffer);

    //=========================================================================
    // GtkSourceCompletion
    //=========================================================================
    pub fn gtk_source_completion_get_type() -> GType;
    pub fn gtk_source_completion_add_provider(
        completion: *mut GtkSourceCompletion,
        provider: *mut GtkSourceCompletionProvider,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gtk_source_completion_block_interactive(completion: *mut GtkSourceCompletion);
    pub fn gtk_source_completion_create_context(
        completion: *mut GtkSourceCompletion,
        position: *mut gtk::GtkTextIter,
    ) -> *mut GtkSourceCompletionContext;
    pub fn gtk_source_completion_get_info_window(
        completion: *mut GtkSourceCompletion,
    ) -> *mut GtkSourceCompletionInfo;
    pub fn gtk_source_completion_get_providers(
        completion: *mut GtkSourceCompletion,
    ) -> *mut glib::GList;
    pub fn gtk_source_completion_get_view(
        completion: *mut GtkSourceCompletion,
    ) -> *mut GtkSourceView;
    pub fn gtk_source_completion_hide(completion: *mut GtkSourceCompletion);
    pub fn gtk_source_completion_remove_provider(
        completion: *mut GtkSourceCompletion,
        provider: *mut GtkSourceCompletionProvider,
        error: *mut *mut glib::GError,
    ) -> gboolean;
    pub fn gtk_source_completion_start(
        completion: *mut GtkSourceCompletion,
        providers: *mut glib::GList,
        context: *mut GtkSourceCompletionContext,
    ) -> gboolean;
    pub fn gtk_source_completion_unblock_interactive(completion: *mut GtkSourceCompletion);

    //=========================================================================
    // GtkSourceCompletionContext
    //=========================================================================
    pub fn gtk_source_completion_context_get_type() -> GType;
    pub fn gtk_source_completion_context_add_proposals(
        context: *mut GtkSourceCompletionContext,
        provider: *mut GtkSourceCompletionProvider,
        proposals: *mut glib::GList,
        finished: gboolean,
    );
    pub fn gtk_source_completion_context_get_activation(
        context: *mut GtkSourceCompletionContext,
    ) -> GtkSourceCompletionActivation;
    pub fn gtk_source_completion_context_get_iter(
        context: *mut GtkSourceCompletionContext,
        iter: *mut gtk::GtkTextIter,
    ) -> gboolean;

    //=========================================================================
    // GtkSourceCompletionInfo
    //=========================================================================
    pub fn gtk_source_completion_info_get_type() -> GType;
    pub fn gtk_source_completion_info_new() -> *mut GtkSourceCompletionInfo;
    pub fn gtk_source_completion_info_move_to_iter(
        info: *mut GtkSourceCompletionInfo,
        view: *mut gtk::GtkTextView,
        iter: *mut gtk::GtkTextIter,
    );

    //=========================================================================
    // GtkSourceCompletionItem
    //=========================================================================
    pub fn gtk_source_completion_item_get_type() -> GType;
    pub fn gtk_source_completion_item_new() -> *mut GtkSourceCompletionItem;
    pub fn gtk_source_completion_item_set_gicon(
        item: *mut GtkSourceCompletionItem,
        gicon: *mut gio::GIcon,
    );
    pub fn gtk_source_completion_item_set_icon(
        item: *mut GtkSourceCompletionItem,
        icon: *mut gdk_pixbuf::GdkPixbuf,
    );
    pub fn gtk_source_completion_item_set_icon_name(
        item: *mut GtkSourceCompletionItem,
        icon_name: *const c_char,
    );
    pub fn gtk_source_completion_item_set_info(
        item: *mut GtkSourceCompletionItem,
        info: *const c_char,
    );
    pub fn gtk_source_completion_item_set_label(
        item: *mut GtkSourceCompletionItem,
        label: *const c_char,
    );
    pub fn gtk_source_completion_item_set_markup(
        item: *mut GtkSourceCompletionItem,
        markup: *const c_char,
    );
    pub fn gtk_source_completion_item_set_text(
        item: *mut GtkSourceCompletionItem,
        text: *const c_char,
    );

    //=========================================================================
    // GtkSourceCompletionWords
    //=========================================================================
    pub fn gtk_source_completion_words_get_type() -> GType;
    pub fn gtk_source_completion_words_new(
        name: *const c_char,
        icon: *mut gdk_pixbuf::GdkPixbuf,
    ) -> *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_renderer_at_pos(
        gutter: *mut GtkSourceGutter,
        x: c_int,
        y: c_int,
    ) -> *mut GtkSourceGutterRenderer;
    pub fn gtk_source_gutter_get_view(gutter: *mut GtkSourceGutter) -> *mut GtkSourceView;
    pub fn gtk_source_gutter_get_window_type(
        gutter: *mut GtkSourceGutter,
    ) -> gtk::GtkTextWindowType;
    pub fn gtk_source_gutter_insert(
        gutter: *mut GtkSourceGutter,
        renderer: *mut GtkSourceGutterRenderer,
        position: c_int,
    ) -> gboolean;
    pub fn gtk_source_gutter_queue_draw(gutter: *mut GtkSourceGutter);
    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,
    );

    //=========================================================================
    // GtkSourceGutterRenderer
    //=========================================================================
    pub fn gtk_source_gutter_renderer_get_type() -> GType;
    pub fn gtk_source_gutter_renderer_activate(
        renderer: *mut GtkSourceGutterRenderer,
        iter: *mut gtk::GtkTextIter,
        area: *mut gdk::GdkRectangle,
        event: *mut gdk::GdkEvent,
    );
    pub fn gtk_source_gutter_renderer_begin(
        renderer: *mut GtkSourceGutterRenderer,
        cr: *mut cairo::cairo_t,
        background_area: *mut gdk::GdkRectangle,
        cell_area: *mut gdk::GdkRectangle,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
    );
    pub fn gtk_source_gutter_renderer_draw(
        renderer: *mut GtkSourceGutterRenderer,
        cr: *mut cairo::cairo_t,
        background_area: *mut gdk::GdkRectangle,
        cell_area: *mut gdk::GdkRectangle,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
        state: GtkSourceGutterRendererState,
    );
    pub fn gtk_source_gutter_renderer_end(renderer: *mut GtkSourceGutterRenderer);
    pub fn gtk_source_gutter_renderer_get_alignment(
        renderer: *mut GtkSourceGutterRenderer,
        xalign: *mut c_float,
        yalign: *mut c_float,
    );
    pub fn gtk_source_gutter_renderer_get_alignment_mode(
        renderer: *mut GtkSourceGutterRenderer,
    ) -> GtkSourceGutterRendererAlignmentMode;
    pub fn gtk_source_gutter_renderer_get_background(
        renderer: *mut GtkSourceGutterRenderer,
        color: *mut gdk::GdkRGBA,
    ) -> gboolean;
    pub fn gtk_source_gutter_renderer_get_padding(
        renderer: *mut GtkSourceGutterRenderer,
        xpad: *mut c_int,
        ypad: *mut c_int,
    );
    pub fn gtk_source_gutter_renderer_get_size(renderer: *mut GtkSourceGutterRenderer) -> c_int;
    pub fn gtk_source_gutter_renderer_get_view(
        renderer: *mut GtkSourceGutterRenderer,
    ) -> *mut gtk::GtkTextView;
    pub fn gtk_source_gutter_renderer_get_visible(
        renderer: *mut GtkSourceGutterRenderer,
    ) -> gboolean;
    pub fn gtk_source_gutter_renderer_get_window_type(
        renderer: *mut GtkSourceGutterRenderer,
    ) -> gtk::GtkTextWindowType;
    pub fn gtk_source_gutter_renderer_query_activatable(
        renderer: *mut GtkSourceGutterRenderer,
        iter: *mut gtk::GtkTextIter,
        area: *mut gdk::GdkRectangle,
        event: *mut gdk::GdkEvent,
    ) -> gboolean;
    pub fn gtk_source_gutter_renderer_query_data(
        renderer: *mut GtkSourceGutterRenderer,
        start: *mut gtk::GtkTextIter,
        end: *mut gtk::GtkTextIter,
        state: GtkSourceGutterRendererState,
    );
    pub fn gtk_source_gutter_renderer_query_tooltip(
        renderer: *mut GtkSourceGutterRenderer,
        iter: *mut gtk::GtkTextIter,
        area: *mut gdk::GdkRectangle,
        x: c_int,
        y: c_int,
        tooltip: *mut gtk::GtkTooltip,
    ) -> gboolean;
    pub fn gtk_source_gutter_renderer_queue_draw(renderer: *mut GtkSourceGutterRenderer);
    pub fn gtk_source_gutter_renderer_set_alignment(
        renderer: *mut GtkSourceGutterRenderer,
        xalign: c_float,
        yalign: c_float,
    );
    pub fn gtk_source_gutter_renderer_set_alignment_mode(
        renderer: *mut GtkSourceGutterRenderer,
        mode: GtkSourceGutterRendererAlignmentMode,
    );
    pub fn gtk_source_gutter_renderer_set_background(
        renderer: *mut GtkSourceGutterRenderer,
        color: *const gdk::GdkRGBA,
    );
    pub fn gtk_source_gutter_renderer_set_padding(
        renderer: *mut GtkSourceGutterRenderer,
        xpad: c_int,
        ypad: c_int,
    );
    pub fn gtk_source_gutter_renderer_set_size(renderer: *mut GtkSourceGutterRenderer, size: c_int);
    pub fn gtk_source_gutter_renderer_set_visible(
        renderer: *mut GtkSourceGutterRenderer,
        visible: gboolean,
    );

    //=========================================================================
    // 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_pixbuf(
        renderer: *mut GtkSourceGutterRendererPixbuf,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    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_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,
    );

    //=========================================================================
    // 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;
    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;
    pub fn gtk_source_language_manager_set_search_path(
        lm: *mut GtkSourceLanguageManager,
        dirs: *mut *mut 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,
    ) -> *const gdk_pixbuf::GdkPixbuf;
    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;
    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;
    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,
    );
    pub fn gtk_source_search_settings_set_wrap_around(
        settings: *mut GtkSourceSearchSettings,
        wrap_around: gboolean,
    );

    //=========================================================================
    // 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;
    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: *mut *mut c_char,
    );

    //=========================================================================
    // GtkSourceTag
    //=========================================================================
    pub fn gtk_source_tag_get_type() -> GType;
    pub fn gtk_source_tag_new(name: *const c_char) -> *mut gtk::GtkTextTag;

    //=========================================================================
    // GtkSourceView
    //=========================================================================
    pub fn gtk_source_view_get_type() -> GType;
    pub fn gtk_source_view_new() -> *mut gtk::GtkWidget;
    pub fn gtk_source_view_new_with_buffer(buffer: *mut GtkSourceBuffer) -> *mut gtk::GtkWidget;
    pub fn gtk_source_view_get_auto_indent(view: *mut GtkSourceView) -> gboolean;
    pub fn gtk_source_view_get_background_pattern(
        view: *mut GtkSourceView,
    ) -> GtkSourceBackgroundPatternType;
    pub fn gtk_source_view_get_completion(view: *mut GtkSourceView) -> *mut GtkSourceCompletion;
    pub fn gtk_source_view_get_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_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_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_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_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_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,
    );

    //=========================================================================
    // GtkSourceCompletionProposal
    //=========================================================================
    pub fn gtk_source_completion_proposal_get_type() -> GType;
    pub fn gtk_source_completion_proposal_changed(proposal: *mut GtkSourceCompletionProposal);
    pub fn gtk_source_completion_proposal_equal(
        proposal: *mut GtkSourceCompletionProposal,
        other: *mut GtkSourceCompletionProposal,
    ) -> gboolean;
    pub fn gtk_source_completion_proposal_get_gicon(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut gio::GIcon;
    pub fn gtk_source_completion_proposal_get_icon(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn gtk_source_completion_proposal_get_icon_name(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *const c_char;
    pub fn gtk_source_completion_proposal_get_info(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut c_char;
    pub fn gtk_source_completion_proposal_get_label(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut c_char;
    pub fn gtk_source_completion_proposal_get_markup(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut c_char;
    pub fn gtk_source_completion_proposal_get_text(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut c_char;
    pub fn gtk_source_completion_proposal_hash(
        proposal: *mut GtkSourceCompletionProposal,
    ) -> c_uint;

    //=========================================================================
    // GtkSourceCompletionProvider
    //=========================================================================
    pub fn gtk_source_completion_provider_get_type() -> GType;
    pub fn gtk_source_completion_provider_activate_proposal(
        provider: *mut GtkSourceCompletionProvider,
        proposal: *mut GtkSourceCompletionProposal,
        iter: *mut gtk::GtkTextIter,
    ) -> gboolean;
    pub fn gtk_source_completion_provider_get_activation(
        provider: *mut GtkSourceCompletionProvider,
    ) -> GtkSourceCompletionActivation;
    pub fn gtk_source_completion_provider_get_gicon(
        provider: *mut GtkSourceCompletionProvider,
    ) -> *mut gio::GIcon;
    pub fn gtk_source_completion_provider_get_icon(
        provider: *mut GtkSourceCompletionProvider,
    ) -> *mut gdk_pixbuf::GdkPixbuf;
    pub fn gtk_source_completion_provider_get_icon_name(
        provider: *mut GtkSourceCompletionProvider,
    ) -> *const c_char;
    pub fn gtk_source_completion_provider_get_info_widget(
        provider: *mut GtkSourceCompletionProvider,
        proposal: *mut GtkSourceCompletionProposal,
    ) -> *mut gtk::GtkWidget;
    pub fn gtk_source_completion_provider_get_interactive_delay(
        provider: *mut GtkSourceCompletionProvider,
    ) -> c_int;
    pub fn gtk_source_completion_provider_get_name(
        provider: *mut GtkSourceCompletionProvider,
    ) -> *mut c_char;
    pub fn gtk_source_completion_provider_get_priority(
        provider: *mut GtkSourceCompletionProvider,
    ) -> c_int;
    pub fn gtk_source_completion_provider_get_start_iter(
        provider: *mut GtkSourceCompletionProvider,
        context: *mut GtkSourceCompletionContext,
        proposal: *mut GtkSourceCompletionProposal,
        iter: *mut gtk::GtkTextIter,
    ) -> gboolean;
    pub fn gtk_source_completion_provider_match(
        provider: *mut GtkSourceCompletionProvider,
        context: *mut GtkSourceCompletionContext,
    ) -> gboolean;
    pub fn gtk_source_completion_provider_populate(
        provider: *mut GtkSourceCompletionProvider,
        context: *mut GtkSourceCompletionContext,
    );
    pub fn gtk_source_completion_provider_update_info(
        provider: *mut GtkSourceCompletionProvider,
        proposal: *mut GtkSourceCompletionProposal,
        info: *mut GtkSourceCompletionInfo,
    );

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

    //=========================================================================
    // GtkSourceUndoManager
    //=========================================================================
    pub fn gtk_source_undo_manager_get_type() -> GType;
    pub fn gtk_source_undo_manager_begin_not_undoable_action(manager: *mut GtkSourceUndoManager);
    pub fn gtk_source_undo_manager_can_redo(manager: *mut GtkSourceUndoManager) -> gboolean;
    pub fn gtk_source_undo_manager_can_redo_changed(manager: *mut GtkSourceUndoManager);
    pub fn gtk_source_undo_manager_can_undo(manager: *mut GtkSourceUndoManager) -> gboolean;
    pub fn gtk_source_undo_manager_can_undo_changed(manager: *mut GtkSourceUndoManager);
    pub fn gtk_source_undo_manager_end_not_undoable_action(manager: *mut GtkSourceUndoManager);
    pub fn gtk_source_undo_manager_redo(manager: *mut GtkSourceUndoManager);
    pub fn gtk_source_undo_manager_undo(manager: *mut GtkSourceUndoManager);

    //=========================================================================
    // Other functions
    //=========================================================================
    pub fn gtk_source_finalize();
    pub fn gtk_source_init();
    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;

}