1 // This file was generated by gir (https://github.com/gtk-rs/gir @ 894f9e5) 2 // from gir-files (https://github.com/gtk-rs/gir-files @ 22748fa) 3 // DO NOT EDIT 4 5 #![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)] 6 #![allow(clippy::approx_constant, clippy::type_complexity, clippy::unreadable_literal)] 7 8 extern crate libc; 9 extern crate cairo_sys as cairo; 10 extern crate glib_sys as glib; 11 extern crate gobject_sys as gobject; 12 extern crate gio_sys as gio; 13 extern crate gtk_sys as gtk; 14 extern crate gdk_sys as gdk; 15 extern crate gdk_pixbuf_sys as gdk_pixbuf; 16 17 #[allow(unused_imports)] 18 use libc::{c_int, c_char, c_uchar, c_float, c_uint, c_double, 19 c_short, c_ushort, c_long, c_ulong, 20 c_void, size_t, ssize_t, intptr_t, uintptr_t, time_t, FILE}; 21 22 #[allow(unused_imports)] 23 use glib::{gboolean, gconstpointer, gpointer, GType}; 24 25 // Enums 26 pub type GtkSourceBackgroundPatternType = c_int; 27 pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE: GtkSourceBackgroundPatternType = 0; 28 pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID: GtkSourceBackgroundPatternType = 1; 29 30 pub type GtkSourceBracketMatchType = c_int; 31 pub const GTK_SOURCE_BRACKET_MATCH_NONE: GtkSourceBracketMatchType = 0; 32 pub const GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE: GtkSourceBracketMatchType = 1; 33 pub const GTK_SOURCE_BRACKET_MATCH_NOT_FOUND: GtkSourceBracketMatchType = 2; 34 pub const GTK_SOURCE_BRACKET_MATCH_FOUND: GtkSourceBracketMatchType = 3; 35 36 pub type GtkSourceChangeCaseType = c_int; 37 pub const GTK_SOURCE_CHANGE_CASE_LOWER: GtkSourceChangeCaseType = 0; 38 pub const GTK_SOURCE_CHANGE_CASE_UPPER: GtkSourceChangeCaseType = 1; 39 pub const GTK_SOURCE_CHANGE_CASE_TOGGLE: GtkSourceChangeCaseType = 2; 40 pub const GTK_SOURCE_CHANGE_CASE_TITLE: GtkSourceChangeCaseType = 3; 41 42 pub type GtkSourceCompletionError = c_int; 43 pub const GTK_SOURCE_COMPLETION_ERROR_ALREADY_BOUND: GtkSourceCompletionError = 0; 44 pub const GTK_SOURCE_COMPLETION_ERROR_NOT_BOUND: GtkSourceCompletionError = 1; 45 46 pub type GtkSourceCompressionType = c_int; 47 pub const GTK_SOURCE_COMPRESSION_TYPE_NONE: GtkSourceCompressionType = 0; 48 pub const GTK_SOURCE_COMPRESSION_TYPE_GZIP: GtkSourceCompressionType = 1; 49 50 pub type GtkSourceFileLoaderError = c_int; 51 pub const GTK_SOURCE_FILE_LOADER_ERROR_TOO_BIG: GtkSourceFileLoaderError = 0; 52 pub const GTK_SOURCE_FILE_LOADER_ERROR_ENCODING_AUTO_DETECTION_FAILED: GtkSourceFileLoaderError = 1; 53 pub const GTK_SOURCE_FILE_LOADER_ERROR_CONVERSION_FALLBACK: GtkSourceFileLoaderError = 2; 54 55 pub type GtkSourceFileSaverError = c_int; 56 pub const GTK_SOURCE_FILE_SAVER_ERROR_INVALID_CHARS: GtkSourceFileSaverError = 0; 57 pub const GTK_SOURCE_FILE_SAVER_ERROR_EXTERNALLY_MODIFIED: GtkSourceFileSaverError = 1; 58 59 pub type GtkSourceGutterRendererAlignmentMode = c_int; 60 pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL: GtkSourceGutterRendererAlignmentMode = 0; 61 pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST: GtkSourceGutterRendererAlignmentMode = 1; 62 pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST: GtkSourceGutterRendererAlignmentMode = 2; 63 64 pub type GtkSourceNewlineType = c_int; 65 pub const GTK_SOURCE_NEWLINE_TYPE_LF: GtkSourceNewlineType = 0; 66 pub const GTK_SOURCE_NEWLINE_TYPE_CR: GtkSourceNewlineType = 1; 67 pub const GTK_SOURCE_NEWLINE_TYPE_CR_LF: GtkSourceNewlineType = 2; 68 69 pub type GtkSourceSmartHomeEndType = c_int; 70 pub const GTK_SOURCE_SMART_HOME_END_DISABLED: GtkSourceSmartHomeEndType = 0; 71 pub const GTK_SOURCE_SMART_HOME_END_BEFORE: GtkSourceSmartHomeEndType = 1; 72 pub const GTK_SOURCE_SMART_HOME_END_AFTER: GtkSourceSmartHomeEndType = 2; 73 pub const GTK_SOURCE_SMART_HOME_END_ALWAYS: GtkSourceSmartHomeEndType = 3; 74 75 pub type GtkSourceViewGutterPosition = c_int; 76 pub const GTK_SOURCE_VIEW_GUTTER_POSITION_LINES: GtkSourceViewGutterPosition = -30; 77 pub const GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS: GtkSourceViewGutterPosition = -20; 78 79 // Flags 80 pub type GtkSourceCompletionActivation = c_uint; 81 pub const GTK_SOURCE_COMPLETION_ACTIVATION_NONE: GtkSourceCompletionActivation = 0; 82 pub const GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE: GtkSourceCompletionActivation = 1; 83 pub const GTK_SOURCE_COMPLETION_ACTIVATION_USER_REQUESTED: GtkSourceCompletionActivation = 2; 84 85 pub type GtkSourceFileSaverFlags = c_uint; 86 pub const GTK_SOURCE_FILE_SAVER_FLAGS_NONE: GtkSourceFileSaverFlags = 0; 87 pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_INVALID_CHARS: GtkSourceFileSaverFlags = 1; 88 pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_MODIFICATION_TIME: GtkSourceFileSaverFlags = 2; 89 pub const GTK_SOURCE_FILE_SAVER_FLAGS_CREATE_BACKUP: GtkSourceFileSaverFlags = 4; 90 91 pub type GtkSourceGutterRendererState = c_uint; 92 pub const GTK_SOURCE_GUTTER_RENDERER_STATE_NORMAL: GtkSourceGutterRendererState = 0; 93 pub const GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR: GtkSourceGutterRendererState = 1; 94 pub const GTK_SOURCE_GUTTER_RENDERER_STATE_PRELIT: GtkSourceGutterRendererState = 2; 95 pub const GTK_SOURCE_GUTTER_RENDERER_STATE_SELECTED: GtkSourceGutterRendererState = 4; 96 97 pub type GtkSourceSortFlags = c_uint; 98 pub const GTK_SOURCE_SORT_FLAGS_NONE: GtkSourceSortFlags = 0; 99 pub const GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE: GtkSourceSortFlags = 1; 100 pub const GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER: GtkSourceSortFlags = 2; 101 pub const GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES: GtkSourceSortFlags = 4; 102 103 pub type GtkSourceSpaceLocationFlags = c_uint; 104 pub const GTK_SOURCE_SPACE_LOCATION_NONE: GtkSourceSpaceLocationFlags = 0; 105 pub const GTK_SOURCE_SPACE_LOCATION_LEADING: GtkSourceSpaceLocationFlags = 1; 106 pub const GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT: GtkSourceSpaceLocationFlags = 2; 107 pub const GTK_SOURCE_SPACE_LOCATION_TRAILING: GtkSourceSpaceLocationFlags = 4; 108 pub const GTK_SOURCE_SPACE_LOCATION_ALL: GtkSourceSpaceLocationFlags = 7; 109 110 pub type GtkSourceSpaceTypeFlags = c_uint; 111 pub const GTK_SOURCE_SPACE_TYPE_NONE: GtkSourceSpaceTypeFlags = 0; 112 pub const GTK_SOURCE_SPACE_TYPE_SPACE: GtkSourceSpaceTypeFlags = 1; 113 pub const GTK_SOURCE_SPACE_TYPE_TAB: GtkSourceSpaceTypeFlags = 2; 114 pub const GTK_SOURCE_SPACE_TYPE_NEWLINE: GtkSourceSpaceTypeFlags = 4; 115 pub const GTK_SOURCE_SPACE_TYPE_NBSP: GtkSourceSpaceTypeFlags = 8; 116 pub const GTK_SOURCE_SPACE_TYPE_ALL: GtkSourceSpaceTypeFlags = 15; 117 118 // Callbacks 119 pub type GtkSourceMountOperationFactory = Option<unsafe extern "C" fn(*mut GtkSourceFile, gpointer) -> *mut gio::GMountOperation>; 120 121 // Records 122 #[repr(C)] 123 #[derive(Copy, Clone)] 124 pub struct GtkSourceBufferClass { 125 pub parent_class: gtk::GtkTextBufferClass, 126 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>, 127 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>, 128 pub bracket_matched: Option<unsafe extern "C" fn(*mut GtkSourceBuffer, *mut gtk::GtkTextIter, GtkSourceBracketMatchType)>, 129 pub padding: [gpointer; 20], 130 } 131 132 impl ::std::fmt::Debug for GtkSourceBufferClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result133 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 134 f.debug_struct(&format!("GtkSourceBufferClass @ {:?}", self as *const _)) 135 .field("parent_class", &self.parent_class) 136 .field("undo", &self.undo) 137 .field("redo", &self.redo) 138 .field("bracket_matched", &self.bracket_matched) 139 .field("padding", &self.padding) 140 .finish() 141 } 142 } 143 144 #[repr(C)] 145 pub struct _GtkSourceBufferPrivate(c_void); 146 147 pub type GtkSourceBufferPrivate = *mut _GtkSourceBufferPrivate; 148 149 #[repr(C)] 150 #[derive(Copy, Clone)] 151 pub struct GtkSourceCompletionClass { 152 pub parent_class: gobject::GObjectClass, 153 pub proposal_activated: Option<unsafe extern "C" fn(*mut GtkSourceCompletion, *mut GtkSourceCompletionProvider, *mut GtkSourceCompletionProposal) -> gboolean>, 154 pub show: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>, 155 pub hide: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>, 156 pub populate_context: Option<unsafe extern "C" fn(*mut GtkSourceCompletion, *mut GtkSourceCompletionContext)>, 157 pub move_cursor: Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>, 158 pub move_page: Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>, 159 pub activate_proposal: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>, 160 pub padding: [gpointer; 20], 161 } 162 163 impl ::std::fmt::Debug for GtkSourceCompletionClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result164 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 165 f.debug_struct(&format!("GtkSourceCompletionClass @ {:?}", self as *const _)) 166 .field("parent_class", &self.parent_class) 167 .field("proposal_activated", &self.proposal_activated) 168 .field("show", &self.show) 169 .field("hide", &self.hide) 170 .field("populate_context", &self.populate_context) 171 .field("move_cursor", &self.move_cursor) 172 .field("move_page", &self.move_page) 173 .field("activate_proposal", &self.activate_proposal) 174 .field("padding", &self.padding) 175 .finish() 176 } 177 } 178 179 #[repr(C)] 180 #[derive(Copy, Clone)] 181 pub struct GtkSourceCompletionContextClass { 182 pub parent_class: gobject::GInitiallyUnownedClass, 183 pub cancelled: Option<unsafe extern "C" fn(*mut GtkSourceCompletionContext)>, 184 pub padding: [gpointer; 10], 185 } 186 187 impl ::std::fmt::Debug for GtkSourceCompletionContextClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result188 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 189 f.debug_struct(&format!("GtkSourceCompletionContextClass @ {:?}", self as *const _)) 190 .field("parent_class", &self.parent_class) 191 .field("cancelled", &self.cancelled) 192 .field("padding", &self.padding) 193 .finish() 194 } 195 } 196 197 #[repr(C)] 198 pub struct _GtkSourceCompletionContextPrivate(c_void); 199 200 pub type GtkSourceCompletionContextPrivate = *mut _GtkSourceCompletionContextPrivate; 201 202 #[repr(C)] 203 #[derive(Copy, Clone)] 204 pub struct GtkSourceCompletionInfoClass { 205 pub parent_class: gtk::GtkWindowClass, 206 pub padding: [gpointer; 10], 207 } 208 209 impl ::std::fmt::Debug for GtkSourceCompletionInfoClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result210 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 211 f.debug_struct(&format!("GtkSourceCompletionInfoClass @ {:?}", self as *const _)) 212 .field("parent_class", &self.parent_class) 213 .field("padding", &self.padding) 214 .finish() 215 } 216 } 217 218 #[repr(C)] 219 pub struct _GtkSourceCompletionInfoPrivate(c_void); 220 221 pub type GtkSourceCompletionInfoPrivate = *mut _GtkSourceCompletionInfoPrivate; 222 223 #[repr(C)] 224 #[derive(Copy, Clone)] 225 pub struct GtkSourceCompletionItemClass { 226 pub parent_class: gobject::GObjectClass, 227 pub padding: [gpointer; 10], 228 } 229 230 impl ::std::fmt::Debug for GtkSourceCompletionItemClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result231 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 232 f.debug_struct(&format!("GtkSourceCompletionItemClass @ {:?}", self as *const _)) 233 .field("parent_class", &self.parent_class) 234 .field("padding", &self.padding) 235 .finish() 236 } 237 } 238 239 #[repr(C)] 240 pub struct _GtkSourceCompletionItemPrivate(c_void); 241 242 pub type GtkSourceCompletionItemPrivate = *mut _GtkSourceCompletionItemPrivate; 243 244 #[repr(C)] 245 pub struct _GtkSourceCompletionPrivate(c_void); 246 247 pub type GtkSourceCompletionPrivate = *mut _GtkSourceCompletionPrivate; 248 249 #[repr(C)] 250 #[derive(Copy, Clone)] 251 pub struct GtkSourceCompletionProposalIface { 252 pub parent: gobject::GTypeInterface, 253 pub get_label: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>, 254 pub get_markup: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>, 255 pub get_text: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>, 256 pub get_icon: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gdk_pixbuf::GdkPixbuf>, 257 pub get_icon_name: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>, 258 pub get_gicon: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gio::GIcon>, 259 pub get_info: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>, 260 pub hash: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> c_uint>, 261 pub equal: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal, *mut GtkSourceCompletionProposal) -> gboolean>, 262 pub changed: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal)>, 263 } 264 265 impl ::std::fmt::Debug for GtkSourceCompletionProposalIface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result266 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 267 f.debug_struct(&format!("GtkSourceCompletionProposalIface @ {:?}", self as *const _)) 268 .field("parent", &self.parent) 269 .field("get_label", &self.get_label) 270 .field("get_markup", &self.get_markup) 271 .field("get_text", &self.get_text) 272 .field("get_icon", &self.get_icon) 273 .field("get_icon_name", &self.get_icon_name) 274 .field("get_gicon", &self.get_gicon) 275 .field("get_info", &self.get_info) 276 .field("hash", &self.hash) 277 .field("equal", &self.equal) 278 .field("changed", &self.changed) 279 .finish() 280 } 281 } 282 283 #[repr(C)] 284 #[derive(Copy, Clone)] 285 pub struct GtkSourceCompletionProviderIface { 286 pub g_iface: gobject::GTypeInterface, 287 pub get_name: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>, 288 pub get_icon: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gdk_pixbuf::GdkPixbuf>, 289 pub get_icon_name: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>, 290 pub get_gicon: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gio::GIcon>, 291 pub populate: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext)>, 292 pub match_: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext) -> gboolean>, 293 pub get_activation: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> GtkSourceCompletionActivation>, 294 pub get_info_widget: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionProposal) -> *mut gtk::GtkWidget>, 295 pub update_info: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionProposal, *mut GtkSourceCompletionInfo)>, 296 pub get_start_iter: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext, *mut GtkSourceCompletionProposal, *mut gtk::GtkTextIter) -> gboolean>, 297 pub activate_proposal: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionProposal, *mut gtk::GtkTextIter) -> gboolean>, 298 pub get_interactive_delay: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>, 299 pub get_priority: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>, 300 } 301 302 impl ::std::fmt::Debug for GtkSourceCompletionProviderIface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result303 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 304 f.debug_struct(&format!("GtkSourceCompletionProviderIface @ {:?}", self as *const _)) 305 .field("g_iface", &self.g_iface) 306 .field("get_name", &self.get_name) 307 .field("get_icon", &self.get_icon) 308 .field("get_icon_name", &self.get_icon_name) 309 .field("get_gicon", &self.get_gicon) 310 .field("populate", &self.populate) 311 .field("match_", &self.match_) 312 .field("get_activation", &self.get_activation) 313 .field("get_info_widget", &self.get_info_widget) 314 .field("update_info", &self.update_info) 315 .field("get_start_iter", &self.get_start_iter) 316 .field("activate_proposal", &self.activate_proposal) 317 .field("get_interactive_delay", &self.get_interactive_delay) 318 .field("get_priority", &self.get_priority) 319 .finish() 320 } 321 } 322 323 #[repr(C)] 324 #[derive(Copy, Clone)] 325 pub struct GtkSourceCompletionWordsClass { 326 pub parent_class: gobject::GObjectClass, 327 } 328 329 impl ::std::fmt::Debug for GtkSourceCompletionWordsClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result330 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 331 f.debug_struct(&format!("GtkSourceCompletionWordsClass @ {:?}", self as *const _)) 332 .field("parent_class", &self.parent_class) 333 .finish() 334 } 335 } 336 337 #[repr(C)] 338 pub struct _GtkSourceCompletionWordsPrivate(c_void); 339 340 pub type GtkSourceCompletionWordsPrivate = *mut _GtkSourceCompletionWordsPrivate; 341 342 #[repr(C)] 343 pub struct GtkSourceEncoding(c_void); 344 345 impl ::std::fmt::Debug for GtkSourceEncoding { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result346 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 347 f.debug_struct(&format!("GtkSourceEncoding @ {:?}", self as *const _)) 348 .finish() 349 } 350 } 351 352 #[repr(C)] 353 #[derive(Copy, Clone)] 354 pub struct GtkSourceFileClass { 355 pub parent_class: gobject::GObjectClass, 356 pub padding: [gpointer; 10], 357 } 358 359 impl ::std::fmt::Debug for GtkSourceFileClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result360 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 361 f.debug_struct(&format!("GtkSourceFileClass @ {:?}", self as *const _)) 362 .field("parent_class", &self.parent_class) 363 .field("padding", &self.padding) 364 .finish() 365 } 366 } 367 368 #[repr(C)] 369 #[derive(Copy, Clone)] 370 pub struct GtkSourceFileLoaderClass { 371 pub parent_class: gobject::GObjectClass, 372 pub padding: [gpointer; 10], 373 } 374 375 impl ::std::fmt::Debug for GtkSourceFileLoaderClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result376 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 377 f.debug_struct(&format!("GtkSourceFileLoaderClass @ {:?}", self as *const _)) 378 .field("parent_class", &self.parent_class) 379 .field("padding", &self.padding) 380 .finish() 381 } 382 } 383 384 #[repr(C)] 385 pub struct _GtkSourceFileLoaderPrivate(c_void); 386 387 pub type GtkSourceFileLoaderPrivate = *mut _GtkSourceFileLoaderPrivate; 388 389 #[repr(C)] 390 pub struct _GtkSourceFilePrivate(c_void); 391 392 pub type GtkSourceFilePrivate = *mut _GtkSourceFilePrivate; 393 394 #[repr(C)] 395 #[derive(Copy, Clone)] 396 pub struct GtkSourceFileSaverClass { 397 pub parent_class: gobject::GObjectClass, 398 pub padding: [gpointer; 10], 399 } 400 401 impl ::std::fmt::Debug for GtkSourceFileSaverClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result402 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 403 f.debug_struct(&format!("GtkSourceFileSaverClass @ {:?}", self as *const _)) 404 .field("parent_class", &self.parent_class) 405 .field("padding", &self.padding) 406 .finish() 407 } 408 } 409 410 #[repr(C)] 411 pub struct _GtkSourceFileSaverPrivate(c_void); 412 413 pub type GtkSourceFileSaverPrivate = *mut _GtkSourceFileSaverPrivate; 414 415 #[repr(C)] 416 #[derive(Copy, Clone)] 417 pub struct GtkSourceGutterClass { 418 pub parent_class: gobject::GObjectClass, 419 pub padding: [gpointer; 10], 420 } 421 422 impl ::std::fmt::Debug for GtkSourceGutterClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result423 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 424 f.debug_struct(&format!("GtkSourceGutterClass @ {:?}", self as *const _)) 425 .field("parent_class", &self.parent_class) 426 .field("padding", &self.padding) 427 .finish() 428 } 429 } 430 431 #[repr(C)] 432 pub struct _GtkSourceGutterPrivate(c_void); 433 434 pub type GtkSourceGutterPrivate = *mut _GtkSourceGutterPrivate; 435 436 #[repr(C)] 437 #[derive(Copy, Clone)] 438 pub struct GtkSourceGutterRendererClass { 439 pub parent_class: gobject::GInitiallyUnownedClass, 440 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)>, 441 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)>, 442 pub end: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>, 443 pub change_view: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextView)>, 444 pub change_buffer: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextBuffer)>, 445 pub query_activatable: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gdk::GdkRectangle, *mut gdk::GdkEvent) -> gboolean>, 446 pub activate: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gdk::GdkRectangle, *mut gdk::GdkEvent)>, 447 pub queue_draw: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>, 448 pub query_tooltip: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gdk::GdkRectangle, c_int, c_int, *mut gtk::GtkTooltip) -> gboolean>, 449 pub query_data: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextIter, *mut gtk::GtkTextIter, GtkSourceGutterRendererState)>, 450 pub padding: [gpointer; 20], 451 } 452 453 impl ::std::fmt::Debug for GtkSourceGutterRendererClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result454 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 455 f.debug_struct(&format!("GtkSourceGutterRendererClass @ {:?}", self as *const _)) 456 .field("parent_class", &self.parent_class) 457 .field("begin", &self.begin) 458 .field("draw", &self.draw) 459 .field("end", &self.end) 460 .field("change_view", &self.change_view) 461 .field("change_buffer", &self.change_buffer) 462 .field("query_activatable", &self.query_activatable) 463 .field("activate", &self.activate) 464 .field("queue_draw", &self.queue_draw) 465 .field("query_tooltip", &self.query_tooltip) 466 .field("query_data", &self.query_data) 467 .field("padding", &self.padding) 468 .finish() 469 } 470 } 471 472 #[repr(C)] 473 #[derive(Copy, Clone)] 474 pub struct GtkSourceGutterRendererPixbufClass { 475 pub parent_class: GtkSourceGutterRendererClass, 476 pub padding: [gpointer; 10], 477 } 478 479 impl ::std::fmt::Debug for GtkSourceGutterRendererPixbufClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result480 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 481 f.debug_struct(&format!("GtkSourceGutterRendererPixbufClass @ {:?}", self as *const _)) 482 .finish() 483 } 484 } 485 486 #[repr(C)] 487 pub struct _GtkSourceGutterRendererPixbufPrivate(c_void); 488 489 pub type GtkSourceGutterRendererPixbufPrivate = *mut _GtkSourceGutterRendererPixbufPrivate; 490 491 #[repr(C)] 492 pub struct _GtkSourceGutterRendererPrivate(c_void); 493 494 pub type GtkSourceGutterRendererPrivate = *mut _GtkSourceGutterRendererPrivate; 495 496 #[repr(C)] 497 #[derive(Copy, Clone)] 498 pub struct GtkSourceGutterRendererTextClass { 499 pub parent_class: GtkSourceGutterRendererClass, 500 pub padding: [gpointer; 10], 501 } 502 503 impl ::std::fmt::Debug for GtkSourceGutterRendererTextClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result504 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 505 f.debug_struct(&format!("GtkSourceGutterRendererTextClass @ {:?}", self as *const _)) 506 .finish() 507 } 508 } 509 510 #[repr(C)] 511 pub struct _GtkSourceGutterRendererTextPrivate(c_void); 512 513 pub type GtkSourceGutterRendererTextPrivate = *mut _GtkSourceGutterRendererTextPrivate; 514 515 #[repr(C)] 516 #[derive(Copy, Clone)] 517 pub struct GtkSourceLanguageClass { 518 pub parent_class: gobject::GObjectClass, 519 pub padding: [gpointer; 10], 520 } 521 522 impl ::std::fmt::Debug for GtkSourceLanguageClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result523 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 524 f.debug_struct(&format!("GtkSourceLanguageClass @ {:?}", self as *const _)) 525 .field("parent_class", &self.parent_class) 526 .field("padding", &self.padding) 527 .finish() 528 } 529 } 530 531 #[repr(C)] 532 #[derive(Copy, Clone)] 533 pub struct GtkSourceLanguageManagerClass { 534 pub parent_class: gobject::GObjectClass, 535 pub padding: [gpointer; 10], 536 } 537 538 impl ::std::fmt::Debug for GtkSourceLanguageManagerClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result539 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 540 f.debug_struct(&format!("GtkSourceLanguageManagerClass @ {:?}", self as *const _)) 541 .field("parent_class", &self.parent_class) 542 .field("padding", &self.padding) 543 .finish() 544 } 545 } 546 547 #[repr(C)] 548 pub struct _GtkSourceLanguageManagerPrivate(c_void); 549 550 pub type GtkSourceLanguageManagerPrivate = *mut _GtkSourceLanguageManagerPrivate; 551 552 #[repr(C)] 553 pub struct _GtkSourceLanguagePrivate(c_void); 554 555 pub type GtkSourceLanguagePrivate = *mut _GtkSourceLanguagePrivate; 556 557 #[repr(C)] 558 #[derive(Copy, Clone)] 559 pub struct GtkSourceMapClass { 560 pub parent_class: GtkSourceViewClass, 561 pub padding: [gpointer; 10], 562 } 563 564 impl ::std::fmt::Debug for GtkSourceMapClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result565 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 566 f.debug_struct(&format!("GtkSourceMapClass @ {:?}", self as *const _)) 567 .field("parent_class", &self.parent_class) 568 .field("padding", &self.padding) 569 .finish() 570 } 571 } 572 573 #[repr(C)] 574 #[derive(Copy, Clone)] 575 pub struct GtkSourceMarkAttributesClass { 576 pub parent_class: gobject::GObjectClass, 577 pub padding: [gpointer; 10], 578 } 579 580 impl ::std::fmt::Debug for GtkSourceMarkAttributesClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result581 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 582 f.debug_struct(&format!("GtkSourceMarkAttributesClass @ {:?}", self as *const _)) 583 .finish() 584 } 585 } 586 587 #[repr(C)] 588 pub struct _GtkSourceMarkAttributesPrivate(c_void); 589 590 pub type GtkSourceMarkAttributesPrivate = *mut _GtkSourceMarkAttributesPrivate; 591 592 #[repr(C)] 593 #[derive(Copy, Clone)] 594 pub struct GtkSourceMarkClass { 595 pub parent_class: gtk::GtkTextMarkClass, 596 pub padding: [gpointer; 10], 597 } 598 599 impl ::std::fmt::Debug for GtkSourceMarkClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result600 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 601 f.debug_struct(&format!("GtkSourceMarkClass @ {:?}", self as *const _)) 602 .field("parent_class", &self.parent_class) 603 .field("padding", &self.padding) 604 .finish() 605 } 606 } 607 608 #[repr(C)] 609 pub struct _GtkSourceMarkPrivate(c_void); 610 611 pub type GtkSourceMarkPrivate = *mut _GtkSourceMarkPrivate; 612 613 #[repr(C)] 614 #[derive(Copy, Clone)] 615 pub struct GtkSourcePrintCompositorClass { 616 pub parent_class: gobject::GObjectClass, 617 pub padding: [gpointer; 10], 618 } 619 620 impl ::std::fmt::Debug for GtkSourcePrintCompositorClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result621 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 622 f.debug_struct(&format!("GtkSourcePrintCompositorClass @ {:?}", self as *const _)) 623 .field("parent_class", &self.parent_class) 624 .field("padding", &self.padding) 625 .finish() 626 } 627 } 628 629 #[repr(C)] 630 pub struct _GtkSourcePrintCompositorPrivate(c_void); 631 632 pub type GtkSourcePrintCompositorPrivate = *mut _GtkSourcePrintCompositorPrivate; 633 634 #[repr(C)] 635 #[derive(Copy, Clone)] 636 pub struct GtkSourceRegionClass { 637 pub parent_class: gobject::GObjectClass, 638 pub padding: [gpointer; 10], 639 } 640 641 impl ::std::fmt::Debug for GtkSourceRegionClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result642 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 643 f.debug_struct(&format!("GtkSourceRegionClass @ {:?}", self as *const _)) 644 .field("parent_class", &self.parent_class) 645 .field("padding", &self.padding) 646 .finish() 647 } 648 } 649 650 #[repr(C)] 651 #[derive(Copy, Clone)] 652 pub struct GtkSourceRegionIter { 653 pub dummy1: gpointer, 654 pub dummy2: u32, 655 pub dummy3: gpointer, 656 } 657 658 impl ::std::fmt::Debug for GtkSourceRegionIter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result659 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 660 f.debug_struct(&format!("GtkSourceRegionIter @ {:?}", self as *const _)) 661 .finish() 662 } 663 } 664 665 #[repr(C)] 666 #[derive(Copy, Clone)] 667 pub struct GtkSourceSearchContextClass { 668 pub parent_class: gobject::GObjectClass, 669 pub padding: [gpointer; 10], 670 } 671 672 impl ::std::fmt::Debug for GtkSourceSearchContextClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result673 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 674 f.debug_struct(&format!("GtkSourceSearchContextClass @ {:?}", self as *const _)) 675 .field("parent_class", &self.parent_class) 676 .field("padding", &self.padding) 677 .finish() 678 } 679 } 680 681 #[repr(C)] 682 pub struct _GtkSourceSearchContextPrivate(c_void); 683 684 pub type GtkSourceSearchContextPrivate = *mut _GtkSourceSearchContextPrivate; 685 686 #[repr(C)] 687 #[derive(Copy, Clone)] 688 pub struct GtkSourceSearchSettingsClass { 689 pub parent_class: gobject::GObjectClass, 690 pub padding: [gpointer; 10], 691 } 692 693 impl ::std::fmt::Debug for GtkSourceSearchSettingsClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result694 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 695 f.debug_struct(&format!("GtkSourceSearchSettingsClass @ {:?}", self as *const _)) 696 .field("parent_class", &self.parent_class) 697 .field("padding", &self.padding) 698 .finish() 699 } 700 } 701 702 #[repr(C)] 703 pub struct _GtkSourceSearchSettingsPrivate(c_void); 704 705 pub type GtkSourceSearchSettingsPrivate = *mut _GtkSourceSearchSettingsPrivate; 706 707 #[repr(C)] 708 #[derive(Copy, Clone)] 709 pub struct GtkSourceSpaceDrawerClass { 710 pub parent_class: gobject::GObjectClass, 711 pub padding: [gpointer; 20], 712 } 713 714 impl ::std::fmt::Debug for GtkSourceSpaceDrawerClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result715 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 716 f.debug_struct(&format!("GtkSourceSpaceDrawerClass @ {:?}", self as *const _)) 717 .field("parent_class", &self.parent_class) 718 .field("padding", &self.padding) 719 .finish() 720 } 721 } 722 723 #[repr(C)] 724 pub struct _GtkSourceSpaceDrawerPrivate(c_void); 725 726 pub type GtkSourceSpaceDrawerPrivate = *mut _GtkSourceSpaceDrawerPrivate; 727 728 #[repr(C)] 729 pub struct _GtkSourceStyleClass(c_void); 730 731 pub type GtkSourceStyleClass = *mut _GtkSourceStyleClass; 732 733 #[repr(C)] 734 #[derive(Copy, Clone)] 735 pub struct GtkSourceStyleSchemeChooserButtonClass { 736 pub parent: gtk::GtkButtonClass, 737 pub padding: [gpointer; 10], 738 } 739 740 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButtonClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result741 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 742 f.debug_struct(&format!("GtkSourceStyleSchemeChooserButtonClass @ {:?}", self as *const _)) 743 .field("parent", &self.parent) 744 .field("padding", &self.padding) 745 .finish() 746 } 747 } 748 749 #[repr(C)] 750 #[derive(Copy, Clone)] 751 pub struct GtkSourceStyleSchemeChooserInterface { 752 pub base_interface: gobject::GTypeInterface, 753 pub get_style_scheme: Option<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser) -> *mut GtkSourceStyleScheme>, 754 pub set_style_scheme: Option<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser, *mut GtkSourceStyleScheme)>, 755 pub padding: [gpointer; 12], 756 } 757 758 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserInterface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result759 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 760 f.debug_struct(&format!("GtkSourceStyleSchemeChooserInterface @ {:?}", self as *const _)) 761 .field("base_interface", &self.base_interface) 762 .field("get_style_scheme", &self.get_style_scheme) 763 .field("set_style_scheme", &self.set_style_scheme) 764 .field("padding", &self.padding) 765 .finish() 766 } 767 } 768 769 #[repr(C)] 770 #[derive(Copy, Clone)] 771 pub struct GtkSourceStyleSchemeChooserWidgetClass { 772 pub parent: gtk::GtkBinClass, 773 pub padding: [gpointer; 10], 774 } 775 776 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidgetClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result777 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 778 f.debug_struct(&format!("GtkSourceStyleSchemeChooserWidgetClass @ {:?}", self as *const _)) 779 .field("parent", &self.parent) 780 .field("padding", &self.padding) 781 .finish() 782 } 783 } 784 785 #[repr(C)] 786 #[derive(Copy, Clone)] 787 pub struct GtkSourceStyleSchemeClass { 788 pub base_class: gobject::GObjectClass, 789 pub padding: [gpointer; 10], 790 } 791 792 impl ::std::fmt::Debug for GtkSourceStyleSchemeClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result793 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 794 f.debug_struct(&format!("GtkSourceStyleSchemeClass @ {:?}", self as *const _)) 795 .field("base_class", &self.base_class) 796 .field("padding", &self.padding) 797 .finish() 798 } 799 } 800 801 #[repr(C)] 802 #[derive(Copy, Clone)] 803 pub struct GtkSourceStyleSchemeManagerClass { 804 pub parent_class: gobject::GObjectClass, 805 pub padding: [gpointer; 10], 806 } 807 808 impl ::std::fmt::Debug for GtkSourceStyleSchemeManagerClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result809 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 810 f.debug_struct(&format!("GtkSourceStyleSchemeManagerClass @ {:?}", self as *const _)) 811 .field("parent_class", &self.parent_class) 812 .field("padding", &self.padding) 813 .finish() 814 } 815 } 816 817 #[repr(C)] 818 pub struct _GtkSourceStyleSchemeManagerPrivate(c_void); 819 820 pub type GtkSourceStyleSchemeManagerPrivate = *mut _GtkSourceStyleSchemeManagerPrivate; 821 822 #[repr(C)] 823 pub struct _GtkSourceStyleSchemePrivate(c_void); 824 825 pub type GtkSourceStyleSchemePrivate = *mut _GtkSourceStyleSchemePrivate; 826 827 #[repr(C)] 828 #[derive(Copy, Clone)] 829 pub struct GtkSourceTagClass { 830 pub parent_class: gtk::GtkTextTagClass, 831 pub padding: [gpointer; 10], 832 } 833 834 impl ::std::fmt::Debug for GtkSourceTagClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result835 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 836 f.debug_struct(&format!("GtkSourceTagClass @ {:?}", self as *const _)) 837 .field("parent_class", &self.parent_class) 838 .field("padding", &self.padding) 839 .finish() 840 } 841 } 842 843 #[repr(C)] 844 #[derive(Copy, Clone)] 845 pub struct GtkSourceUndoManagerIface { 846 pub parent: gobject::GTypeInterface, 847 pub can_undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>, 848 pub can_redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>, 849 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 850 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 851 pub begin_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 852 pub end_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 853 pub can_undo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 854 pub can_redo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>, 855 } 856 857 impl ::std::fmt::Debug for GtkSourceUndoManagerIface { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result858 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 859 f.debug_struct(&format!("GtkSourceUndoManagerIface @ {:?}", self as *const _)) 860 .field("parent", &self.parent) 861 .field("can_undo", &self.can_undo) 862 .field("can_redo", &self.can_redo) 863 .field("undo", &self.undo) 864 .field("redo", &self.redo) 865 .field("begin_not_undoable_action", &self.begin_not_undoable_action) 866 .field("end_not_undoable_action", &self.end_not_undoable_action) 867 .field("can_undo_changed", &self.can_undo_changed) 868 .field("can_redo_changed", &self.can_redo_changed) 869 .finish() 870 } 871 } 872 873 #[repr(C)] 874 #[derive(Copy, Clone)] 875 pub struct GtkSourceViewClass { 876 pub parent_class: gtk::GtkTextViewClass, 877 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceView)>, 878 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceView)>, 879 pub line_mark_activated: Option<unsafe extern "C" fn(*mut GtkSourceView, *mut gtk::GtkTextIter, *mut gdk::GdkEvent)>, 880 pub show_completion: Option<unsafe extern "C" fn(*mut GtkSourceView)>, 881 pub move_lines: Option<unsafe extern "C" fn(*mut GtkSourceView, gboolean)>, 882 pub move_words: Option<unsafe extern "C" fn(*mut GtkSourceView, c_int)>, 883 pub padding: [gpointer; 20], 884 } 885 886 impl ::std::fmt::Debug for GtkSourceViewClass { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result887 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 888 f.debug_struct(&format!("GtkSourceViewClass @ {:?}", self as *const _)) 889 .field("parent_class", &self.parent_class) 890 .field("undo", &self.undo) 891 .field("redo", &self.redo) 892 .field("line_mark_activated", &self.line_mark_activated) 893 .field("show_completion", &self.show_completion) 894 .field("move_lines", &self.move_lines) 895 .field("move_words", &self.move_words) 896 .field("padding", &self.padding) 897 .finish() 898 } 899 } 900 901 #[repr(C)] 902 pub struct _GtkSourceViewPrivate(c_void); 903 904 pub type GtkSourceViewPrivate = *mut _GtkSourceViewPrivate; 905 906 // Classes 907 #[repr(C)] 908 #[derive(Copy, Clone)] 909 pub struct GtkSourceBuffer { 910 pub parent_instance: gtk::GtkTextBuffer, 911 pub priv_: *mut GtkSourceBufferPrivate, 912 } 913 914 impl ::std::fmt::Debug for GtkSourceBuffer { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result915 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 916 f.debug_struct(&format!("GtkSourceBuffer @ {:?}", self as *const _)) 917 .field("parent_instance", &self.parent_instance) 918 .field("priv_", &self.priv_) 919 .finish() 920 } 921 } 922 923 #[repr(C)] 924 #[derive(Copy, Clone)] 925 pub struct GtkSourceCompletion { 926 pub parent_instance: gobject::GObject, 927 pub priv_: *mut GtkSourceCompletionPrivate, 928 } 929 930 impl ::std::fmt::Debug for GtkSourceCompletion { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result931 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 932 f.debug_struct(&format!("GtkSourceCompletion @ {:?}", self as *const _)) 933 .field("parent_instance", &self.parent_instance) 934 .field("priv_", &self.priv_) 935 .finish() 936 } 937 } 938 939 #[repr(C)] 940 #[derive(Copy, Clone)] 941 pub struct GtkSourceCompletionContext { 942 pub parent: gobject::GInitiallyUnowned, 943 pub priv_: *mut GtkSourceCompletionContextPrivate, 944 } 945 946 impl ::std::fmt::Debug for GtkSourceCompletionContext { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result947 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 948 f.debug_struct(&format!("GtkSourceCompletionContext @ {:?}", self as *const _)) 949 .field("parent", &self.parent) 950 .field("priv_", &self.priv_) 951 .finish() 952 } 953 } 954 955 #[repr(C)] 956 #[derive(Copy, Clone)] 957 pub struct GtkSourceCompletionInfo { 958 pub parent: gtk::GtkWindow, 959 pub priv_: *mut GtkSourceCompletionInfoPrivate, 960 } 961 962 impl ::std::fmt::Debug for GtkSourceCompletionInfo { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result963 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 964 f.debug_struct(&format!("GtkSourceCompletionInfo @ {:?}", self as *const _)) 965 .field("parent", &self.parent) 966 .field("priv_", &self.priv_) 967 .finish() 968 } 969 } 970 971 #[repr(C)] 972 #[derive(Copy, Clone)] 973 pub struct GtkSourceCompletionItem { 974 pub parent: gobject::GObject, 975 pub priv_: *mut GtkSourceCompletionItemPrivate, 976 } 977 978 impl ::std::fmt::Debug for GtkSourceCompletionItem { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result979 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 980 f.debug_struct(&format!("GtkSourceCompletionItem @ {:?}", self as *const _)) 981 .field("parent", &self.parent) 982 .field("priv_", &self.priv_) 983 .finish() 984 } 985 } 986 987 #[repr(C)] 988 #[derive(Copy, Clone)] 989 pub struct GtkSourceCompletionWords { 990 pub parent: gobject::GObject, 991 pub priv_: *mut GtkSourceCompletionWordsPrivate, 992 } 993 994 impl ::std::fmt::Debug for GtkSourceCompletionWords { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result995 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 996 f.debug_struct(&format!("GtkSourceCompletionWords @ {:?}", self as *const _)) 997 .field("parent", &self.parent) 998 .field("priv_", &self.priv_) 999 .finish() 1000 } 1001 } 1002 1003 #[repr(C)] 1004 #[derive(Copy, Clone)] 1005 pub struct GtkSourceFile { 1006 pub parent: gobject::GObject, 1007 pub priv_: *mut GtkSourceFilePrivate, 1008 } 1009 1010 impl ::std::fmt::Debug for GtkSourceFile { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1011 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1012 f.debug_struct(&format!("GtkSourceFile @ {:?}", self as *const _)) 1013 .field("parent", &self.parent) 1014 .field("priv_", &self.priv_) 1015 .finish() 1016 } 1017 } 1018 1019 #[repr(C)] 1020 #[derive(Copy, Clone)] 1021 pub struct GtkSourceFileLoader { 1022 pub parent: gobject::GObject, 1023 pub priv_: *mut GtkSourceFileLoaderPrivate, 1024 } 1025 1026 impl ::std::fmt::Debug for GtkSourceFileLoader { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1027 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1028 f.debug_struct(&format!("GtkSourceFileLoader @ {:?}", self as *const _)) 1029 .field("parent", &self.parent) 1030 .field("priv_", &self.priv_) 1031 .finish() 1032 } 1033 } 1034 1035 #[repr(C)] 1036 #[derive(Copy, Clone)] 1037 pub struct GtkSourceFileSaver { 1038 pub object: gobject::GObject, 1039 pub priv_: *mut GtkSourceFileSaverPrivate, 1040 } 1041 1042 impl ::std::fmt::Debug for GtkSourceFileSaver { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1043 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1044 f.debug_struct(&format!("GtkSourceFileSaver @ {:?}", self as *const _)) 1045 .field("object", &self.object) 1046 .field("priv_", &self.priv_) 1047 .finish() 1048 } 1049 } 1050 1051 #[repr(C)] 1052 #[derive(Copy, Clone)] 1053 pub struct GtkSourceGutter { 1054 pub parent: gobject::GObject, 1055 pub priv_: *mut GtkSourceGutterPrivate, 1056 } 1057 1058 impl ::std::fmt::Debug for GtkSourceGutter { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1059 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1060 f.debug_struct(&format!("GtkSourceGutter @ {:?}", self as *const _)) 1061 .field("parent", &self.parent) 1062 .field("priv_", &self.priv_) 1063 .finish() 1064 } 1065 } 1066 1067 #[repr(C)] 1068 #[derive(Copy, Clone)] 1069 pub struct GtkSourceGutterRenderer { 1070 pub parent: gobject::GInitiallyUnowned, 1071 pub priv_: *mut GtkSourceGutterRendererPrivate, 1072 } 1073 1074 impl ::std::fmt::Debug for GtkSourceGutterRenderer { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1075 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1076 f.debug_struct(&format!("GtkSourceGutterRenderer @ {:?}", self as *const _)) 1077 .field("parent", &self.parent) 1078 .finish() 1079 } 1080 } 1081 1082 #[repr(C)] 1083 #[derive(Copy, Clone)] 1084 pub struct GtkSourceGutterRendererPixbuf { 1085 pub parent: GtkSourceGutterRenderer, 1086 pub priv_: *mut GtkSourceGutterRendererPixbufPrivate, 1087 } 1088 1089 impl ::std::fmt::Debug for GtkSourceGutterRendererPixbuf { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1090 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1091 f.debug_struct(&format!("GtkSourceGutterRendererPixbuf @ {:?}", self as *const _)) 1092 .finish() 1093 } 1094 } 1095 1096 #[repr(C)] 1097 #[derive(Copy, Clone)] 1098 pub struct GtkSourceGutterRendererText { 1099 pub parent: GtkSourceGutterRenderer, 1100 pub priv_: *mut GtkSourceGutterRendererTextPrivate, 1101 } 1102 1103 impl ::std::fmt::Debug for GtkSourceGutterRendererText { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1104 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1105 f.debug_struct(&format!("GtkSourceGutterRendererText @ {:?}", self as *const _)) 1106 .finish() 1107 } 1108 } 1109 1110 #[repr(C)] 1111 #[derive(Copy, Clone)] 1112 pub struct GtkSourceLanguage { 1113 pub parent_instance: gobject::GObject, 1114 pub priv_: *mut GtkSourceLanguagePrivate, 1115 } 1116 1117 impl ::std::fmt::Debug for GtkSourceLanguage { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1118 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1119 f.debug_struct(&format!("GtkSourceLanguage @ {:?}", self as *const _)) 1120 .field("parent_instance", &self.parent_instance) 1121 .field("priv_", &self.priv_) 1122 .finish() 1123 } 1124 } 1125 1126 #[repr(C)] 1127 #[derive(Copy, Clone)] 1128 pub struct GtkSourceLanguageManager { 1129 pub parent_instance: gobject::GObject, 1130 pub priv_: *mut GtkSourceLanguageManagerPrivate, 1131 } 1132 1133 impl ::std::fmt::Debug for GtkSourceLanguageManager { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1134 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1135 f.debug_struct(&format!("GtkSourceLanguageManager @ {:?}", self as *const _)) 1136 .field("parent_instance", &self.parent_instance) 1137 .field("priv_", &self.priv_) 1138 .finish() 1139 } 1140 } 1141 1142 #[repr(C)] 1143 #[derive(Copy, Clone)] 1144 pub struct GtkSourceMap { 1145 pub parent_instance: GtkSourceView, 1146 } 1147 1148 impl ::std::fmt::Debug for GtkSourceMap { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1149 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1150 f.debug_struct(&format!("GtkSourceMap @ {:?}", self as *const _)) 1151 .field("parent_instance", &self.parent_instance) 1152 .finish() 1153 } 1154 } 1155 1156 #[repr(C)] 1157 #[derive(Copy, Clone)] 1158 pub struct GtkSourceMark { 1159 pub parent_instance: gtk::GtkTextMark, 1160 pub priv_: *mut GtkSourceMarkPrivate, 1161 } 1162 1163 impl ::std::fmt::Debug for GtkSourceMark { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1164 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1165 f.debug_struct(&format!("GtkSourceMark @ {:?}", self as *const _)) 1166 .field("parent_instance", &self.parent_instance) 1167 .field("priv_", &self.priv_) 1168 .finish() 1169 } 1170 } 1171 1172 #[repr(C)] 1173 #[derive(Copy, Clone)] 1174 pub struct GtkSourceMarkAttributes { 1175 pub parent: gobject::GObject, 1176 pub priv_: *mut GtkSourceMarkAttributesPrivate, 1177 } 1178 1179 impl ::std::fmt::Debug for GtkSourceMarkAttributes { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1180 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1181 f.debug_struct(&format!("GtkSourceMarkAttributes @ {:?}", self as *const _)) 1182 .finish() 1183 } 1184 } 1185 1186 #[repr(C)] 1187 #[derive(Copy, Clone)] 1188 pub struct GtkSourcePrintCompositor { 1189 pub parent_instance: gobject::GObject, 1190 pub priv_: *mut GtkSourcePrintCompositorPrivate, 1191 } 1192 1193 impl ::std::fmt::Debug for GtkSourcePrintCompositor { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1194 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1195 f.debug_struct(&format!("GtkSourcePrintCompositor @ {:?}", self as *const _)) 1196 .field("parent_instance", &self.parent_instance) 1197 .field("priv_", &self.priv_) 1198 .finish() 1199 } 1200 } 1201 1202 #[repr(C)] 1203 #[derive(Copy, Clone)] 1204 pub struct GtkSourceRegion { 1205 pub parent_instance: gobject::GObject, 1206 } 1207 1208 impl ::std::fmt::Debug for GtkSourceRegion { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1209 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1210 f.debug_struct(&format!("GtkSourceRegion @ {:?}", self as *const _)) 1211 .field("parent_instance", &self.parent_instance) 1212 .finish() 1213 } 1214 } 1215 1216 #[repr(C)] 1217 #[derive(Copy, Clone)] 1218 pub struct GtkSourceSearchContext { 1219 pub parent: gobject::GObject, 1220 pub priv_: *mut GtkSourceSearchContextPrivate, 1221 } 1222 1223 impl ::std::fmt::Debug for GtkSourceSearchContext { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1224 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1225 f.debug_struct(&format!("GtkSourceSearchContext @ {:?}", self as *const _)) 1226 .field("parent", &self.parent) 1227 .field("priv_", &self.priv_) 1228 .finish() 1229 } 1230 } 1231 1232 #[repr(C)] 1233 #[derive(Copy, Clone)] 1234 pub struct GtkSourceSearchSettings { 1235 pub parent: gobject::GObject, 1236 pub priv_: *mut GtkSourceSearchSettingsPrivate, 1237 } 1238 1239 impl ::std::fmt::Debug for GtkSourceSearchSettings { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1240 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1241 f.debug_struct(&format!("GtkSourceSearchSettings @ {:?}", self as *const _)) 1242 .field("parent", &self.parent) 1243 .field("priv_", &self.priv_) 1244 .finish() 1245 } 1246 } 1247 1248 #[repr(C)] 1249 #[derive(Copy, Clone)] 1250 pub struct GtkSourceSpaceDrawer { 1251 pub parent: gobject::GObject, 1252 pub priv_: *mut GtkSourceSpaceDrawerPrivate, 1253 } 1254 1255 impl ::std::fmt::Debug for GtkSourceSpaceDrawer { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1256 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1257 f.debug_struct(&format!("GtkSourceSpaceDrawer @ {:?}", self as *const _)) 1258 .field("parent", &self.parent) 1259 .field("priv_", &self.priv_) 1260 .finish() 1261 } 1262 } 1263 1264 #[repr(C)] 1265 pub struct GtkSourceStyle(c_void); 1266 1267 impl ::std::fmt::Debug for GtkSourceStyle { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1268 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1269 f.debug_struct(&format!("GtkSourceStyle @ {:?}", self as *const _)) 1270 .finish() 1271 } 1272 } 1273 1274 #[repr(C)] 1275 #[derive(Copy, Clone)] 1276 pub struct GtkSourceStyleScheme { 1277 pub base: gobject::GObject, 1278 pub priv_: *mut GtkSourceStyleSchemePrivate, 1279 } 1280 1281 impl ::std::fmt::Debug for GtkSourceStyleScheme { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1282 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1283 f.debug_struct(&format!("GtkSourceStyleScheme @ {:?}", self as *const _)) 1284 .field("base", &self.base) 1285 .field("priv_", &self.priv_) 1286 .finish() 1287 } 1288 } 1289 1290 #[repr(C)] 1291 #[derive(Copy, Clone)] 1292 pub struct GtkSourceStyleSchemeChooserButton { 1293 pub parent: gtk::GtkButton, 1294 } 1295 1296 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButton { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1297 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1298 f.debug_struct(&format!("GtkSourceStyleSchemeChooserButton @ {:?}", self as *const _)) 1299 .field("parent", &self.parent) 1300 .finish() 1301 } 1302 } 1303 1304 #[repr(C)] 1305 #[derive(Copy, Clone)] 1306 pub struct GtkSourceStyleSchemeChooserWidget { 1307 pub parent: gtk::GtkBin, 1308 } 1309 1310 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidget { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1311 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1312 f.debug_struct(&format!("GtkSourceStyleSchemeChooserWidget @ {:?}", self as *const _)) 1313 .field("parent", &self.parent) 1314 .finish() 1315 } 1316 } 1317 1318 #[repr(C)] 1319 #[derive(Copy, Clone)] 1320 pub struct GtkSourceStyleSchemeManager { 1321 pub parent: gobject::GObject, 1322 pub priv_: *mut GtkSourceStyleSchemeManagerPrivate, 1323 } 1324 1325 impl ::std::fmt::Debug for GtkSourceStyleSchemeManager { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1326 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1327 f.debug_struct(&format!("GtkSourceStyleSchemeManager @ {:?}", self as *const _)) 1328 .field("parent", &self.parent) 1329 .field("priv_", &self.priv_) 1330 .finish() 1331 } 1332 } 1333 1334 #[repr(C)] 1335 #[derive(Copy, Clone)] 1336 pub struct GtkSourceTag { 1337 pub parent_instance: gtk::GtkTextTag, 1338 } 1339 1340 impl ::std::fmt::Debug for GtkSourceTag { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1341 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1342 f.debug_struct(&format!("GtkSourceTag @ {:?}", self as *const _)) 1343 .field("parent_instance", &self.parent_instance) 1344 .finish() 1345 } 1346 } 1347 1348 #[repr(C)] 1349 #[derive(Copy, Clone)] 1350 pub struct GtkSourceView { 1351 pub parent: gtk::GtkTextView, 1352 pub priv_: *mut GtkSourceViewPrivate, 1353 } 1354 1355 impl ::std::fmt::Debug for GtkSourceView { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1356 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1357 f.debug_struct(&format!("GtkSourceView @ {:?}", self as *const _)) 1358 .field("parent", &self.parent) 1359 .field("priv_", &self.priv_) 1360 .finish() 1361 } 1362 } 1363 1364 // Interfaces 1365 #[repr(C)] 1366 pub struct GtkSourceCompletionProposal(c_void); 1367 1368 impl ::std::fmt::Debug for GtkSourceCompletionProposal { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1369 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1370 write!(f, "GtkSourceCompletionProposal @ {:?}", self as *const _) 1371 } 1372 } 1373 1374 #[repr(C)] 1375 pub struct GtkSourceCompletionProvider(c_void); 1376 1377 impl ::std::fmt::Debug for GtkSourceCompletionProvider { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1378 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1379 write!(f, "GtkSourceCompletionProvider @ {:?}", self as *const _) 1380 } 1381 } 1382 1383 #[repr(C)] 1384 pub struct GtkSourceStyleSchemeChooser(c_void); 1385 1386 impl ::std::fmt::Debug for GtkSourceStyleSchemeChooser { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1387 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1388 write!(f, "GtkSourceStyleSchemeChooser @ {:?}", self as *const _) 1389 } 1390 } 1391 1392 #[repr(C)] 1393 pub struct GtkSourceUndoManager(c_void); 1394 1395 impl ::std::fmt::Debug for GtkSourceUndoManager { fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result1396 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result { 1397 write!(f, "GtkSourceUndoManager @ {:?}", self as *const _) 1398 } 1399 } 1400 1401 1402 extern "C" { 1403 1404 //========================================================================= 1405 // GtkSourceBackgroundPatternType 1406 //========================================================================= gtk_source_background_pattern_type_get_type() -> GType1407 pub fn gtk_source_background_pattern_type_get_type() -> GType; 1408 1409 //========================================================================= 1410 // GtkSourceBracketMatchType 1411 //========================================================================= gtk_source_bracket_match_type_get_type() -> GType1412 pub fn gtk_source_bracket_match_type_get_type() -> GType; 1413 1414 //========================================================================= 1415 // GtkSourceChangeCaseType 1416 //========================================================================= gtk_source_change_case_type_get_type() -> GType1417 pub fn gtk_source_change_case_type_get_type() -> GType; 1418 1419 //========================================================================= 1420 // GtkSourceCompletionError 1421 //========================================================================= gtk_source_completion_error_get_type() -> GType1422 pub fn gtk_source_completion_error_get_type() -> GType; gtk_source_completion_error_quark() -> glib::GQuark1423 pub fn gtk_source_completion_error_quark() -> glib::GQuark; 1424 1425 //========================================================================= 1426 // GtkSourceCompressionType 1427 //========================================================================= gtk_source_compression_type_get_type() -> GType1428 pub fn gtk_source_compression_type_get_type() -> GType; 1429 1430 //========================================================================= 1431 // GtkSourceFileLoaderError 1432 //========================================================================= gtk_source_file_loader_error_get_type() -> GType1433 pub fn gtk_source_file_loader_error_get_type() -> GType; gtk_source_file_loader_error_quark() -> glib::GQuark1434 pub fn gtk_source_file_loader_error_quark() -> glib::GQuark; 1435 1436 //========================================================================= 1437 // GtkSourceFileSaverError 1438 //========================================================================= gtk_source_file_saver_error_get_type() -> GType1439 pub fn gtk_source_file_saver_error_get_type() -> GType; gtk_source_file_saver_error_quark() -> glib::GQuark1440 pub fn gtk_source_file_saver_error_quark() -> glib::GQuark; 1441 1442 //========================================================================= 1443 // GtkSourceGutterRendererAlignmentMode 1444 //========================================================================= gtk_source_gutter_renderer_alignment_mode_get_type() -> GType1445 pub fn gtk_source_gutter_renderer_alignment_mode_get_type() -> GType; 1446 1447 //========================================================================= 1448 // GtkSourceNewlineType 1449 //========================================================================= gtk_source_newline_type_get_type() -> GType1450 pub fn gtk_source_newline_type_get_type() -> GType; 1451 1452 //========================================================================= 1453 // GtkSourceSmartHomeEndType 1454 //========================================================================= gtk_source_smart_home_end_type_get_type() -> GType1455 pub fn gtk_source_smart_home_end_type_get_type() -> GType; 1456 1457 //========================================================================= 1458 // GtkSourceViewGutterPosition 1459 //========================================================================= gtk_source_view_gutter_position_get_type() -> GType1460 pub fn gtk_source_view_gutter_position_get_type() -> GType; 1461 1462 //========================================================================= 1463 // GtkSourceCompletionActivation 1464 //========================================================================= gtk_source_completion_activation_get_type() -> GType1465 pub fn gtk_source_completion_activation_get_type() -> GType; 1466 1467 //========================================================================= 1468 // GtkSourceFileSaverFlags 1469 //========================================================================= gtk_source_file_saver_flags_get_type() -> GType1470 pub fn gtk_source_file_saver_flags_get_type() -> GType; 1471 1472 //========================================================================= 1473 // GtkSourceGutterRendererState 1474 //========================================================================= gtk_source_gutter_renderer_state_get_type() -> GType1475 pub fn gtk_source_gutter_renderer_state_get_type() -> GType; 1476 1477 //========================================================================= 1478 // GtkSourceSortFlags 1479 //========================================================================= gtk_source_sort_flags_get_type() -> GType1480 pub fn gtk_source_sort_flags_get_type() -> GType; 1481 1482 //========================================================================= 1483 // GtkSourceSpaceLocationFlags 1484 //========================================================================= gtk_source_space_location_flags_get_type() -> GType1485 pub fn gtk_source_space_location_flags_get_type() -> GType; 1486 1487 //========================================================================= 1488 // GtkSourceSpaceTypeFlags 1489 //========================================================================= gtk_source_space_type_flags_get_type() -> GType1490 pub fn gtk_source_space_type_flags_get_type() -> GType; 1491 1492 //========================================================================= 1493 // GtkSourceEncoding 1494 //========================================================================= gtk_source_encoding_get_type() -> GType1495 pub fn gtk_source_encoding_get_type() -> GType; gtk_source_encoding_copy(enc: *const GtkSourceEncoding) -> *mut GtkSourceEncoding1496 pub fn gtk_source_encoding_copy(enc: *const GtkSourceEncoding) -> *mut GtkSourceEncoding; gtk_source_encoding_free(enc: *mut GtkSourceEncoding)1497 pub fn gtk_source_encoding_free(enc: *mut GtkSourceEncoding); gtk_source_encoding_get_charset(enc: *const GtkSourceEncoding) -> *const c_char1498 pub fn gtk_source_encoding_get_charset(enc: *const GtkSourceEncoding) -> *const c_char; gtk_source_encoding_get_name(enc: *const GtkSourceEncoding) -> *const c_char1499 pub fn gtk_source_encoding_get_name(enc: *const GtkSourceEncoding) -> *const c_char; gtk_source_encoding_to_string(enc: *const GtkSourceEncoding) -> *mut c_char1500 pub fn gtk_source_encoding_to_string(enc: *const GtkSourceEncoding) -> *mut c_char; gtk_source_encoding_get_all() -> *mut glib::GSList1501 pub fn gtk_source_encoding_get_all() -> *mut glib::GSList; gtk_source_encoding_get_current() -> *const GtkSourceEncoding1502 pub fn gtk_source_encoding_get_current() -> *const GtkSourceEncoding; gtk_source_encoding_get_default_candidates() -> *mut glib::GSList1503 pub fn gtk_source_encoding_get_default_candidates() -> *mut glib::GSList; gtk_source_encoding_get_from_charset(charset: *const c_char) -> *const GtkSourceEncoding1504 pub fn gtk_source_encoding_get_from_charset(charset: *const c_char) -> *const GtkSourceEncoding; gtk_source_encoding_get_utf8() -> *const GtkSourceEncoding1505 pub fn gtk_source_encoding_get_utf8() -> *const GtkSourceEncoding; 1506 1507 //========================================================================= 1508 // GtkSourceRegionIter 1509 //========================================================================= gtk_source_region_iter_get_subregion(iter: *mut GtkSourceRegionIter, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter) -> gboolean1510 pub fn gtk_source_region_iter_get_subregion(iter: *mut GtkSourceRegionIter, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter) -> gboolean; gtk_source_region_iter_is_end(iter: *mut GtkSourceRegionIter) -> gboolean1511 pub fn gtk_source_region_iter_is_end(iter: *mut GtkSourceRegionIter) -> gboolean; gtk_source_region_iter_next(iter: *mut GtkSourceRegionIter) -> gboolean1512 pub fn gtk_source_region_iter_next(iter: *mut GtkSourceRegionIter) -> gboolean; 1513 1514 //========================================================================= 1515 // GtkSourceBuffer 1516 //========================================================================= gtk_source_buffer_get_type() -> GType1517 pub fn gtk_source_buffer_get_type() -> GType; gtk_source_buffer_new(table: *mut gtk::GtkTextTagTable) -> *mut GtkSourceBuffer1518 pub fn gtk_source_buffer_new(table: *mut gtk::GtkTextTagTable) -> *mut GtkSourceBuffer; gtk_source_buffer_new_with_language(language: *mut GtkSourceLanguage) -> *mut GtkSourceBuffer1519 pub fn gtk_source_buffer_new_with_language(language: *mut GtkSourceLanguage) -> *mut GtkSourceBuffer; gtk_source_buffer_backward_iter_to_source_mark(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> gboolean1520 pub fn gtk_source_buffer_backward_iter_to_source_mark(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> gboolean; gtk_source_buffer_begin_not_undoable_action(buffer: *mut GtkSourceBuffer)1521 pub fn gtk_source_buffer_begin_not_undoable_action(buffer: *mut GtkSourceBuffer); gtk_source_buffer_can_redo(buffer: *mut GtkSourceBuffer) -> gboolean1522 pub fn gtk_source_buffer_can_redo(buffer: *mut GtkSourceBuffer) -> gboolean; gtk_source_buffer_can_undo(buffer: *mut GtkSourceBuffer) -> gboolean1523 pub fn gtk_source_buffer_can_undo(buffer: *mut GtkSourceBuffer) -> gboolean; gtk_source_buffer_change_case(buffer: *mut GtkSourceBuffer, case_type: GtkSourceChangeCaseType, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter)1524 pub fn gtk_source_buffer_change_case(buffer: *mut GtkSourceBuffer, case_type: GtkSourceChangeCaseType, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter); gtk_source_buffer_create_source_mark(buffer: *mut GtkSourceBuffer, name: *const c_char, category: *const c_char, where_: *const gtk::GtkTextIter) -> *mut GtkSourceMark1525 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; gtk_source_buffer_create_source_tag(buffer: *mut GtkSourceBuffer, tag_name: *const c_char, first_property_name: *const c_char, ...) -> *mut gtk::GtkTextTag1526 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; gtk_source_buffer_end_not_undoable_action(buffer: *mut GtkSourceBuffer)1527 pub fn gtk_source_buffer_end_not_undoable_action(buffer: *mut GtkSourceBuffer); gtk_source_buffer_ensure_highlight(buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter)1528 pub fn gtk_source_buffer_ensure_highlight(buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter); gtk_source_buffer_forward_iter_to_source_mark(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> gboolean1529 pub fn gtk_source_buffer_forward_iter_to_source_mark(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> gboolean; gtk_source_buffer_get_context_classes_at_iter(buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter) -> *mut *mut c_char1530 pub fn gtk_source_buffer_get_context_classes_at_iter(buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter) -> *mut *mut c_char; gtk_source_buffer_get_highlight_matching_brackets(buffer: *mut GtkSourceBuffer) -> gboolean1531 pub fn gtk_source_buffer_get_highlight_matching_brackets(buffer: *mut GtkSourceBuffer) -> gboolean; gtk_source_buffer_get_highlight_syntax(buffer: *mut GtkSourceBuffer) -> gboolean1532 pub fn gtk_source_buffer_get_highlight_syntax(buffer: *mut GtkSourceBuffer) -> gboolean; gtk_source_buffer_get_implicit_trailing_newline(buffer: *mut GtkSourceBuffer) -> gboolean1533 pub fn gtk_source_buffer_get_implicit_trailing_newline(buffer: *mut GtkSourceBuffer) -> gboolean; gtk_source_buffer_get_language(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceLanguage1534 pub fn gtk_source_buffer_get_language(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceLanguage; gtk_source_buffer_get_max_undo_levels(buffer: *mut GtkSourceBuffer) -> c_int1535 pub fn gtk_source_buffer_get_max_undo_levels(buffer: *mut GtkSourceBuffer) -> c_int; gtk_source_buffer_get_source_marks_at_iter(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> *mut glib::GSList1536 pub fn gtk_source_buffer_get_source_marks_at_iter(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, category: *const c_char) -> *mut glib::GSList; gtk_source_buffer_get_source_marks_at_line(buffer: *mut GtkSourceBuffer, line: c_int, category: *const c_char) -> *mut glib::GSList1537 pub fn gtk_source_buffer_get_source_marks_at_line(buffer: *mut GtkSourceBuffer, line: c_int, category: *const c_char) -> *mut glib::GSList; gtk_source_buffer_get_style_scheme(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceStyleScheme1538 pub fn gtk_source_buffer_get_style_scheme(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceStyleScheme; gtk_source_buffer_get_undo_manager(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceUndoManager1539 pub fn gtk_source_buffer_get_undo_manager(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceUndoManager; gtk_source_buffer_iter_backward_to_context_class_toggle(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char) -> gboolean1540 pub fn gtk_source_buffer_iter_backward_to_context_class_toggle(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char) -> gboolean; gtk_source_buffer_iter_forward_to_context_class_toggle(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char) -> gboolean1541 pub fn gtk_source_buffer_iter_forward_to_context_class_toggle(buffer: *mut GtkSourceBuffer, iter: *mut gtk::GtkTextIter, context_class: *const c_char) -> gboolean; gtk_source_buffer_iter_has_context_class(buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter, context_class: *const c_char) -> gboolean1542 pub fn gtk_source_buffer_iter_has_context_class(buffer: *mut GtkSourceBuffer, iter: *const gtk::GtkTextIter, context_class: *const c_char) -> gboolean; gtk_source_buffer_join_lines(buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter)1543 pub fn gtk_source_buffer_join_lines(buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter); gtk_source_buffer_redo(buffer: *mut GtkSourceBuffer)1544 pub fn gtk_source_buffer_redo(buffer: *mut GtkSourceBuffer); gtk_source_buffer_remove_source_marks(buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter, category: *const c_char)1545 pub fn gtk_source_buffer_remove_source_marks(buffer: *mut GtkSourceBuffer, start: *const gtk::GtkTextIter, end: *const gtk::GtkTextIter, category: *const c_char); gtk_source_buffer_set_highlight_matching_brackets(buffer: *mut GtkSourceBuffer, highlight: gboolean)1546 pub fn gtk_source_buffer_set_highlight_matching_brackets(buffer: *mut GtkSourceBuffer, highlight: gboolean); gtk_source_buffer_set_highlight_syntax(buffer: *mut GtkSourceBuffer, highlight: gboolean)1547 pub fn gtk_source_buffer_set_highlight_syntax(buffer: *mut GtkSourceBuffer, highlight: gboolean); gtk_source_buffer_set_implicit_trailing_newline(buffer: *mut GtkSourceBuffer, implicit_trailing_newline: gboolean)1548 pub fn gtk_source_buffer_set_implicit_trailing_newline(buffer: *mut GtkSourceBuffer, implicit_trailing_newline: gboolean); gtk_source_buffer_set_language(buffer: *mut GtkSourceBuffer, language: *mut GtkSourceLanguage)1549 pub fn gtk_source_buffer_set_language(buffer: *mut GtkSourceBuffer, language: *mut GtkSourceLanguage); gtk_source_buffer_set_max_undo_levels(buffer: *mut GtkSourceBuffer, max_undo_levels: c_int)1550 pub fn gtk_source_buffer_set_max_undo_levels(buffer: *mut GtkSourceBuffer, max_undo_levels: c_int); gtk_source_buffer_set_style_scheme(buffer: *mut GtkSourceBuffer, scheme: *mut GtkSourceStyleScheme)1551 pub fn gtk_source_buffer_set_style_scheme(buffer: *mut GtkSourceBuffer, scheme: *mut GtkSourceStyleScheme); gtk_source_buffer_set_undo_manager(buffer: *mut GtkSourceBuffer, manager: *mut GtkSourceUndoManager)1552 pub fn gtk_source_buffer_set_undo_manager(buffer: *mut GtkSourceBuffer, manager: *mut GtkSourceUndoManager); gtk_source_buffer_sort_lines(buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, flags: GtkSourceSortFlags, column: c_int)1553 pub fn gtk_source_buffer_sort_lines(buffer: *mut GtkSourceBuffer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, flags: GtkSourceSortFlags, column: c_int); gtk_source_buffer_undo(buffer: *mut GtkSourceBuffer)1554 pub fn gtk_source_buffer_undo(buffer: *mut GtkSourceBuffer); 1555 1556 //========================================================================= 1557 // GtkSourceCompletion 1558 //========================================================================= gtk_source_completion_get_type() -> GType1559 pub fn gtk_source_completion_get_type() -> GType; gtk_source_completion_add_provider(completion: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, error: *mut *mut glib::GError) -> gboolean1560 pub fn gtk_source_completion_add_provider(completion: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, error: *mut *mut glib::GError) -> gboolean; gtk_source_completion_block_interactive(completion: *mut GtkSourceCompletion)1561 pub fn gtk_source_completion_block_interactive(completion: *mut GtkSourceCompletion); gtk_source_completion_create_context(completion: *mut GtkSourceCompletion, position: *mut gtk::GtkTextIter) -> *mut GtkSourceCompletionContext1562 pub fn gtk_source_completion_create_context(completion: *mut GtkSourceCompletion, position: *mut gtk::GtkTextIter) -> *mut GtkSourceCompletionContext; gtk_source_completion_get_info_window(completion: *mut GtkSourceCompletion) -> *mut GtkSourceCompletionInfo1563 pub fn gtk_source_completion_get_info_window(completion: *mut GtkSourceCompletion) -> *mut GtkSourceCompletionInfo; gtk_source_completion_get_providers(completion: *mut GtkSourceCompletion) -> *mut glib::GList1564 pub fn gtk_source_completion_get_providers(completion: *mut GtkSourceCompletion) -> *mut glib::GList; gtk_source_completion_get_view(completion: *mut GtkSourceCompletion) -> *mut GtkSourceView1565 pub fn gtk_source_completion_get_view(completion: *mut GtkSourceCompletion) -> *mut GtkSourceView; gtk_source_completion_hide(completion: *mut GtkSourceCompletion)1566 pub fn gtk_source_completion_hide(completion: *mut GtkSourceCompletion); gtk_source_completion_remove_provider(completion: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, error: *mut *mut glib::GError) -> gboolean1567 pub fn gtk_source_completion_remove_provider(completion: *mut GtkSourceCompletion, provider: *mut GtkSourceCompletionProvider, error: *mut *mut glib::GError) -> gboolean; gtk_source_completion_start(completion: *mut GtkSourceCompletion, providers: *mut glib::GList, context: *mut GtkSourceCompletionContext) -> gboolean1568 pub fn gtk_source_completion_start(completion: *mut GtkSourceCompletion, providers: *mut glib::GList, context: *mut GtkSourceCompletionContext) -> gboolean; gtk_source_completion_unblock_interactive(completion: *mut GtkSourceCompletion)1569 pub fn gtk_source_completion_unblock_interactive(completion: *mut GtkSourceCompletion); 1570 1571 //========================================================================= 1572 // GtkSourceCompletionContext 1573 //========================================================================= gtk_source_completion_context_get_type() -> GType1574 pub fn gtk_source_completion_context_get_type() -> GType; gtk_source_completion_context_add_proposals(context: *mut GtkSourceCompletionContext, provider: *mut GtkSourceCompletionProvider, proposals: *mut glib::GList, finished: gboolean)1575 pub fn gtk_source_completion_context_add_proposals(context: *mut GtkSourceCompletionContext, provider: *mut GtkSourceCompletionProvider, proposals: *mut glib::GList, finished: gboolean); gtk_source_completion_context_get_activation(context: *mut GtkSourceCompletionContext) -> GtkSourceCompletionActivation1576 pub fn gtk_source_completion_context_get_activation(context: *mut GtkSourceCompletionContext) -> GtkSourceCompletionActivation; gtk_source_completion_context_get_iter(context: *mut GtkSourceCompletionContext, iter: *mut gtk::GtkTextIter) -> gboolean1577 pub fn gtk_source_completion_context_get_iter(context: *mut GtkSourceCompletionContext, iter: *mut gtk::GtkTextIter) -> gboolean; 1578 1579 //========================================================================= 1580 // GtkSourceCompletionInfo 1581 //========================================================================= gtk_source_completion_info_get_type() -> GType1582 pub fn gtk_source_completion_info_get_type() -> GType; gtk_source_completion_info_new() -> *mut GtkSourceCompletionInfo1583 pub fn gtk_source_completion_info_new() -> *mut GtkSourceCompletionInfo; gtk_source_completion_info_move_to_iter(info: *mut GtkSourceCompletionInfo, view: *mut gtk::GtkTextView, iter: *mut gtk::GtkTextIter)1584 pub fn gtk_source_completion_info_move_to_iter(info: *mut GtkSourceCompletionInfo, view: *mut gtk::GtkTextView, iter: *mut gtk::GtkTextIter); 1585 1586 //========================================================================= 1587 // GtkSourceCompletionItem 1588 //========================================================================= gtk_source_completion_item_get_type() -> GType1589 pub fn gtk_source_completion_item_get_type() -> GType; gtk_source_completion_item_new() -> *mut GtkSourceCompletionItem1590 pub fn gtk_source_completion_item_new() -> *mut GtkSourceCompletionItem; gtk_source_completion_item_set_gicon(item: *mut GtkSourceCompletionItem, gicon: *mut gio::GIcon)1591 pub fn gtk_source_completion_item_set_gicon(item: *mut GtkSourceCompletionItem, gicon: *mut gio::GIcon); gtk_source_completion_item_set_icon(item: *mut GtkSourceCompletionItem, icon: *mut gdk_pixbuf::GdkPixbuf)1592 pub fn gtk_source_completion_item_set_icon(item: *mut GtkSourceCompletionItem, icon: *mut gdk_pixbuf::GdkPixbuf); gtk_source_completion_item_set_icon_name(item: *mut GtkSourceCompletionItem, icon_name: *const c_char)1593 pub fn gtk_source_completion_item_set_icon_name(item: *mut GtkSourceCompletionItem, icon_name: *const c_char); gtk_source_completion_item_set_info(item: *mut GtkSourceCompletionItem, info: *const c_char)1594 pub fn gtk_source_completion_item_set_info(item: *mut GtkSourceCompletionItem, info: *const c_char); gtk_source_completion_item_set_label(item: *mut GtkSourceCompletionItem, label: *const c_char)1595 pub fn gtk_source_completion_item_set_label(item: *mut GtkSourceCompletionItem, label: *const c_char); gtk_source_completion_item_set_markup(item: *mut GtkSourceCompletionItem, markup: *const c_char)1596 pub fn gtk_source_completion_item_set_markup(item: *mut GtkSourceCompletionItem, markup: *const c_char); gtk_source_completion_item_set_text(item: *mut GtkSourceCompletionItem, text: *const c_char)1597 pub fn gtk_source_completion_item_set_text(item: *mut GtkSourceCompletionItem, text: *const c_char); 1598 1599 //========================================================================= 1600 // GtkSourceCompletionWords 1601 //========================================================================= gtk_source_completion_words_get_type() -> GType1602 pub fn gtk_source_completion_words_get_type() -> GType; gtk_source_completion_words_new(name: *const c_char, icon: *mut gdk_pixbuf::GdkPixbuf) -> *mut GtkSourceCompletionWords1603 pub fn gtk_source_completion_words_new(name: *const c_char, icon: *mut gdk_pixbuf::GdkPixbuf) -> *mut GtkSourceCompletionWords; gtk_source_completion_words_register(words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer)1604 pub fn gtk_source_completion_words_register(words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer); gtk_source_completion_words_unregister(words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer)1605 pub fn gtk_source_completion_words_unregister(words: *mut GtkSourceCompletionWords, buffer: *mut gtk::GtkTextBuffer); 1606 1607 //========================================================================= 1608 // GtkSourceFile 1609 //========================================================================= gtk_source_file_get_type() -> GType1610 pub fn gtk_source_file_get_type() -> GType; gtk_source_file_new() -> *mut GtkSourceFile1611 pub fn gtk_source_file_new() -> *mut GtkSourceFile; gtk_source_file_check_file_on_disk(file: *mut GtkSourceFile)1612 pub fn gtk_source_file_check_file_on_disk(file: *mut GtkSourceFile); gtk_source_file_get_compression_type(file: *mut GtkSourceFile) -> GtkSourceCompressionType1613 pub fn gtk_source_file_get_compression_type(file: *mut GtkSourceFile) -> GtkSourceCompressionType; gtk_source_file_get_encoding(file: *mut GtkSourceFile) -> *const GtkSourceEncoding1614 pub fn gtk_source_file_get_encoding(file: *mut GtkSourceFile) -> *const GtkSourceEncoding; gtk_source_file_get_location(file: *mut GtkSourceFile) -> *mut gio::GFile1615 pub fn gtk_source_file_get_location(file: *mut GtkSourceFile) -> *mut gio::GFile; gtk_source_file_get_newline_type(file: *mut GtkSourceFile) -> GtkSourceNewlineType1616 pub fn gtk_source_file_get_newline_type(file: *mut GtkSourceFile) -> GtkSourceNewlineType; gtk_source_file_is_deleted(file: *mut GtkSourceFile) -> gboolean1617 pub fn gtk_source_file_is_deleted(file: *mut GtkSourceFile) -> gboolean; gtk_source_file_is_externally_modified(file: *mut GtkSourceFile) -> gboolean1618 pub fn gtk_source_file_is_externally_modified(file: *mut GtkSourceFile) -> gboolean; gtk_source_file_is_local(file: *mut GtkSourceFile) -> gboolean1619 pub fn gtk_source_file_is_local(file: *mut GtkSourceFile) -> gboolean; gtk_source_file_is_readonly(file: *mut GtkSourceFile) -> gboolean1620 pub fn gtk_source_file_is_readonly(file: *mut GtkSourceFile) -> gboolean; gtk_source_file_set_location(file: *mut GtkSourceFile, location: *mut gio::GFile)1621 pub fn gtk_source_file_set_location(file: *mut GtkSourceFile, location: *mut gio::GFile); gtk_source_file_set_mount_operation_factory(file: *mut GtkSourceFile, callback: GtkSourceMountOperationFactory, user_data: gpointer, notify: glib::GDestroyNotify)1622 pub fn gtk_source_file_set_mount_operation_factory(file: *mut GtkSourceFile, callback: GtkSourceMountOperationFactory, user_data: gpointer, notify: glib::GDestroyNotify); 1623 1624 //========================================================================= 1625 // GtkSourceFileLoader 1626 //========================================================================= gtk_source_file_loader_get_type() -> GType1627 pub fn gtk_source_file_loader_get_type() -> GType; gtk_source_file_loader_new(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile) -> *mut GtkSourceFileLoader1628 pub fn gtk_source_file_loader_new(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile) -> *mut GtkSourceFileLoader; gtk_source_file_loader_new_from_stream(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, stream: *mut gio::GInputStream) -> *mut GtkSourceFileLoader1629 pub fn gtk_source_file_loader_new_from_stream(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, stream: *mut gio::GInputStream) -> *mut GtkSourceFileLoader; gtk_source_file_loader_get_buffer(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceBuffer1630 pub fn gtk_source_file_loader_get_buffer(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceBuffer; gtk_source_file_loader_get_compression_type(loader: *mut GtkSourceFileLoader) -> GtkSourceCompressionType1631 pub fn gtk_source_file_loader_get_compression_type(loader: *mut GtkSourceFileLoader) -> GtkSourceCompressionType; gtk_source_file_loader_get_encoding(loader: *mut GtkSourceFileLoader) -> *const GtkSourceEncoding1632 pub fn gtk_source_file_loader_get_encoding(loader: *mut GtkSourceFileLoader) -> *const GtkSourceEncoding; gtk_source_file_loader_get_file(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceFile1633 pub fn gtk_source_file_loader_get_file(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceFile; gtk_source_file_loader_get_input_stream(loader: *mut GtkSourceFileLoader) -> *mut gio::GInputStream1634 pub fn gtk_source_file_loader_get_input_stream(loader: *mut GtkSourceFileLoader) -> *mut gio::GInputStream; gtk_source_file_loader_get_location(loader: *mut GtkSourceFileLoader) -> *mut gio::GFile1635 pub fn gtk_source_file_loader_get_location(loader: *mut GtkSourceFileLoader) -> *mut gio::GFile; gtk_source_file_loader_get_newline_type(loader: *mut GtkSourceFileLoader) -> GtkSourceNewlineType1636 pub fn gtk_source_file_loader_get_newline_type(loader: *mut GtkSourceFileLoader) -> GtkSourceNewlineType; 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)1637 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); gtk_source_file_loader_load_finish(loader: *mut GtkSourceFileLoader, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean1638 pub fn gtk_source_file_loader_load_finish(loader: *mut GtkSourceFileLoader, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean; gtk_source_file_loader_set_candidate_encodings(loader: *mut GtkSourceFileLoader, candidate_encodings: *mut glib::GSList)1639 pub fn gtk_source_file_loader_set_candidate_encodings(loader: *mut GtkSourceFileLoader, candidate_encodings: *mut glib::GSList); 1640 1641 //========================================================================= 1642 // GtkSourceFileSaver 1643 //========================================================================= gtk_source_file_saver_get_type() -> GType1644 pub fn gtk_source_file_saver_get_type() -> GType; gtk_source_file_saver_new(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile) -> *mut GtkSourceFileSaver1645 pub fn gtk_source_file_saver_new(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile) -> *mut GtkSourceFileSaver; gtk_source_file_saver_new_with_target(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, target_location: *mut gio::GFile) -> *mut GtkSourceFileSaver1646 pub fn gtk_source_file_saver_new_with_target(buffer: *mut GtkSourceBuffer, file: *mut GtkSourceFile, target_location: *mut gio::GFile) -> *mut GtkSourceFileSaver; gtk_source_file_saver_get_buffer(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceBuffer1647 pub fn gtk_source_file_saver_get_buffer(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceBuffer; gtk_source_file_saver_get_compression_type(saver: *mut GtkSourceFileSaver) -> GtkSourceCompressionType1648 pub fn gtk_source_file_saver_get_compression_type(saver: *mut GtkSourceFileSaver) -> GtkSourceCompressionType; gtk_source_file_saver_get_encoding(saver: *mut GtkSourceFileSaver) -> *const GtkSourceEncoding1649 pub fn gtk_source_file_saver_get_encoding(saver: *mut GtkSourceFileSaver) -> *const GtkSourceEncoding; gtk_source_file_saver_get_file(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceFile1650 pub fn gtk_source_file_saver_get_file(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceFile; gtk_source_file_saver_get_flags(saver: *mut GtkSourceFileSaver) -> GtkSourceFileSaverFlags1651 pub fn gtk_source_file_saver_get_flags(saver: *mut GtkSourceFileSaver) -> GtkSourceFileSaverFlags; gtk_source_file_saver_get_location(saver: *mut GtkSourceFileSaver) -> *mut gio::GFile1652 pub fn gtk_source_file_saver_get_location(saver: *mut GtkSourceFileSaver) -> *mut gio::GFile; gtk_source_file_saver_get_newline_type(saver: *mut GtkSourceFileSaver) -> GtkSourceNewlineType1653 pub fn gtk_source_file_saver_get_newline_type(saver: *mut GtkSourceFileSaver) -> GtkSourceNewlineType; 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)1654 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); gtk_source_file_saver_save_finish(saver: *mut GtkSourceFileSaver, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean1655 pub fn gtk_source_file_saver_save_finish(saver: *mut GtkSourceFileSaver, result: *mut gio::GAsyncResult, error: *mut *mut glib::GError) -> gboolean; gtk_source_file_saver_set_compression_type(saver: *mut GtkSourceFileSaver, compression_type: GtkSourceCompressionType)1656 pub fn gtk_source_file_saver_set_compression_type(saver: *mut GtkSourceFileSaver, compression_type: GtkSourceCompressionType); gtk_source_file_saver_set_encoding(saver: *mut GtkSourceFileSaver, encoding: *const GtkSourceEncoding)1657 pub fn gtk_source_file_saver_set_encoding(saver: *mut GtkSourceFileSaver, encoding: *const GtkSourceEncoding); gtk_source_file_saver_set_flags(saver: *mut GtkSourceFileSaver, flags: GtkSourceFileSaverFlags)1658 pub fn gtk_source_file_saver_set_flags(saver: *mut GtkSourceFileSaver, flags: GtkSourceFileSaverFlags); gtk_source_file_saver_set_newline_type(saver: *mut GtkSourceFileSaver, newline_type: GtkSourceNewlineType)1659 pub fn gtk_source_file_saver_set_newline_type(saver: *mut GtkSourceFileSaver, newline_type: GtkSourceNewlineType); 1660 1661 //========================================================================= 1662 // GtkSourceGutter 1663 //========================================================================= gtk_source_gutter_get_type() -> GType1664 pub fn gtk_source_gutter_get_type() -> GType; gtk_source_gutter_get_renderer_at_pos(gutter: *mut GtkSourceGutter, x: c_int, y: c_int) -> *mut GtkSourceGutterRenderer1665 pub fn gtk_source_gutter_get_renderer_at_pos(gutter: *mut GtkSourceGutter, x: c_int, y: c_int) -> *mut GtkSourceGutterRenderer; gtk_source_gutter_get_view(gutter: *mut GtkSourceGutter) -> *mut GtkSourceView1666 pub fn gtk_source_gutter_get_view(gutter: *mut GtkSourceGutter) -> *mut GtkSourceView; gtk_source_gutter_get_window_type(gutter: *mut GtkSourceGutter) -> gtk::GtkTextWindowType1667 pub fn gtk_source_gutter_get_window_type(gutter: *mut GtkSourceGutter) -> gtk::GtkTextWindowType; gtk_source_gutter_insert(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int) -> gboolean1668 pub fn gtk_source_gutter_insert(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int) -> gboolean; gtk_source_gutter_queue_draw(gutter: *mut GtkSourceGutter)1669 pub fn gtk_source_gutter_queue_draw(gutter: *mut GtkSourceGutter); gtk_source_gutter_remove(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer)1670 pub fn gtk_source_gutter_remove(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer); gtk_source_gutter_reorder(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int)1671 pub fn gtk_source_gutter_reorder(gutter: *mut GtkSourceGutter, renderer: *mut GtkSourceGutterRenderer, position: c_int); 1672 1673 //========================================================================= 1674 // GtkSourceGutterRenderer 1675 //========================================================================= gtk_source_gutter_renderer_get_type() -> GType1676 pub fn gtk_source_gutter_renderer_get_type() -> GType; gtk_source_gutter_renderer_activate(renderer: *mut GtkSourceGutterRenderer, iter: *mut gtk::GtkTextIter, area: *mut gdk::GdkRectangle, event: *mut gdk::GdkEvent)1677 pub fn gtk_source_gutter_renderer_activate(renderer: *mut GtkSourceGutterRenderer, iter: *mut gtk::GtkTextIter, area: *mut gdk::GdkRectangle, event: *mut gdk::GdkEvent); 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)1678 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); 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)1679 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); gtk_source_gutter_renderer_end(renderer: *mut GtkSourceGutterRenderer)1680 pub fn gtk_source_gutter_renderer_end(renderer: *mut GtkSourceGutterRenderer); gtk_source_gutter_renderer_get_alignment(renderer: *mut GtkSourceGutterRenderer, xalign: *mut c_float, yalign: *mut c_float)1681 pub fn gtk_source_gutter_renderer_get_alignment(renderer: *mut GtkSourceGutterRenderer, xalign: *mut c_float, yalign: *mut c_float); gtk_source_gutter_renderer_get_alignment_mode(renderer: *mut GtkSourceGutterRenderer) -> GtkSourceGutterRendererAlignmentMode1682 pub fn gtk_source_gutter_renderer_get_alignment_mode(renderer: *mut GtkSourceGutterRenderer) -> GtkSourceGutterRendererAlignmentMode; gtk_source_gutter_renderer_get_background(renderer: *mut GtkSourceGutterRenderer, color: *mut gdk::GdkRGBA) -> gboolean1683 pub fn gtk_source_gutter_renderer_get_background(renderer: *mut GtkSourceGutterRenderer, color: *mut gdk::GdkRGBA) -> gboolean; gtk_source_gutter_renderer_get_padding(renderer: *mut GtkSourceGutterRenderer, xpad: *mut c_int, ypad: *mut c_int)1684 pub fn gtk_source_gutter_renderer_get_padding(renderer: *mut GtkSourceGutterRenderer, xpad: *mut c_int, ypad: *mut c_int); gtk_source_gutter_renderer_get_size(renderer: *mut GtkSourceGutterRenderer) -> c_int1685 pub fn gtk_source_gutter_renderer_get_size(renderer: *mut GtkSourceGutterRenderer) -> c_int; gtk_source_gutter_renderer_get_view(renderer: *mut GtkSourceGutterRenderer) -> *mut gtk::GtkTextView1686 pub fn gtk_source_gutter_renderer_get_view(renderer: *mut GtkSourceGutterRenderer) -> *mut gtk::GtkTextView; gtk_source_gutter_renderer_get_visible(renderer: *mut GtkSourceGutterRenderer) -> gboolean1687 pub fn gtk_source_gutter_renderer_get_visible(renderer: *mut GtkSourceGutterRenderer) -> gboolean; gtk_source_gutter_renderer_get_window_type(renderer: *mut GtkSourceGutterRenderer) -> gtk::GtkTextWindowType1688 pub fn gtk_source_gutter_renderer_get_window_type(renderer: *mut GtkSourceGutterRenderer) -> gtk::GtkTextWindowType; gtk_source_gutter_renderer_query_activatable(renderer: *mut GtkSourceGutterRenderer, iter: *mut gtk::GtkTextIter, area: *mut gdk::GdkRectangle, event: *mut gdk::GdkEvent) -> gboolean1689 pub fn gtk_source_gutter_renderer_query_activatable(renderer: *mut GtkSourceGutterRenderer, iter: *mut gtk::GtkTextIter, area: *mut gdk::GdkRectangle, event: *mut gdk::GdkEvent) -> gboolean; gtk_source_gutter_renderer_query_data(renderer: *mut GtkSourceGutterRenderer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, state: GtkSourceGutterRendererState)1690 pub fn gtk_source_gutter_renderer_query_data(renderer: *mut GtkSourceGutterRenderer, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter, state: GtkSourceGutterRendererState); 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) -> gboolean1691 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; gtk_source_gutter_renderer_queue_draw(renderer: *mut GtkSourceGutterRenderer)1692 pub fn gtk_source_gutter_renderer_queue_draw(renderer: *mut GtkSourceGutterRenderer); gtk_source_gutter_renderer_set_alignment(renderer: *mut GtkSourceGutterRenderer, xalign: c_float, yalign: c_float)1693 pub fn gtk_source_gutter_renderer_set_alignment(renderer: *mut GtkSourceGutterRenderer, xalign: c_float, yalign: c_float); gtk_source_gutter_renderer_set_alignment_mode(renderer: *mut GtkSourceGutterRenderer, mode: GtkSourceGutterRendererAlignmentMode)1694 pub fn gtk_source_gutter_renderer_set_alignment_mode(renderer: *mut GtkSourceGutterRenderer, mode: GtkSourceGutterRendererAlignmentMode); gtk_source_gutter_renderer_set_background(renderer: *mut GtkSourceGutterRenderer, color: *const gdk::GdkRGBA)1695 pub fn gtk_source_gutter_renderer_set_background(renderer: *mut GtkSourceGutterRenderer, color: *const gdk::GdkRGBA); gtk_source_gutter_renderer_set_padding(renderer: *mut GtkSourceGutterRenderer, xpad: c_int, ypad: c_int)1696 pub fn gtk_source_gutter_renderer_set_padding(renderer: *mut GtkSourceGutterRenderer, xpad: c_int, ypad: c_int); gtk_source_gutter_renderer_set_size(renderer: *mut GtkSourceGutterRenderer, size: c_int)1697 pub fn gtk_source_gutter_renderer_set_size(renderer: *mut GtkSourceGutterRenderer, size: c_int); gtk_source_gutter_renderer_set_visible(renderer: *mut GtkSourceGutterRenderer, visible: gboolean)1698 pub fn gtk_source_gutter_renderer_set_visible(renderer: *mut GtkSourceGutterRenderer, visible: gboolean); 1699 1700 //========================================================================= 1701 // GtkSourceGutterRendererPixbuf 1702 //========================================================================= gtk_source_gutter_renderer_pixbuf_get_type() -> GType1703 pub fn gtk_source_gutter_renderer_pixbuf_get_type() -> GType; gtk_source_gutter_renderer_pixbuf_new() -> *mut GtkSourceGutterRenderer1704 pub fn gtk_source_gutter_renderer_pixbuf_new() -> *mut GtkSourceGutterRenderer; gtk_source_gutter_renderer_pixbuf_get_gicon(renderer: *mut GtkSourceGutterRendererPixbuf) -> *mut gio::GIcon1705 pub fn gtk_source_gutter_renderer_pixbuf_get_gicon(renderer: *mut GtkSourceGutterRendererPixbuf) -> *mut gio::GIcon; gtk_source_gutter_renderer_pixbuf_get_icon_name(renderer: *mut GtkSourceGutterRendererPixbuf) -> *const c_char1706 pub fn gtk_source_gutter_renderer_pixbuf_get_icon_name(renderer: *mut GtkSourceGutterRendererPixbuf) -> *const c_char; gtk_source_gutter_renderer_pixbuf_get_pixbuf(renderer: *mut GtkSourceGutterRendererPixbuf) -> *mut gdk_pixbuf::GdkPixbuf1707 pub fn gtk_source_gutter_renderer_pixbuf_get_pixbuf(renderer: *mut GtkSourceGutterRendererPixbuf) -> *mut gdk_pixbuf::GdkPixbuf; gtk_source_gutter_renderer_pixbuf_set_gicon(renderer: *mut GtkSourceGutterRendererPixbuf, icon: *mut gio::GIcon)1708 pub fn gtk_source_gutter_renderer_pixbuf_set_gicon(renderer: *mut GtkSourceGutterRendererPixbuf, icon: *mut gio::GIcon); gtk_source_gutter_renderer_pixbuf_set_icon_name(renderer: *mut GtkSourceGutterRendererPixbuf, icon_name: *const c_char)1709 pub fn gtk_source_gutter_renderer_pixbuf_set_icon_name(renderer: *mut GtkSourceGutterRendererPixbuf, icon_name: *const c_char); gtk_source_gutter_renderer_pixbuf_set_pixbuf(renderer: *mut GtkSourceGutterRendererPixbuf, pixbuf: *mut gdk_pixbuf::GdkPixbuf)1710 pub fn gtk_source_gutter_renderer_pixbuf_set_pixbuf(renderer: *mut GtkSourceGutterRendererPixbuf, pixbuf: *mut gdk_pixbuf::GdkPixbuf); 1711 1712 //========================================================================= 1713 // GtkSourceGutterRendererText 1714 //========================================================================= gtk_source_gutter_renderer_text_get_type() -> GType1715 pub fn gtk_source_gutter_renderer_text_get_type() -> GType; gtk_source_gutter_renderer_text_new() -> *mut GtkSourceGutterRenderer1716 pub fn gtk_source_gutter_renderer_text_new() -> *mut GtkSourceGutterRenderer; gtk_source_gutter_renderer_text_measure(renderer: *mut GtkSourceGutterRendererText, text: *const c_char, width: *mut c_int, height: *mut c_int)1717 pub fn gtk_source_gutter_renderer_text_measure(renderer: *mut GtkSourceGutterRendererText, text: *const c_char, width: *mut c_int, height: *mut c_int); gtk_source_gutter_renderer_text_measure_markup(renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, width: *mut c_int, height: *mut c_int)1718 pub fn gtk_source_gutter_renderer_text_measure_markup(renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, width: *mut c_int, height: *mut c_int); gtk_source_gutter_renderer_text_set_markup(renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, length: c_int)1719 pub fn gtk_source_gutter_renderer_text_set_markup(renderer: *mut GtkSourceGutterRendererText, markup: *const c_char, length: c_int); gtk_source_gutter_renderer_text_set_text(renderer: *mut GtkSourceGutterRendererText, text: *const c_char, length: c_int)1720 pub fn gtk_source_gutter_renderer_text_set_text(renderer: *mut GtkSourceGutterRendererText, text: *const c_char, length: c_int); 1721 1722 //========================================================================= 1723 // GtkSourceLanguage 1724 //========================================================================= gtk_source_language_get_type() -> GType1725 pub fn gtk_source_language_get_type() -> GType; gtk_source_language_get_globs(language: *mut GtkSourceLanguage) -> *mut *mut c_char1726 pub fn gtk_source_language_get_globs(language: *mut GtkSourceLanguage) -> *mut *mut c_char; gtk_source_language_get_hidden(language: *mut GtkSourceLanguage) -> gboolean1727 pub fn gtk_source_language_get_hidden(language: *mut GtkSourceLanguage) -> gboolean; gtk_source_language_get_id(language: *mut GtkSourceLanguage) -> *const c_char1728 pub fn gtk_source_language_get_id(language: *mut GtkSourceLanguage) -> *const c_char; gtk_source_language_get_metadata(language: *mut GtkSourceLanguage, name: *const c_char) -> *const c_char1729 pub fn gtk_source_language_get_metadata(language: *mut GtkSourceLanguage, name: *const c_char) -> *const c_char; gtk_source_language_get_mime_types(language: *mut GtkSourceLanguage) -> *mut *mut c_char1730 pub fn gtk_source_language_get_mime_types(language: *mut GtkSourceLanguage) -> *mut *mut c_char; gtk_source_language_get_name(language: *mut GtkSourceLanguage) -> *const c_char1731 pub fn gtk_source_language_get_name(language: *mut GtkSourceLanguage) -> *const c_char; gtk_source_language_get_section(language: *mut GtkSourceLanguage) -> *const c_char1732 pub fn gtk_source_language_get_section(language: *mut GtkSourceLanguage) -> *const c_char; gtk_source_language_get_style_fallback(language: *mut GtkSourceLanguage, style_id: *const c_char) -> *const c_char1733 pub fn gtk_source_language_get_style_fallback(language: *mut GtkSourceLanguage, style_id: *const c_char) -> *const c_char; gtk_source_language_get_style_ids(language: *mut GtkSourceLanguage) -> *mut *mut c_char1734 pub fn gtk_source_language_get_style_ids(language: *mut GtkSourceLanguage) -> *mut *mut c_char; gtk_source_language_get_style_name(language: *mut GtkSourceLanguage, style_id: *const c_char) -> *const c_char1735 pub fn gtk_source_language_get_style_name(language: *mut GtkSourceLanguage, style_id: *const c_char) -> *const c_char; 1736 1737 //========================================================================= 1738 // GtkSourceLanguageManager 1739 //========================================================================= gtk_source_language_manager_get_type() -> GType1740 pub fn gtk_source_language_manager_get_type() -> GType; gtk_source_language_manager_new() -> *mut GtkSourceLanguageManager1741 pub fn gtk_source_language_manager_new() -> *mut GtkSourceLanguageManager; gtk_source_language_manager_get_default() -> *mut GtkSourceLanguageManager1742 pub fn gtk_source_language_manager_get_default() -> *mut GtkSourceLanguageManager; gtk_source_language_manager_get_language(lm: *mut GtkSourceLanguageManager, id: *const c_char) -> *mut GtkSourceLanguage1743 pub fn gtk_source_language_manager_get_language(lm: *mut GtkSourceLanguageManager, id: *const c_char) -> *mut GtkSourceLanguage; gtk_source_language_manager_get_language_ids(lm: *mut GtkSourceLanguageManager) -> *const *const c_char1744 pub fn gtk_source_language_manager_get_language_ids(lm: *mut GtkSourceLanguageManager) -> *const *const c_char; gtk_source_language_manager_get_search_path(lm: *mut GtkSourceLanguageManager) -> *const *const c_char1745 pub fn gtk_source_language_manager_get_search_path(lm: *mut GtkSourceLanguageManager) -> *const *const c_char; gtk_source_language_manager_guess_language(lm: *mut GtkSourceLanguageManager, filename: *const c_char, content_type: *const c_char) -> *mut GtkSourceLanguage1746 pub fn gtk_source_language_manager_guess_language(lm: *mut GtkSourceLanguageManager, filename: *const c_char, content_type: *const c_char) -> *mut GtkSourceLanguage; gtk_source_language_manager_set_search_path(lm: *mut GtkSourceLanguageManager, dirs: *mut *mut c_char)1747 pub fn gtk_source_language_manager_set_search_path(lm: *mut GtkSourceLanguageManager, dirs: *mut *mut c_char); 1748 1749 //========================================================================= 1750 // GtkSourceMap 1751 //========================================================================= gtk_source_map_get_type() -> GType1752 pub fn gtk_source_map_get_type() -> GType; gtk_source_map_new() -> *mut gtk::GtkWidget1753 pub fn gtk_source_map_new() -> *mut gtk::GtkWidget; gtk_source_map_get_view(map: *mut GtkSourceMap) -> *mut GtkSourceView1754 pub fn gtk_source_map_get_view(map: *mut GtkSourceMap) -> *mut GtkSourceView; gtk_source_map_set_view(map: *mut GtkSourceMap, view: *mut GtkSourceView)1755 pub fn gtk_source_map_set_view(map: *mut GtkSourceMap, view: *mut GtkSourceView); 1756 1757 //========================================================================= 1758 // GtkSourceMark 1759 //========================================================================= gtk_source_mark_get_type() -> GType1760 pub fn gtk_source_mark_get_type() -> GType; gtk_source_mark_new(name: *const c_char, category: *const c_char) -> *mut GtkSourceMark1761 pub fn gtk_source_mark_new(name: *const c_char, category: *const c_char) -> *mut GtkSourceMark; gtk_source_mark_get_category(mark: *mut GtkSourceMark) -> *const c_char1762 pub fn gtk_source_mark_get_category(mark: *mut GtkSourceMark) -> *const c_char; gtk_source_mark_next(mark: *mut GtkSourceMark, category: *const c_char) -> *mut GtkSourceMark1763 pub fn gtk_source_mark_next(mark: *mut GtkSourceMark, category: *const c_char) -> *mut GtkSourceMark; gtk_source_mark_prev(mark: *mut GtkSourceMark, category: *const c_char) -> *mut GtkSourceMark1764 pub fn gtk_source_mark_prev(mark: *mut GtkSourceMark, category: *const c_char) -> *mut GtkSourceMark; 1765 1766 //========================================================================= 1767 // GtkSourceMarkAttributes 1768 //========================================================================= gtk_source_mark_attributes_get_type() -> GType1769 pub fn gtk_source_mark_attributes_get_type() -> GType; gtk_source_mark_attributes_new() -> *mut GtkSourceMarkAttributes1770 pub fn gtk_source_mark_attributes_new() -> *mut GtkSourceMarkAttributes; gtk_source_mark_attributes_get_background(attributes: *mut GtkSourceMarkAttributes, background: *mut gdk::GdkRGBA) -> gboolean1771 pub fn gtk_source_mark_attributes_get_background(attributes: *mut GtkSourceMarkAttributes, background: *mut gdk::GdkRGBA) -> gboolean; gtk_source_mark_attributes_get_gicon(attributes: *mut GtkSourceMarkAttributes) -> *mut gio::GIcon1772 pub fn gtk_source_mark_attributes_get_gicon(attributes: *mut GtkSourceMarkAttributes) -> *mut gio::GIcon; gtk_source_mark_attributes_get_icon_name(attributes: *mut GtkSourceMarkAttributes) -> *const c_char1773 pub fn gtk_source_mark_attributes_get_icon_name(attributes: *mut GtkSourceMarkAttributes) -> *const c_char; gtk_source_mark_attributes_get_pixbuf(attributes: *mut GtkSourceMarkAttributes) -> *const gdk_pixbuf::GdkPixbuf1774 pub fn gtk_source_mark_attributes_get_pixbuf(attributes: *mut GtkSourceMarkAttributes) -> *const gdk_pixbuf::GdkPixbuf; gtk_source_mark_attributes_get_tooltip_markup(attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark) -> *mut c_char1775 pub fn gtk_source_mark_attributes_get_tooltip_markup(attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark) -> *mut c_char; gtk_source_mark_attributes_get_tooltip_text(attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark) -> *mut c_char1776 pub fn gtk_source_mark_attributes_get_tooltip_text(attributes: *mut GtkSourceMarkAttributes, mark: *mut GtkSourceMark) -> *mut c_char; gtk_source_mark_attributes_render_icon(attributes: *mut GtkSourceMarkAttributes, widget: *mut gtk::GtkWidget, size: c_int) -> *const gdk_pixbuf::GdkPixbuf1777 pub fn gtk_source_mark_attributes_render_icon(attributes: *mut GtkSourceMarkAttributes, widget: *mut gtk::GtkWidget, size: c_int) -> *const gdk_pixbuf::GdkPixbuf; gtk_source_mark_attributes_set_background(attributes: *mut GtkSourceMarkAttributes, background: *const gdk::GdkRGBA)1778 pub fn gtk_source_mark_attributes_set_background(attributes: *mut GtkSourceMarkAttributes, background: *const gdk::GdkRGBA); gtk_source_mark_attributes_set_gicon(attributes: *mut GtkSourceMarkAttributes, gicon: *mut gio::GIcon)1779 pub fn gtk_source_mark_attributes_set_gicon(attributes: *mut GtkSourceMarkAttributes, gicon: *mut gio::GIcon); gtk_source_mark_attributes_set_icon_name(attributes: *mut GtkSourceMarkAttributes, icon_name: *const c_char)1780 pub fn gtk_source_mark_attributes_set_icon_name(attributes: *mut GtkSourceMarkAttributes, icon_name: *const c_char); gtk_source_mark_attributes_set_pixbuf(attributes: *mut GtkSourceMarkAttributes, pixbuf: *const gdk_pixbuf::GdkPixbuf)1781 pub fn gtk_source_mark_attributes_set_pixbuf(attributes: *mut GtkSourceMarkAttributes, pixbuf: *const gdk_pixbuf::GdkPixbuf); 1782 1783 //========================================================================= 1784 // GtkSourcePrintCompositor 1785 //========================================================================= gtk_source_print_compositor_get_type() -> GType1786 pub fn gtk_source_print_compositor_get_type() -> GType; gtk_source_print_compositor_new(buffer: *mut GtkSourceBuffer) -> *mut GtkSourcePrintCompositor1787 pub fn gtk_source_print_compositor_new(buffer: *mut GtkSourceBuffer) -> *mut GtkSourcePrintCompositor; gtk_source_print_compositor_new_from_view(view: *mut GtkSourceView) -> *mut GtkSourcePrintCompositor1788 pub fn gtk_source_print_compositor_new_from_view(view: *mut GtkSourceView) -> *mut GtkSourcePrintCompositor; gtk_source_print_compositor_draw_page(compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext, page_nr: c_int)1789 pub fn gtk_source_print_compositor_draw_page(compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext, page_nr: c_int); gtk_source_print_compositor_get_body_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char1790 pub fn gtk_source_print_compositor_get_body_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char; gtk_source_print_compositor_get_bottom_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double1791 pub fn gtk_source_print_compositor_get_bottom_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double; gtk_source_print_compositor_get_buffer(compositor: *mut GtkSourcePrintCompositor) -> *mut GtkSourceBuffer1792 pub fn gtk_source_print_compositor_get_buffer(compositor: *mut GtkSourcePrintCompositor) -> *mut GtkSourceBuffer; gtk_source_print_compositor_get_footer_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char1793 pub fn gtk_source_print_compositor_get_footer_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char; gtk_source_print_compositor_get_header_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char1794 pub fn gtk_source_print_compositor_get_header_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char; gtk_source_print_compositor_get_highlight_syntax(compositor: *mut GtkSourcePrintCompositor) -> gboolean1795 pub fn gtk_source_print_compositor_get_highlight_syntax(compositor: *mut GtkSourcePrintCompositor) -> gboolean; gtk_source_print_compositor_get_left_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double1796 pub fn gtk_source_print_compositor_get_left_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double; gtk_source_print_compositor_get_line_numbers_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char1797 pub fn gtk_source_print_compositor_get_line_numbers_font_name(compositor: *mut GtkSourcePrintCompositor) -> *mut c_char; gtk_source_print_compositor_get_n_pages(compositor: *mut GtkSourcePrintCompositor) -> c_int1798 pub fn gtk_source_print_compositor_get_n_pages(compositor: *mut GtkSourcePrintCompositor) -> c_int; gtk_source_print_compositor_get_pagination_progress(compositor: *mut GtkSourcePrintCompositor) -> c_double1799 pub fn gtk_source_print_compositor_get_pagination_progress(compositor: *mut GtkSourcePrintCompositor) -> c_double; gtk_source_print_compositor_get_print_footer(compositor: *mut GtkSourcePrintCompositor) -> gboolean1800 pub fn gtk_source_print_compositor_get_print_footer(compositor: *mut GtkSourcePrintCompositor) -> gboolean; gtk_source_print_compositor_get_print_header(compositor: *mut GtkSourcePrintCompositor) -> gboolean1801 pub fn gtk_source_print_compositor_get_print_header(compositor: *mut GtkSourcePrintCompositor) -> gboolean; gtk_source_print_compositor_get_print_line_numbers(compositor: *mut GtkSourcePrintCompositor) -> c_uint1802 pub fn gtk_source_print_compositor_get_print_line_numbers(compositor: *mut GtkSourcePrintCompositor) -> c_uint; gtk_source_print_compositor_get_right_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double1803 pub fn gtk_source_print_compositor_get_right_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double; gtk_source_print_compositor_get_tab_width(compositor: *mut GtkSourcePrintCompositor) -> c_uint1804 pub fn gtk_source_print_compositor_get_tab_width(compositor: *mut GtkSourcePrintCompositor) -> c_uint; gtk_source_print_compositor_get_top_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double1805 pub fn gtk_source_print_compositor_get_top_margin(compositor: *mut GtkSourcePrintCompositor, unit: gtk::GtkUnit) -> c_double; gtk_source_print_compositor_get_wrap_mode(compositor: *mut GtkSourcePrintCompositor) -> gtk::GtkWrapMode1806 pub fn gtk_source_print_compositor_get_wrap_mode(compositor: *mut GtkSourcePrintCompositor) -> gtk::GtkWrapMode; gtk_source_print_compositor_paginate(compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext) -> gboolean1807 pub fn gtk_source_print_compositor_paginate(compositor: *mut GtkSourcePrintCompositor, context: *mut gtk::GtkPrintContext) -> gboolean; gtk_source_print_compositor_set_body_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char)1808 pub fn gtk_source_print_compositor_set_body_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char); gtk_source_print_compositor_set_bottom_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit)1809 pub fn gtk_source_print_compositor_set_bottom_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit); gtk_source_print_compositor_set_footer_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char)1810 pub fn gtk_source_print_compositor_set_footer_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char); gtk_source_print_compositor_set_footer_format(compositor: *mut GtkSourcePrintCompositor, separator: gboolean, left: *const c_char, center: *const c_char, right: *const c_char)1811 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); gtk_source_print_compositor_set_header_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char)1812 pub fn gtk_source_print_compositor_set_header_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char); gtk_source_print_compositor_set_header_format(compositor: *mut GtkSourcePrintCompositor, separator: gboolean, left: *const c_char, center: *const c_char, right: *const c_char)1813 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); gtk_source_print_compositor_set_highlight_syntax(compositor: *mut GtkSourcePrintCompositor, highlight: gboolean)1814 pub fn gtk_source_print_compositor_set_highlight_syntax(compositor: *mut GtkSourcePrintCompositor, highlight: gboolean); gtk_source_print_compositor_set_left_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit)1815 pub fn gtk_source_print_compositor_set_left_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit); gtk_source_print_compositor_set_line_numbers_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char)1816 pub fn gtk_source_print_compositor_set_line_numbers_font_name(compositor: *mut GtkSourcePrintCompositor, font_name: *const c_char); gtk_source_print_compositor_set_print_footer(compositor: *mut GtkSourcePrintCompositor, print: gboolean)1817 pub fn gtk_source_print_compositor_set_print_footer(compositor: *mut GtkSourcePrintCompositor, print: gboolean); gtk_source_print_compositor_set_print_header(compositor: *mut GtkSourcePrintCompositor, print: gboolean)1818 pub fn gtk_source_print_compositor_set_print_header(compositor: *mut GtkSourcePrintCompositor, print: gboolean); gtk_source_print_compositor_set_print_line_numbers(compositor: *mut GtkSourcePrintCompositor, interval: c_uint)1819 pub fn gtk_source_print_compositor_set_print_line_numbers(compositor: *mut GtkSourcePrintCompositor, interval: c_uint); gtk_source_print_compositor_set_right_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit)1820 pub fn gtk_source_print_compositor_set_right_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit); gtk_source_print_compositor_set_tab_width(compositor: *mut GtkSourcePrintCompositor, width: c_uint)1821 pub fn gtk_source_print_compositor_set_tab_width(compositor: *mut GtkSourcePrintCompositor, width: c_uint); gtk_source_print_compositor_set_top_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit)1822 pub fn gtk_source_print_compositor_set_top_margin(compositor: *mut GtkSourcePrintCompositor, margin: c_double, unit: gtk::GtkUnit); gtk_source_print_compositor_set_wrap_mode(compositor: *mut GtkSourcePrintCompositor, wrap_mode: gtk::GtkWrapMode)1823 pub fn gtk_source_print_compositor_set_wrap_mode(compositor: *mut GtkSourcePrintCompositor, wrap_mode: gtk::GtkWrapMode); 1824 1825 //========================================================================= 1826 // GtkSourceRegion 1827 //========================================================================= gtk_source_region_get_type() -> GType1828 pub fn gtk_source_region_get_type() -> GType; gtk_source_region_new(buffer: *mut gtk::GtkTextBuffer) -> *mut GtkSourceRegion1829 pub fn gtk_source_region_new(buffer: *mut gtk::GtkTextBuffer) -> *mut GtkSourceRegion; gtk_source_region_add_region(region: *mut GtkSourceRegion, region_to_add: *mut GtkSourceRegion)1830 pub fn gtk_source_region_add_region(region: *mut GtkSourceRegion, region_to_add: *mut GtkSourceRegion); gtk_source_region_add_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter)1831 pub fn gtk_source_region_add_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter); gtk_source_region_get_bounds(region: *mut GtkSourceRegion, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter) -> gboolean1832 pub fn gtk_source_region_get_bounds(region: *mut GtkSourceRegion, start: *mut gtk::GtkTextIter, end: *mut gtk::GtkTextIter) -> gboolean; gtk_source_region_get_buffer(region: *mut GtkSourceRegion) -> *mut gtk::GtkTextBuffer1833 pub fn gtk_source_region_get_buffer(region: *mut GtkSourceRegion) -> *mut gtk::GtkTextBuffer; gtk_source_region_get_start_region_iter(region: *mut GtkSourceRegion, iter: *mut GtkSourceRegionIter)1834 pub fn gtk_source_region_get_start_region_iter(region: *mut GtkSourceRegion, iter: *mut GtkSourceRegionIter); gtk_source_region_intersect_region(region1: *mut GtkSourceRegion, region2: *mut GtkSourceRegion) -> *mut GtkSourceRegion1835 pub fn gtk_source_region_intersect_region(region1: *mut GtkSourceRegion, region2: *mut GtkSourceRegion) -> *mut GtkSourceRegion; gtk_source_region_intersect_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter) -> *mut GtkSourceRegion1836 pub fn gtk_source_region_intersect_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter) -> *mut GtkSourceRegion; gtk_source_region_is_empty(region: *mut GtkSourceRegion) -> gboolean1837 pub fn gtk_source_region_is_empty(region: *mut GtkSourceRegion) -> gboolean; gtk_source_region_subtract_region(region: *mut GtkSourceRegion, region_to_subtract: *mut GtkSourceRegion)1838 pub fn gtk_source_region_subtract_region(region: *mut GtkSourceRegion, region_to_subtract: *mut GtkSourceRegion); gtk_source_region_subtract_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter)1839 pub fn gtk_source_region_subtract_subregion(region: *mut GtkSourceRegion, _start: *const gtk::GtkTextIter, _end: *const gtk::GtkTextIter); gtk_source_region_to_string(region: *mut GtkSourceRegion) -> *mut c_char1840 pub fn gtk_source_region_to_string(region: *mut GtkSourceRegion) -> *mut c_char; 1841 1842 //========================================================================= 1843 // GtkSourceSearchContext 1844 //========================================================================= gtk_source_search_context_get_type() -> GType1845 pub fn gtk_source_search_context_get_type() -> GType; gtk_source_search_context_new(buffer: *mut GtkSourceBuffer, settings: *mut GtkSourceSearchSettings) -> *mut GtkSourceSearchContext1846 pub fn gtk_source_search_context_new(buffer: *mut GtkSourceBuffer, settings: *mut GtkSourceSearchSettings) -> *mut GtkSourceSearchContext; 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) -> gboolean1847 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; gtk_source_search_context_backward_async(search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer)1848 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); 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) -> gboolean1849 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; 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) -> gboolean1850 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; gtk_source_search_context_forward_async(search: *mut GtkSourceSearchContext, iter: *const gtk::GtkTextIter, cancellable: *mut gio::GCancellable, callback: gio::GAsyncReadyCallback, user_data: gpointer)1851