1#![allow(non_camel_case_types, non_upper_case_globals, non_snake_case)]
6#![allow(
7 clippy::approx_constant,
8 clippy::type_complexity,
9 clippy::unreadable_literal
10)]
11
12extern crate cairo_sys as cairo;
13extern crate gdk_pixbuf_sys as gdk_pixbuf;
14extern crate gdk_sys as gdk;
15extern crate gio_sys as gio;
16extern crate glib_sys as glib;
17extern crate gobject_sys as gobject;
18extern crate gtk_sys as gtk;
19extern crate libc;
20
21#[allow(unused_imports)]
22use libc::{
23 c_char, c_double, c_float, c_int, c_long, c_short, c_uchar, c_uint, c_ulong, c_ushort, c_void,
24 intptr_t, size_t, ssize_t, time_t, uintptr_t, FILE,
25};
26
27#[allow(unused_imports)]
28use glib::{gboolean, gconstpointer, gpointer, GType};
29
30pub type GtkSourceBackgroundPatternType = c_int;
32pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_NONE: GtkSourceBackgroundPatternType = 0;
33pub const GTK_SOURCE_BACKGROUND_PATTERN_TYPE_GRID: GtkSourceBackgroundPatternType = 1;
34
35pub type GtkSourceBracketMatchType = c_int;
36pub const GTK_SOURCE_BRACKET_MATCH_NONE: GtkSourceBracketMatchType = 0;
37pub const GTK_SOURCE_BRACKET_MATCH_OUT_OF_RANGE: GtkSourceBracketMatchType = 1;
38pub const GTK_SOURCE_BRACKET_MATCH_NOT_FOUND: GtkSourceBracketMatchType = 2;
39pub const GTK_SOURCE_BRACKET_MATCH_FOUND: GtkSourceBracketMatchType = 3;
40
41pub type GtkSourceChangeCaseType = c_int;
42pub const GTK_SOURCE_CHANGE_CASE_LOWER: GtkSourceChangeCaseType = 0;
43pub const GTK_SOURCE_CHANGE_CASE_UPPER: GtkSourceChangeCaseType = 1;
44pub const GTK_SOURCE_CHANGE_CASE_TOGGLE: GtkSourceChangeCaseType = 2;
45pub const GTK_SOURCE_CHANGE_CASE_TITLE: GtkSourceChangeCaseType = 3;
46
47pub type GtkSourceCompletionError = c_int;
48pub const GTK_SOURCE_COMPLETION_ERROR_ALREADY_BOUND: GtkSourceCompletionError = 0;
49pub const GTK_SOURCE_COMPLETION_ERROR_NOT_BOUND: GtkSourceCompletionError = 1;
50
51pub type GtkSourceCompressionType = c_int;
52pub const GTK_SOURCE_COMPRESSION_TYPE_NONE: GtkSourceCompressionType = 0;
53pub const GTK_SOURCE_COMPRESSION_TYPE_GZIP: GtkSourceCompressionType = 1;
54
55pub type GtkSourceFileLoaderError = c_int;
56pub const GTK_SOURCE_FILE_LOADER_ERROR_TOO_BIG: GtkSourceFileLoaderError = 0;
57pub const GTK_SOURCE_FILE_LOADER_ERROR_ENCODING_AUTO_DETECTION_FAILED: GtkSourceFileLoaderError = 1;
58pub const GTK_SOURCE_FILE_LOADER_ERROR_CONVERSION_FALLBACK: GtkSourceFileLoaderError = 2;
59
60pub type GtkSourceFileSaverError = c_int;
61pub const GTK_SOURCE_FILE_SAVER_ERROR_INVALID_CHARS: GtkSourceFileSaverError = 0;
62pub const GTK_SOURCE_FILE_SAVER_ERROR_EXTERNALLY_MODIFIED: GtkSourceFileSaverError = 1;
63
64pub type GtkSourceGutterRendererAlignmentMode = c_int;
65pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_CELL: GtkSourceGutterRendererAlignmentMode = 0;
66pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_FIRST: GtkSourceGutterRendererAlignmentMode = 1;
67pub const GTK_SOURCE_GUTTER_RENDERER_ALIGNMENT_MODE_LAST: GtkSourceGutterRendererAlignmentMode = 2;
68
69pub type GtkSourceNewlineType = c_int;
70pub const GTK_SOURCE_NEWLINE_TYPE_LF: GtkSourceNewlineType = 0;
71pub const GTK_SOURCE_NEWLINE_TYPE_CR: GtkSourceNewlineType = 1;
72pub const GTK_SOURCE_NEWLINE_TYPE_CR_LF: GtkSourceNewlineType = 2;
73
74pub type GtkSourceSmartHomeEndType = c_int;
75pub const GTK_SOURCE_SMART_HOME_END_DISABLED: GtkSourceSmartHomeEndType = 0;
76pub const GTK_SOURCE_SMART_HOME_END_BEFORE: GtkSourceSmartHomeEndType = 1;
77pub const GTK_SOURCE_SMART_HOME_END_AFTER: GtkSourceSmartHomeEndType = 2;
78pub const GTK_SOURCE_SMART_HOME_END_ALWAYS: GtkSourceSmartHomeEndType = 3;
79
80pub type GtkSourceViewGutterPosition = c_int;
81pub const GTK_SOURCE_VIEW_GUTTER_POSITION_LINES: GtkSourceViewGutterPosition = -30;
82pub const GTK_SOURCE_VIEW_GUTTER_POSITION_MARKS: GtkSourceViewGutterPosition = -20;
83
84pub type GtkSourceCompletionActivation = c_uint;
86pub const GTK_SOURCE_COMPLETION_ACTIVATION_NONE: GtkSourceCompletionActivation = 0;
87pub const GTK_SOURCE_COMPLETION_ACTIVATION_INTERACTIVE: GtkSourceCompletionActivation = 1;
88pub const GTK_SOURCE_COMPLETION_ACTIVATION_USER_REQUESTED: GtkSourceCompletionActivation = 2;
89
90pub type GtkSourceDrawSpacesFlags = c_uint;
91pub const GTK_SOURCE_DRAW_SPACES_SPACE: GtkSourceDrawSpacesFlags = 1;
92pub const GTK_SOURCE_DRAW_SPACES_TAB: GtkSourceDrawSpacesFlags = 2;
93pub const GTK_SOURCE_DRAW_SPACES_NEWLINE: GtkSourceDrawSpacesFlags = 4;
94pub const GTK_SOURCE_DRAW_SPACES_NBSP: GtkSourceDrawSpacesFlags = 8;
95pub const GTK_SOURCE_DRAW_SPACES_LEADING: GtkSourceDrawSpacesFlags = 16;
96pub const GTK_SOURCE_DRAW_SPACES_TEXT: GtkSourceDrawSpacesFlags = 32;
97pub const GTK_SOURCE_DRAW_SPACES_TRAILING: GtkSourceDrawSpacesFlags = 64;
98pub const GTK_SOURCE_DRAW_SPACES_ALL: GtkSourceDrawSpacesFlags = 127;
99
100pub type GtkSourceFileSaverFlags = c_uint;
101pub const GTK_SOURCE_FILE_SAVER_FLAGS_NONE: GtkSourceFileSaverFlags = 0;
102pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_INVALID_CHARS: GtkSourceFileSaverFlags = 1;
103pub const GTK_SOURCE_FILE_SAVER_FLAGS_IGNORE_MODIFICATION_TIME: GtkSourceFileSaverFlags = 2;
104pub const GTK_SOURCE_FILE_SAVER_FLAGS_CREATE_BACKUP: GtkSourceFileSaverFlags = 4;
105
106pub type GtkSourceGutterRendererState = c_uint;
107pub const GTK_SOURCE_GUTTER_RENDERER_STATE_NORMAL: GtkSourceGutterRendererState = 0;
108pub const GTK_SOURCE_GUTTER_RENDERER_STATE_CURSOR: GtkSourceGutterRendererState = 1;
109pub const GTK_SOURCE_GUTTER_RENDERER_STATE_PRELIT: GtkSourceGutterRendererState = 2;
110pub const GTK_SOURCE_GUTTER_RENDERER_STATE_SELECTED: GtkSourceGutterRendererState = 4;
111
112pub type GtkSourceSortFlags = c_uint;
113pub const GTK_SOURCE_SORT_FLAGS_NONE: GtkSourceSortFlags = 0;
114pub const GTK_SOURCE_SORT_FLAGS_CASE_SENSITIVE: GtkSourceSortFlags = 1;
115pub const GTK_SOURCE_SORT_FLAGS_REVERSE_ORDER: GtkSourceSortFlags = 2;
116pub const GTK_SOURCE_SORT_FLAGS_REMOVE_DUPLICATES: GtkSourceSortFlags = 4;
117
118pub type GtkSourceSpaceLocationFlags = c_uint;
119pub const GTK_SOURCE_SPACE_LOCATION_NONE: GtkSourceSpaceLocationFlags = 0;
120pub const GTK_SOURCE_SPACE_LOCATION_LEADING: GtkSourceSpaceLocationFlags = 1;
121pub const GTK_SOURCE_SPACE_LOCATION_INSIDE_TEXT: GtkSourceSpaceLocationFlags = 2;
122pub const GTK_SOURCE_SPACE_LOCATION_TRAILING: GtkSourceSpaceLocationFlags = 4;
123pub const GTK_SOURCE_SPACE_LOCATION_ALL: GtkSourceSpaceLocationFlags = 7;
124
125pub type GtkSourceSpaceTypeFlags = c_uint;
126pub const GTK_SOURCE_SPACE_TYPE_NONE: GtkSourceSpaceTypeFlags = 0;
127pub const GTK_SOURCE_SPACE_TYPE_SPACE: GtkSourceSpaceTypeFlags = 1;
128pub const GTK_SOURCE_SPACE_TYPE_TAB: GtkSourceSpaceTypeFlags = 2;
129pub const GTK_SOURCE_SPACE_TYPE_NEWLINE: GtkSourceSpaceTypeFlags = 4;
130pub const GTK_SOURCE_SPACE_TYPE_NBSP: GtkSourceSpaceTypeFlags = 8;
131pub const GTK_SOURCE_SPACE_TYPE_ALL: GtkSourceSpaceTypeFlags = 15;
132
133pub type GtkSourceMountOperationFactory =
135 Option<unsafe extern "C" fn(*mut GtkSourceFile, gpointer) -> *mut gio::GMountOperation>;
136
137#[repr(C)]
139#[derive(Copy, Clone)]
140pub struct GtkSourceBufferClass {
141 pub parent_class: gtk::GtkTextBufferClass,
142 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>,
143 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceBuffer)>,
144 pub bracket_matched: Option<
145 unsafe extern "C" fn(
146 *mut GtkSourceBuffer,
147 *mut gtk::GtkTextIter,
148 GtkSourceBracketMatchType,
149 ),
150 >,
151 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
152 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
153 pub _gtk_source_reserved3: Option<unsafe extern "C" fn()>,
154}
155
156impl ::std::fmt::Debug for GtkSourceBufferClass {
157 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
158 f.debug_struct(&format!("GtkSourceBufferClass @ {:?}", self as *const _))
159 .field("parent_class", &self.parent_class)
160 .field("undo", &self.undo)
161 .field("redo", &self.redo)
162 .field("bracket_matched", &self.bracket_matched)
163 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
164 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
165 .field("_gtk_source_reserved3", &self._gtk_source_reserved3)
166 .finish()
167 }
168}
169
170#[repr(C)]
171pub struct _GtkSourceBufferPrivate(c_void);
172
173pub type GtkSourceBufferPrivate = *mut _GtkSourceBufferPrivate;
174
175#[repr(C)]
176#[derive(Copy, Clone)]
177pub struct GtkSourceCompletionClass {
178 pub parent_class: gobject::GObjectClass,
179 pub proposal_activated: Option<
180 unsafe extern "C" fn(
181 *mut GtkSourceCompletion,
182 *mut GtkSourceCompletionProvider,
183 *mut GtkSourceCompletionProposal,
184 ) -> gboolean,
185 >,
186 pub show: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
187 pub hide: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
188 pub populate_context:
189 Option<unsafe extern "C" fn(*mut GtkSourceCompletion, *mut GtkSourceCompletionContext)>,
190 pub move_cursor:
191 Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>,
192 pub move_page:
193 Option<unsafe extern "C" fn(*mut GtkSourceCompletion, gtk::GtkScrollStep, c_int)>,
194 pub activate_proposal: Option<unsafe extern "C" fn(*mut GtkSourceCompletion)>,
195}
196
197impl ::std::fmt::Debug for GtkSourceCompletionClass {
198 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
199 f.debug_struct(&format!(
200 "GtkSourceCompletionClass @ {:?}",
201 self as *const _
202 ))
203 .field("parent_class", &self.parent_class)
204 .field("proposal_activated", &self.proposal_activated)
205 .field("show", &self.show)
206 .field("hide", &self.hide)
207 .field("populate_context", &self.populate_context)
208 .field("move_cursor", &self.move_cursor)
209 .field("move_page", &self.move_page)
210 .field("activate_proposal", &self.activate_proposal)
211 .finish()
212 }
213}
214
215#[repr(C)]
216#[derive(Copy, Clone)]
217pub struct GtkSourceCompletionContextClass {
218 pub parent_class: gobject::GInitiallyUnownedClass,
219 pub cancelled: Option<unsafe extern "C" fn(*mut GtkSourceCompletionContext)>,
220 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
221 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
222 pub _gtk_source_reserved3: Option<unsafe extern "C" fn()>,
223}
224
225impl ::std::fmt::Debug for GtkSourceCompletionContextClass {
226 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
227 f.debug_struct(&format!(
228 "GtkSourceCompletionContextClass @ {:?}",
229 self as *const _
230 ))
231 .field("parent_class", &self.parent_class)
232 .field("cancelled", &self.cancelled)
233 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
234 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
235 .field("_gtk_source_reserved3", &self._gtk_source_reserved3)
236 .finish()
237 }
238}
239
240#[repr(C)]
241pub struct _GtkSourceCompletionContextPrivate(c_void);
242
243pub type GtkSourceCompletionContextPrivate = *mut _GtkSourceCompletionContextPrivate;
244
245#[repr(C)]
246#[derive(Copy, Clone)]
247pub struct GtkSourceCompletionInfoClass {
248 pub parent_class: gtk::GtkWindowClass,
249 pub before_show: Option<unsafe extern "C" fn(*mut GtkSourceCompletionInfo)>,
250}
251
252impl ::std::fmt::Debug for GtkSourceCompletionInfoClass {
253 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
254 f.debug_struct(&format!(
255 "GtkSourceCompletionInfoClass @ {:?}",
256 self as *const _
257 ))
258 .field("parent_class", &self.parent_class)
259 .field("before_show", &self.before_show)
260 .finish()
261 }
262}
263
264#[repr(C)]
265pub struct _GtkSourceCompletionInfoPrivate(c_void);
266
267pub type GtkSourceCompletionInfoPrivate = *mut _GtkSourceCompletionInfoPrivate;
268
269#[repr(C)]
270#[derive(Copy, Clone)]
271pub struct GtkSourceCompletionItemClass {
272 pub parent_class: gobject::GObjectClass,
273}
274
275impl ::std::fmt::Debug for GtkSourceCompletionItemClass {
276 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
277 f.debug_struct(&format!(
278 "GtkSourceCompletionItemClass @ {:?}",
279 self as *const _
280 ))
281 .field("parent_class", &self.parent_class)
282 .finish()
283 }
284}
285
286#[repr(C)]
287pub struct _GtkSourceCompletionItemPrivate(c_void);
288
289pub type GtkSourceCompletionItemPrivate = *mut _GtkSourceCompletionItemPrivate;
290
291#[repr(C)]
292pub struct _GtkSourceCompletionPrivate(c_void);
293
294pub type GtkSourceCompletionPrivate = *mut _GtkSourceCompletionPrivate;
295
296#[repr(C)]
297#[derive(Copy, Clone)]
298pub struct GtkSourceCompletionProposalIface {
299 pub parent: gobject::GTypeInterface,
300 pub get_label: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
301 pub get_markup: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
302 pub get_text: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
303 pub get_icon: Option<
304 unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gdk_pixbuf::GdkPixbuf,
305 >,
306 pub get_icon_name:
307 Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
308 pub get_gicon:
309 Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut gio::GIcon>,
310 pub get_info: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> *mut c_char>,
311 pub hash: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal) -> c_uint>,
312 pub equal: Option<
313 unsafe extern "C" fn(
314 *mut GtkSourceCompletionProposal,
315 *mut GtkSourceCompletionProposal,
316 ) -> gboolean,
317 >,
318 pub changed: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProposal)>,
319}
320
321impl ::std::fmt::Debug for GtkSourceCompletionProposalIface {
322 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
323 f.debug_struct(&format!(
324 "GtkSourceCompletionProposalIface @ {:?}",
325 self as *const _
326 ))
327 .field("parent", &self.parent)
328 .field("get_label", &self.get_label)
329 .field("get_markup", &self.get_markup)
330 .field("get_text", &self.get_text)
331 .field("get_icon", &self.get_icon)
332 .field("get_icon_name", &self.get_icon_name)
333 .field("get_gicon", &self.get_gicon)
334 .field("get_info", &self.get_info)
335 .field("hash", &self.hash)
336 .field("equal", &self.equal)
337 .field("changed", &self.changed)
338 .finish()
339 }
340}
341
342#[repr(C)]
343#[derive(Copy, Clone)]
344pub struct GtkSourceCompletionProviderIface {
345 pub g_iface: gobject::GTypeInterface,
346 pub get_name: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>,
347 pub get_icon: Option<
348 unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gdk_pixbuf::GdkPixbuf,
349 >,
350 pub get_icon_name:
351 Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *const c_char>,
352 pub get_gicon:
353 Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> *mut gio::GIcon>,
354 pub populate: Option<
355 unsafe extern "C" fn(*mut GtkSourceCompletionProvider, *mut GtkSourceCompletionContext),
356 >,
357 pub match_: Option<
358 unsafe extern "C" fn(
359 *mut GtkSourceCompletionProvider,
360 *mut GtkSourceCompletionContext,
361 ) -> gboolean,
362 >,
363 pub get_activation: Option<
364 unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> GtkSourceCompletionActivation,
365 >,
366 pub get_info_widget: Option<
367 unsafe extern "C" fn(
368 *mut GtkSourceCompletionProvider,
369 *mut GtkSourceCompletionProposal,
370 ) -> *mut gtk::GtkWidget,
371 >,
372 pub update_info: Option<
373 unsafe extern "C" fn(
374 *mut GtkSourceCompletionProvider,
375 *mut GtkSourceCompletionProposal,
376 *mut GtkSourceCompletionInfo,
377 ),
378 >,
379 pub get_start_iter: Option<
380 unsafe extern "C" fn(
381 *mut GtkSourceCompletionProvider,
382 *mut GtkSourceCompletionContext,
383 *mut GtkSourceCompletionProposal,
384 *mut gtk::GtkTextIter,
385 ) -> gboolean,
386 >,
387 pub activate_proposal: Option<
388 unsafe extern "C" fn(
389 *mut GtkSourceCompletionProvider,
390 *mut GtkSourceCompletionProposal,
391 *mut gtk::GtkTextIter,
392 ) -> gboolean,
393 >,
394 pub get_interactive_delay:
395 Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>,
396 pub get_priority: Option<unsafe extern "C" fn(*mut GtkSourceCompletionProvider) -> c_int>,
397}
398
399impl ::std::fmt::Debug for GtkSourceCompletionProviderIface {
400 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
401 f.debug_struct(&format!(
402 "GtkSourceCompletionProviderIface @ {:?}",
403 self as *const _
404 ))
405 .field("g_iface", &self.g_iface)
406 .field("get_name", &self.get_name)
407 .field("get_icon", &self.get_icon)
408 .field("get_icon_name", &self.get_icon_name)
409 .field("get_gicon", &self.get_gicon)
410 .field("populate", &self.populate)
411 .field("match_", &self.match_)
412 .field("get_activation", &self.get_activation)
413 .field("get_info_widget", &self.get_info_widget)
414 .field("update_info", &self.update_info)
415 .field("get_start_iter", &self.get_start_iter)
416 .field("activate_proposal", &self.activate_proposal)
417 .field("get_interactive_delay", &self.get_interactive_delay)
418 .field("get_priority", &self.get_priority)
419 .finish()
420 }
421}
422
423#[repr(C)]
424#[derive(Copy, Clone)]
425pub struct GtkSourceCompletionWordsClass {
426 pub parent_class: gobject::GObjectClass,
427}
428
429impl ::std::fmt::Debug for GtkSourceCompletionWordsClass {
430 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
431 f.debug_struct(&format!(
432 "GtkSourceCompletionWordsClass @ {:?}",
433 self as *const _
434 ))
435 .field("parent_class", &self.parent_class)
436 .finish()
437 }
438}
439
440#[repr(C)]
441pub struct _GtkSourceCompletionWordsPrivate(c_void);
442
443pub type GtkSourceCompletionWordsPrivate = *mut _GtkSourceCompletionWordsPrivate;
444
445#[repr(C)]
446pub struct GtkSourceEncoding(c_void);
447
448impl ::std::fmt::Debug for GtkSourceEncoding {
449 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
450 f.debug_struct(&format!("GtkSourceEncoding @ {:?}", self as *const _))
451 .finish()
452 }
453}
454
455#[repr(C)]
456#[derive(Copy, Clone)]
457pub struct GtkSourceFileClass {
458 pub parent_class: gobject::GObjectClass,
459 pub padding: [gpointer; 10],
460}
461
462impl ::std::fmt::Debug for GtkSourceFileClass {
463 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
464 f.debug_struct(&format!("GtkSourceFileClass @ {:?}", self as *const _))
465 .field("parent_class", &self.parent_class)
466 .field("padding", &self.padding)
467 .finish()
468 }
469}
470
471#[repr(C)]
472#[derive(Copy, Clone)]
473pub struct GtkSourceFileLoaderClass {
474 pub parent_class: gobject::GObjectClass,
475 pub padding: [gpointer; 10],
476}
477
478impl ::std::fmt::Debug for GtkSourceFileLoaderClass {
479 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
480 f.debug_struct(&format!(
481 "GtkSourceFileLoaderClass @ {:?}",
482 self as *const _
483 ))
484 .field("parent_class", &self.parent_class)
485 .field("padding", &self.padding)
486 .finish()
487 }
488}
489
490#[repr(C)]
491pub struct _GtkSourceFileLoaderPrivate(c_void);
492
493pub type GtkSourceFileLoaderPrivate = *mut _GtkSourceFileLoaderPrivate;
494
495#[repr(C)]
496pub struct _GtkSourceFilePrivate(c_void);
497
498pub type GtkSourceFilePrivate = *mut _GtkSourceFilePrivate;
499
500#[repr(C)]
501#[derive(Copy, Clone)]
502pub struct GtkSourceFileSaverClass {
503 pub parent_class: gobject::GObjectClass,
504 pub padding: [gpointer; 10],
505}
506
507impl ::std::fmt::Debug for GtkSourceFileSaverClass {
508 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
509 f.debug_struct(&format!("GtkSourceFileSaverClass @ {:?}", self as *const _))
510 .field("parent_class", &self.parent_class)
511 .field("padding", &self.padding)
512 .finish()
513 }
514}
515
516#[repr(C)]
517pub struct _GtkSourceFileSaverPrivate(c_void);
518
519pub type GtkSourceFileSaverPrivate = *mut _GtkSourceFileSaverPrivate;
520
521#[repr(C)]
522#[derive(Copy, Clone)]
523pub struct GtkSourceGutterClass {
524 pub parent_class: gobject::GObjectClass,
525}
526
527impl ::std::fmt::Debug for GtkSourceGutterClass {
528 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
529 f.debug_struct(&format!("GtkSourceGutterClass @ {:?}", self as *const _))
530 .field("parent_class", &self.parent_class)
531 .finish()
532 }
533}
534
535#[repr(C)]
536pub struct _GtkSourceGutterPrivate(c_void);
537
538pub type GtkSourceGutterPrivate = *mut _GtkSourceGutterPrivate;
539
540#[repr(C)]
541#[derive(Copy, Clone)]
542pub struct GtkSourceGutterRendererClass {
543 pub parent_class: gobject::GInitiallyUnownedClass,
544 pub begin: Option<
545 unsafe extern "C" fn(
546 *mut GtkSourceGutterRenderer,
547 *mut cairo::cairo_t,
548 *mut gdk::GdkRectangle,
549 *mut gdk::GdkRectangle,
550 *mut gtk::GtkTextIter,
551 *mut gtk::GtkTextIter,
552 ),
553 >,
554 pub draw: Option<
555 unsafe extern "C" fn(
556 *mut GtkSourceGutterRenderer,
557 *mut cairo::cairo_t,
558 *mut gdk::GdkRectangle,
559 *mut gdk::GdkRectangle,
560 *mut gtk::GtkTextIter,
561 *mut gtk::GtkTextIter,
562 GtkSourceGutterRendererState,
563 ),
564 >,
565 pub end: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>,
566 pub change_view:
567 Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextView)>,
568 pub change_buffer:
569 Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer, *mut gtk::GtkTextBuffer)>,
570 pub query_activatable: Option<
571 unsafe extern "C" fn(
572 *mut GtkSourceGutterRenderer,
573 *mut gtk::GtkTextIter,
574 *mut gdk::GdkRectangle,
575 *mut gdk::GdkEvent,
576 ) -> gboolean,
577 >,
578 pub activate: Option<
579 unsafe extern "C" fn(
580 *mut GtkSourceGutterRenderer,
581 *mut gtk::GtkTextIter,
582 *mut gdk::GdkRectangle,
583 *mut gdk::GdkEvent,
584 ),
585 >,
586 pub queue_draw: Option<unsafe extern "C" fn(*mut GtkSourceGutterRenderer)>,
587 pub query_tooltip: Option<
588 unsafe extern "C" fn(
589 *mut GtkSourceGutterRenderer,
590 *mut gtk::GtkTextIter,
591 *mut gdk::GdkRectangle,
592 c_int,
593 c_int,
594 *mut gtk::GtkTooltip,
595 ) -> gboolean,
596 >,
597 pub query_data: Option<
598 unsafe extern "C" fn(
599 *mut GtkSourceGutterRenderer,
600 *mut gtk::GtkTextIter,
601 *mut gtk::GtkTextIter,
602 GtkSourceGutterRendererState,
603 ),
604 >,
605}
606
607impl ::std::fmt::Debug for GtkSourceGutterRendererClass {
608 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
609 f.debug_struct(&format!(
610 "GtkSourceGutterRendererClass @ {:?}",
611 self as *const _
612 ))
613 .field("parent_class", &self.parent_class)
614 .field("begin", &self.begin)
615 .field("draw", &self.draw)
616 .field("end", &self.end)
617 .field("change_view", &self.change_view)
618 .field("change_buffer", &self.change_buffer)
619 .field("query_activatable", &self.query_activatable)
620 .field("activate", &self.activate)
621 .field("queue_draw", &self.queue_draw)
622 .field("query_tooltip", &self.query_tooltip)
623 .field("query_data", &self.query_data)
624 .finish()
625 }
626}
627
628#[repr(C)]
629#[derive(Copy, Clone)]
630pub struct GtkSourceGutterRendererPixbufClass {
631 pub parent_class: GtkSourceGutterRendererClass,
632}
633
634impl ::std::fmt::Debug for GtkSourceGutterRendererPixbufClass {
635 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
636 f.debug_struct(&format!(
637 "GtkSourceGutterRendererPixbufClass @ {:?}",
638 self as *const _
639 ))
640 .finish()
641 }
642}
643
644#[repr(C)]
645pub struct _GtkSourceGutterRendererPixbufPrivate(c_void);
646
647pub type GtkSourceGutterRendererPixbufPrivate = *mut _GtkSourceGutterRendererPixbufPrivate;
648
649#[repr(C)]
650pub struct _GtkSourceGutterRendererPrivate(c_void);
651
652pub type GtkSourceGutterRendererPrivate = *mut _GtkSourceGutterRendererPrivate;
653
654#[repr(C)]
655#[derive(Copy, Clone)]
656pub struct GtkSourceGutterRendererTextClass {
657 pub parent_class: GtkSourceGutterRendererClass,
658}
659
660impl ::std::fmt::Debug for GtkSourceGutterRendererTextClass {
661 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
662 f.debug_struct(&format!(
663 "GtkSourceGutterRendererTextClass @ {:?}",
664 self as *const _
665 ))
666 .finish()
667 }
668}
669
670#[repr(C)]
671pub struct _GtkSourceGutterRendererTextPrivate(c_void);
672
673pub type GtkSourceGutterRendererTextPrivate = *mut _GtkSourceGutterRendererTextPrivate;
674
675#[repr(C)]
676#[derive(Copy, Clone)]
677pub struct GtkSourceLanguageClass {
678 pub parent_class: gobject::GObjectClass,
679 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
680 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
681}
682
683impl ::std::fmt::Debug for GtkSourceLanguageClass {
684 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
685 f.debug_struct(&format!("GtkSourceLanguageClass @ {:?}", self as *const _))
686 .field("parent_class", &self.parent_class)
687 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
688 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
689 .finish()
690 }
691}
692
693#[repr(C)]
694#[derive(Copy, Clone)]
695pub struct GtkSourceLanguageManagerClass {
696 pub parent_class: gobject::GObjectClass,
697 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
698 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
699 pub _gtk_source_reserved3: Option<unsafe extern "C" fn()>,
700 pub _gtk_source_reserved4: Option<unsafe extern "C" fn()>,
701}
702
703impl ::std::fmt::Debug for GtkSourceLanguageManagerClass {
704 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
705 f.debug_struct(&format!(
706 "GtkSourceLanguageManagerClass @ {:?}",
707 self as *const _
708 ))
709 .field("parent_class", &self.parent_class)
710 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
711 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
712 .field("_gtk_source_reserved3", &self._gtk_source_reserved3)
713 .field("_gtk_source_reserved4", &self._gtk_source_reserved4)
714 .finish()
715 }
716}
717
718#[repr(C)]
719pub struct _GtkSourceLanguageManagerPrivate(c_void);
720
721pub type GtkSourceLanguageManagerPrivate = *mut _GtkSourceLanguageManagerPrivate;
722
723#[repr(C)]
724pub struct _GtkSourceLanguagePrivate(c_void);
725
726pub type GtkSourceLanguagePrivate = *mut _GtkSourceLanguagePrivate;
727
728#[repr(C)]
729#[derive(Copy, Clone)]
730pub struct GtkSourceMapClass {
731 pub parent_class: GtkSourceViewClass,
732 pub padding: [gpointer; 10],
733}
734
735impl ::std::fmt::Debug for GtkSourceMapClass {
736 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
737 f.debug_struct(&format!("GtkSourceMapClass @ {:?}", self as *const _))
738 .field("parent_class", &self.parent_class)
739 .field("padding", &self.padding)
740 .finish()
741 }
742}
743
744#[repr(C)]
745#[derive(Copy, Clone)]
746pub struct GtkSourceMarkAttributesClass {
747 pub parent_class: gobject::GObjectClass,
748}
749
750impl ::std::fmt::Debug for GtkSourceMarkAttributesClass {
751 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
752 f.debug_struct(&format!(
753 "GtkSourceMarkAttributesClass @ {:?}",
754 self as *const _
755 ))
756 .finish()
757 }
758}
759
760#[repr(C)]
761pub struct _GtkSourceMarkAttributesPrivate(c_void);
762
763pub type GtkSourceMarkAttributesPrivate = *mut _GtkSourceMarkAttributesPrivate;
764
765#[repr(C)]
766#[derive(Copy, Clone)]
767pub struct GtkSourceMarkClass {
768 pub parent_class: gtk::GtkTextMarkClass,
769 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
770 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
771}
772
773impl ::std::fmt::Debug for GtkSourceMarkClass {
774 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
775 f.debug_struct(&format!("GtkSourceMarkClass @ {:?}", self as *const _))
776 .field("parent_class", &self.parent_class)
777 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
778 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
779 .finish()
780 }
781}
782
783#[repr(C)]
784pub struct _GtkSourceMarkPrivate(c_void);
785
786pub type GtkSourceMarkPrivate = *mut _GtkSourceMarkPrivate;
787
788#[repr(C)]
789#[derive(Copy, Clone)]
790pub struct GtkSourcePrintCompositorClass {
791 pub parent_class: gobject::GObjectClass,
792 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
793 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
794}
795
796impl ::std::fmt::Debug for GtkSourcePrintCompositorClass {
797 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
798 f.debug_struct(&format!(
799 "GtkSourcePrintCompositorClass @ {:?}",
800 self as *const _
801 ))
802 .field("parent_class", &self.parent_class)
803 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
804 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
805 .finish()
806 }
807}
808
809#[repr(C)]
810pub struct _GtkSourcePrintCompositorPrivate(c_void);
811
812pub type GtkSourcePrintCompositorPrivate = *mut _GtkSourcePrintCompositorPrivate;
813
814#[repr(C)]
815#[derive(Copy, Clone)]
816pub struct GtkSourceRegionClass {
817 pub parent_class: gobject::GObjectClass,
818 pub padding: [gpointer; 8],
819}
820
821impl ::std::fmt::Debug for GtkSourceRegionClass {
822 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
823 f.debug_struct(&format!("GtkSourceRegionClass @ {:?}", self as *const _))
824 .field("parent_class", &self.parent_class)
825 .field("padding", &self.padding)
826 .finish()
827 }
828}
829
830#[repr(C)]
831#[derive(Copy, Clone)]
832pub struct GtkSourceRegionIter {
833 pub dummy1: gpointer,
834 pub dummy2: u32,
835 pub dummy3: gpointer,
836}
837
838impl ::std::fmt::Debug for GtkSourceRegionIter {
839 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
840 f.debug_struct(&format!("GtkSourceRegionIter @ {:?}", self as *const _))
841 .finish()
842 }
843}
844
845#[repr(C)]
846#[derive(Copy, Clone)]
847pub struct GtkSourceSearchContextClass {
848 pub parent_class: gobject::GObjectClass,
849 pub padding: [gpointer; 10],
850}
851
852impl ::std::fmt::Debug for GtkSourceSearchContextClass {
853 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
854 f.debug_struct(&format!(
855 "GtkSourceSearchContextClass @ {:?}",
856 self as *const _
857 ))
858 .field("parent_class", &self.parent_class)
859 .field("padding", &self.padding)
860 .finish()
861 }
862}
863
864#[repr(C)]
865pub struct _GtkSourceSearchContextPrivate(c_void);
866
867pub type GtkSourceSearchContextPrivate = *mut _GtkSourceSearchContextPrivate;
868
869#[repr(C)]
870#[derive(Copy, Clone)]
871pub struct GtkSourceSearchSettingsClass {
872 pub parent_class: gobject::GObjectClass,
873 pub padding: [gpointer; 10],
874}
875
876impl ::std::fmt::Debug for GtkSourceSearchSettingsClass {
877 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
878 f.debug_struct(&format!(
879 "GtkSourceSearchSettingsClass @ {:?}",
880 self as *const _
881 ))
882 .field("parent_class", &self.parent_class)
883 .field("padding", &self.padding)
884 .finish()
885 }
886}
887
888#[repr(C)]
889pub struct _GtkSourceSearchSettingsPrivate(c_void);
890
891pub type GtkSourceSearchSettingsPrivate = *mut _GtkSourceSearchSettingsPrivate;
892
893#[repr(C)]
894#[derive(Copy, Clone)]
895pub struct GtkSourceSpaceDrawerClass {
896 pub parent_class: gobject::GObjectClass,
897 pub padding: [gpointer; 20],
898}
899
900impl ::std::fmt::Debug for GtkSourceSpaceDrawerClass {
901 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
902 f.debug_struct(&format!(
903 "GtkSourceSpaceDrawerClass @ {:?}",
904 self as *const _
905 ))
906 .field("parent_class", &self.parent_class)
907 .field("padding", &self.padding)
908 .finish()
909 }
910}
911
912#[repr(C)]
913pub struct _GtkSourceSpaceDrawerPrivate(c_void);
914
915pub type GtkSourceSpaceDrawerPrivate = *mut _GtkSourceSpaceDrawerPrivate;
916
917#[repr(C)]
918pub struct _GtkSourceStyleClass(c_void);
919
920pub type GtkSourceStyleClass = *mut _GtkSourceStyleClass;
921
922#[repr(C)]
923#[derive(Copy, Clone)]
924pub struct GtkSourceStyleSchemeChooserButtonClass {
925 pub parent: gtk::GtkButtonClass,
926}
927
928impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButtonClass {
929 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
930 f.debug_struct(&format!(
931 "GtkSourceStyleSchemeChooserButtonClass @ {:?}",
932 self as *const _
933 ))
934 .field("parent", &self.parent)
935 .finish()
936 }
937}
938
939#[repr(C)]
940#[derive(Copy, Clone)]
941pub struct GtkSourceStyleSchemeChooserInterface {
942 pub base_interface: gobject::GTypeInterface,
943 pub get_style_scheme:
944 Option<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser) -> *mut GtkSourceStyleScheme>,
945 pub set_style_scheme:
946 Option<unsafe extern "C" fn(*mut GtkSourceStyleSchemeChooser, *mut GtkSourceStyleScheme)>,
947 pub padding: [gpointer; 12],
948}
949
950impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserInterface {
951 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
952 f.debug_struct(&format!(
953 "GtkSourceStyleSchemeChooserInterface @ {:?}",
954 self as *const _
955 ))
956 .field("base_interface", &self.base_interface)
957 .field("get_style_scheme", &self.get_style_scheme)
958 .field("set_style_scheme", &self.set_style_scheme)
959 .field("padding", &self.padding)
960 .finish()
961 }
962}
963
964#[repr(C)]
965#[derive(Copy, Clone)]
966pub struct GtkSourceStyleSchemeChooserWidgetClass {
967 pub parent: gtk::GtkBinClass,
968}
969
970impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidgetClass {
971 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
972 f.debug_struct(&format!(
973 "GtkSourceStyleSchemeChooserWidgetClass @ {:?}",
974 self as *const _
975 ))
976 .field("parent", &self.parent)
977 .finish()
978 }
979}
980
981#[repr(C)]
982#[derive(Copy, Clone)]
983pub struct GtkSourceStyleSchemeClass {
984 pub base_class: gobject::GObjectClass,
985 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
986 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
987}
988
989impl ::std::fmt::Debug for GtkSourceStyleSchemeClass {
990 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
991 f.debug_struct(&format!(
992 "GtkSourceStyleSchemeClass @ {:?}",
993 self as *const _
994 ))
995 .field("base_class", &self.base_class)
996 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
997 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
998 .finish()
999 }
1000}
1001
1002#[repr(C)]
1003#[derive(Copy, Clone)]
1004pub struct GtkSourceStyleSchemeManagerClass {
1005 pub parent_class: gobject::GObjectClass,
1006 pub _gtk_source_reserved1: Option<unsafe extern "C" fn()>,
1007 pub _gtk_source_reserved2: Option<unsafe extern "C" fn()>,
1008 pub _gtk_source_reserved3: Option<unsafe extern "C" fn()>,
1009 pub _gtk_source_reserved4: Option<unsafe extern "C" fn()>,
1010}
1011
1012impl ::std::fmt::Debug for GtkSourceStyleSchemeManagerClass {
1013 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1014 f.debug_struct(&format!(
1015 "GtkSourceStyleSchemeManagerClass @ {:?}",
1016 self as *const _
1017 ))
1018 .field("parent_class", &self.parent_class)
1019 .field("_gtk_source_reserved1", &self._gtk_source_reserved1)
1020 .field("_gtk_source_reserved2", &self._gtk_source_reserved2)
1021 .field("_gtk_source_reserved3", &self._gtk_source_reserved3)
1022 .field("_gtk_source_reserved4", &self._gtk_source_reserved4)
1023 .finish()
1024 }
1025}
1026
1027#[repr(C)]
1028pub struct _GtkSourceStyleSchemeManagerPrivate(c_void);
1029
1030pub type GtkSourceStyleSchemeManagerPrivate = *mut _GtkSourceStyleSchemeManagerPrivate;
1031
1032#[repr(C)]
1033pub struct _GtkSourceStyleSchemePrivate(c_void);
1034
1035pub type GtkSourceStyleSchemePrivate = *mut _GtkSourceStyleSchemePrivate;
1036
1037#[repr(C)]
1038#[derive(Copy, Clone)]
1039pub struct GtkSourceTagClass {
1040 pub parent_class: gtk::GtkTextTagClass,
1041 pub padding: [gpointer; 10],
1042}
1043
1044impl ::std::fmt::Debug for GtkSourceTagClass {
1045 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1046 f.debug_struct(&format!("GtkSourceTagClass @ {:?}", self as *const _))
1047 .field("parent_class", &self.parent_class)
1048 .field("padding", &self.padding)
1049 .finish()
1050 }
1051}
1052
1053#[repr(C)]
1054#[derive(Copy, Clone)]
1055pub struct GtkSourceUndoManagerIface {
1056 pub parent: gobject::GTypeInterface,
1057 pub can_undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>,
1058 pub can_redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager) -> gboolean>,
1059 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1060 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1061 pub begin_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1062 pub end_not_undoable_action: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1063 pub can_undo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1064 pub can_redo_changed: Option<unsafe extern "C" fn(*mut GtkSourceUndoManager)>,
1065}
1066
1067impl ::std::fmt::Debug for GtkSourceUndoManagerIface {
1068 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1069 f.debug_struct(&format!(
1070 "GtkSourceUndoManagerIface @ {:?}",
1071 self as *const _
1072 ))
1073 .field("parent", &self.parent)
1074 .field("can_undo", &self.can_undo)
1075 .field("can_redo", &self.can_redo)
1076 .field("undo", &self.undo)
1077 .field("redo", &self.redo)
1078 .field("begin_not_undoable_action", &self.begin_not_undoable_action)
1079 .field("end_not_undoable_action", &self.end_not_undoable_action)
1080 .field("can_undo_changed", &self.can_undo_changed)
1081 .field("can_redo_changed", &self.can_redo_changed)
1082 .finish()
1083 }
1084}
1085
1086#[repr(C)]
1087#[derive(Copy, Clone)]
1088pub struct GtkSourceViewClass {
1089 pub parent_class: gtk::GtkTextViewClass,
1090 pub undo: Option<unsafe extern "C" fn(*mut GtkSourceView)>,
1091 pub redo: Option<unsafe extern "C" fn(*mut GtkSourceView)>,
1092 pub line_mark_activated:
1093 Option<unsafe extern "C" fn(*mut GtkSourceView, *mut gtk::GtkTextIter, *mut gdk::GdkEvent)>,
1094 pub show_completion: Option<unsafe extern "C" fn(*mut GtkSourceView)>,
1095 pub move_lines: Option<unsafe extern "C" fn(*mut GtkSourceView, gboolean, c_int)>,
1096 pub move_words: Option<unsafe extern "C" fn(*mut GtkSourceView, c_int)>,
1097}
1098
1099impl ::std::fmt::Debug for GtkSourceViewClass {
1100 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1101 f.debug_struct(&format!("GtkSourceViewClass @ {:?}", self as *const _))
1102 .field("parent_class", &self.parent_class)
1103 .field("undo", &self.undo)
1104 .field("redo", &self.redo)
1105 .field("line_mark_activated", &self.line_mark_activated)
1106 .field("show_completion", &self.show_completion)
1107 .field("move_lines", &self.move_lines)
1108 .field("move_words", &self.move_words)
1109 .finish()
1110 }
1111}
1112
1113#[repr(C)]
1114pub struct _GtkSourceViewPrivate(c_void);
1115
1116pub type GtkSourceViewPrivate = *mut _GtkSourceViewPrivate;
1117
1118#[repr(C)]
1120#[derive(Copy, Clone)]
1121pub struct GtkSourceBuffer {
1122 pub parent_instance: gtk::GtkTextBuffer,
1123 pub priv_: *mut GtkSourceBufferPrivate,
1124}
1125
1126impl ::std::fmt::Debug for GtkSourceBuffer {
1127 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1128 f.debug_struct(&format!("GtkSourceBuffer @ {:?}", self as *const _))
1129 .field("parent_instance", &self.parent_instance)
1130 .field("priv_", &self.priv_)
1131 .finish()
1132 }
1133}
1134
1135#[repr(C)]
1136#[derive(Copy, Clone)]
1137pub struct GtkSourceCompletion {
1138 pub parent_instance: gobject::GObject,
1139 pub priv_: *mut GtkSourceCompletionPrivate,
1140}
1141
1142impl ::std::fmt::Debug for GtkSourceCompletion {
1143 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1144 f.debug_struct(&format!("GtkSourceCompletion @ {:?}", self as *const _))
1145 .field("parent_instance", &self.parent_instance)
1146 .field("priv_", &self.priv_)
1147 .finish()
1148 }
1149}
1150
1151#[repr(C)]
1152#[derive(Copy, Clone)]
1153pub struct GtkSourceCompletionContext {
1154 pub parent: gobject::GInitiallyUnowned,
1155 pub priv_: *mut GtkSourceCompletionContextPrivate,
1156}
1157
1158impl ::std::fmt::Debug for GtkSourceCompletionContext {
1159 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1160 f.debug_struct(&format!(
1161 "GtkSourceCompletionContext @ {:?}",
1162 self as *const _
1163 ))
1164 .field("parent", &self.parent)
1165 .field("priv_", &self.priv_)
1166 .finish()
1167 }
1168}
1169
1170#[repr(C)]
1171#[derive(Copy, Clone)]
1172pub struct GtkSourceCompletionInfo {
1173 pub parent: gtk::GtkWindow,
1174 pub priv_: *mut GtkSourceCompletionInfoPrivate,
1175}
1176
1177impl ::std::fmt::Debug for GtkSourceCompletionInfo {
1178 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1179 f.debug_struct(&format!("GtkSourceCompletionInfo @ {:?}", self as *const _))
1180 .field("parent", &self.parent)
1181 .field("priv_", &self.priv_)
1182 .finish()
1183 }
1184}
1185
1186#[repr(C)]
1187#[derive(Copy, Clone)]
1188pub struct GtkSourceCompletionItem {
1189 pub parent: gobject::GObject,
1190 pub priv_: *mut GtkSourceCompletionItemPrivate,
1191}
1192
1193impl ::std::fmt::Debug for GtkSourceCompletionItem {
1194 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1195 f.debug_struct(&format!("GtkSourceCompletionItem @ {:?}", self as *const _))
1196 .field("parent", &self.parent)
1197 .field("priv_", &self.priv_)
1198 .finish()
1199 }
1200}
1201
1202#[repr(C)]
1203#[derive(Copy, Clone)]
1204pub struct GtkSourceCompletionWords {
1205 pub parent: gobject::GObject,
1206 pub priv_: *mut GtkSourceCompletionWordsPrivate,
1207}
1208
1209impl ::std::fmt::Debug for GtkSourceCompletionWords {
1210 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1211 f.debug_struct(&format!(
1212 "GtkSourceCompletionWords @ {:?}",
1213 self as *const _
1214 ))
1215 .field("parent", &self.parent)
1216 .field("priv_", &self.priv_)
1217 .finish()
1218 }
1219}
1220
1221#[repr(C)]
1222#[derive(Copy, Clone)]
1223pub struct GtkSourceFile {
1224 pub parent: gobject::GObject,
1225 pub priv_: *mut GtkSourceFilePrivate,
1226}
1227
1228impl ::std::fmt::Debug for GtkSourceFile {
1229 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1230 f.debug_struct(&format!("GtkSourceFile @ {:?}", self as *const _))
1231 .field("parent", &self.parent)
1232 .field("priv_", &self.priv_)
1233 .finish()
1234 }
1235}
1236
1237#[repr(C)]
1238#[derive(Copy, Clone)]
1239pub struct GtkSourceFileLoader {
1240 pub parent: gobject::GObject,
1241 pub priv_: *mut GtkSourceFileLoaderPrivate,
1242}
1243
1244impl ::std::fmt::Debug for GtkSourceFileLoader {
1245 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1246 f.debug_struct(&format!("GtkSourceFileLoader @ {:?}", self as *const _))
1247 .field("parent", &self.parent)
1248 .field("priv_", &self.priv_)
1249 .finish()
1250 }
1251}
1252
1253#[repr(C)]
1254#[derive(Copy, Clone)]
1255pub struct GtkSourceFileSaver {
1256 pub object: gobject::GObject,
1257 pub priv_: *mut GtkSourceFileSaverPrivate,
1258}
1259
1260impl ::std::fmt::Debug for GtkSourceFileSaver {
1261 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1262 f.debug_struct(&format!("GtkSourceFileSaver @ {:?}", self as *const _))
1263 .field("object", &self.object)
1264 .field("priv_", &self.priv_)
1265 .finish()
1266 }
1267}
1268
1269#[repr(C)]
1270#[derive(Copy, Clone)]
1271pub struct GtkSourceGutter {
1272 pub parent: gobject::GObject,
1273 pub priv_: *mut GtkSourceGutterPrivate,
1274}
1275
1276impl ::std::fmt::Debug for GtkSourceGutter {
1277 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1278 f.debug_struct(&format!("GtkSourceGutter @ {:?}", self as *const _))
1279 .field("parent", &self.parent)
1280 .field("priv_", &self.priv_)
1281 .finish()
1282 }
1283}
1284
1285#[repr(C)]
1286#[derive(Copy, Clone)]
1287pub struct GtkSourceGutterRenderer {
1288 pub parent: gobject::GInitiallyUnowned,
1289 pub priv_: *mut GtkSourceGutterRendererPrivate,
1290}
1291
1292impl ::std::fmt::Debug for GtkSourceGutterRenderer {
1293 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1294 f.debug_struct(&format!("GtkSourceGutterRenderer @ {:?}", self as *const _))
1295 .field("parent", &self.parent)
1296 .finish()
1297 }
1298}
1299
1300#[repr(C)]
1301#[derive(Copy, Clone)]
1302pub struct GtkSourceGutterRendererPixbuf {
1303 pub parent: GtkSourceGutterRenderer,
1304 pub priv_: *mut GtkSourceGutterRendererPixbufPrivate,
1305}
1306
1307impl ::std::fmt::Debug for GtkSourceGutterRendererPixbuf {
1308 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1309 f.debug_struct(&format!(
1310 "GtkSourceGutterRendererPixbuf @ {:?}",
1311 self as *const _
1312 ))
1313 .finish()
1314 }
1315}
1316
1317#[repr(C)]
1318#[derive(Copy, Clone)]
1319pub struct GtkSourceGutterRendererText {
1320 pub parent: GtkSourceGutterRenderer,
1321 pub priv_: *mut GtkSourceGutterRendererTextPrivate,
1322}
1323
1324impl ::std::fmt::Debug for GtkSourceGutterRendererText {
1325 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1326 f.debug_struct(&format!(
1327 "GtkSourceGutterRendererText @ {:?}",
1328 self as *const _
1329 ))
1330 .finish()
1331 }
1332}
1333
1334#[repr(C)]
1335#[derive(Copy, Clone)]
1336pub struct GtkSourceLanguage {
1337 pub parent_instance: gobject::GObject,
1338 pub priv_: *mut GtkSourceLanguagePrivate,
1339}
1340
1341impl ::std::fmt::Debug for GtkSourceLanguage {
1342 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1343 f.debug_struct(&format!("GtkSourceLanguage @ {:?}", self as *const _))
1344 .field("parent_instance", &self.parent_instance)
1345 .field("priv_", &self.priv_)
1346 .finish()
1347 }
1348}
1349
1350#[repr(C)]
1351#[derive(Copy, Clone)]
1352pub struct GtkSourceLanguageManager {
1353 pub parent_instance: gobject::GObject,
1354 pub priv_: *mut GtkSourceLanguageManagerPrivate,
1355}
1356
1357impl ::std::fmt::Debug for GtkSourceLanguageManager {
1358 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1359 f.debug_struct(&format!(
1360 "GtkSourceLanguageManager @ {:?}",
1361 self as *const _
1362 ))
1363 .field("parent_instance", &self.parent_instance)
1364 .field("priv_", &self.priv_)
1365 .finish()
1366 }
1367}
1368
1369#[repr(C)]
1370#[derive(Copy, Clone)]
1371pub struct GtkSourceMap {
1372 pub parent_instance: GtkSourceView,
1373}
1374
1375impl ::std::fmt::Debug for GtkSourceMap {
1376 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1377 f.debug_struct(&format!("GtkSourceMap @ {:?}", self as *const _))
1378 .field("parent_instance", &self.parent_instance)
1379 .finish()
1380 }
1381}
1382
1383#[repr(C)]
1384#[derive(Copy, Clone)]
1385pub struct GtkSourceMark {
1386 pub parent_instance: gtk::GtkTextMark,
1387 pub priv_: *mut GtkSourceMarkPrivate,
1388}
1389
1390impl ::std::fmt::Debug for GtkSourceMark {
1391 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1392 f.debug_struct(&format!("GtkSourceMark @ {:?}", self as *const _))
1393 .field("parent_instance", &self.parent_instance)
1394 .field("priv_", &self.priv_)
1395 .finish()
1396 }
1397}
1398
1399#[repr(C)]
1400#[derive(Copy, Clone)]
1401pub struct GtkSourceMarkAttributes {
1402 pub parent: gobject::GObject,
1403 pub priv_: *mut GtkSourceMarkAttributesPrivate,
1404}
1405
1406impl ::std::fmt::Debug for GtkSourceMarkAttributes {
1407 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1408 f.debug_struct(&format!("GtkSourceMarkAttributes @ {:?}", self as *const _))
1409 .finish()
1410 }
1411}
1412
1413#[repr(C)]
1414#[derive(Copy, Clone)]
1415pub struct GtkSourcePrintCompositor {
1416 pub parent_instance: gobject::GObject,
1417 pub priv_: *mut GtkSourcePrintCompositorPrivate,
1418}
1419
1420impl ::std::fmt::Debug for GtkSourcePrintCompositor {
1421 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1422 f.debug_struct(&format!(
1423 "GtkSourcePrintCompositor @ {:?}",
1424 self as *const _
1425 ))
1426 .field("parent_instance", &self.parent_instance)
1427 .field("priv_", &self.priv_)
1428 .finish()
1429 }
1430}
1431
1432#[repr(C)]
1433#[derive(Copy, Clone)]
1434pub struct GtkSourceRegion {
1435 pub parent_instance: gobject::GObject,
1436}
1437
1438impl ::std::fmt::Debug for GtkSourceRegion {
1439 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1440 f.debug_struct(&format!("GtkSourceRegion @ {:?}", self as *const _))
1441 .field("parent_instance", &self.parent_instance)
1442 .finish()
1443 }
1444}
1445
1446#[repr(C)]
1447#[derive(Copy, Clone)]
1448pub struct GtkSourceSearchContext {
1449 pub parent: gobject::GObject,
1450 pub priv_: *mut GtkSourceSearchContextPrivate,
1451}
1452
1453impl ::std::fmt::Debug for GtkSourceSearchContext {
1454 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1455 f.debug_struct(&format!("GtkSourceSearchContext @ {:?}", self as *const _))
1456 .field("parent", &self.parent)
1457 .field("priv_", &self.priv_)
1458 .finish()
1459 }
1460}
1461
1462#[repr(C)]
1463#[derive(Copy, Clone)]
1464pub struct GtkSourceSearchSettings {
1465 pub parent: gobject::GObject,
1466 pub priv_: *mut GtkSourceSearchSettingsPrivate,
1467}
1468
1469impl ::std::fmt::Debug for GtkSourceSearchSettings {
1470 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1471 f.debug_struct(&format!("GtkSourceSearchSettings @ {:?}", self as *const _))
1472 .field("parent", &self.parent)
1473 .field("priv_", &self.priv_)
1474 .finish()
1475 }
1476}
1477
1478#[repr(C)]
1479#[derive(Copy, Clone)]
1480pub struct GtkSourceSpaceDrawer {
1481 pub parent: gobject::GObject,
1482 pub priv_: *mut GtkSourceSpaceDrawerPrivate,
1483}
1484
1485impl ::std::fmt::Debug for GtkSourceSpaceDrawer {
1486 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1487 f.debug_struct(&format!("GtkSourceSpaceDrawer @ {:?}", self as *const _))
1488 .field("parent", &self.parent)
1489 .field("priv_", &self.priv_)
1490 .finish()
1491 }
1492}
1493
1494#[repr(C)]
1495pub struct GtkSourceStyle(c_void);
1496
1497impl ::std::fmt::Debug for GtkSourceStyle {
1498 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1499 f.debug_struct(&format!("GtkSourceStyle @ {:?}", self as *const _))
1500 .finish()
1501 }
1502}
1503
1504#[repr(C)]
1505#[derive(Copy, Clone)]
1506pub struct GtkSourceStyleScheme {
1507 pub base: gobject::GObject,
1508 pub priv_: *mut GtkSourceStyleSchemePrivate,
1509}
1510
1511impl ::std::fmt::Debug for GtkSourceStyleScheme {
1512 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1513 f.debug_struct(&format!("GtkSourceStyleScheme @ {:?}", self as *const _))
1514 .field("base", &self.base)
1515 .field("priv_", &self.priv_)
1516 .finish()
1517 }
1518}
1519
1520#[repr(C)]
1521#[derive(Copy, Clone)]
1522pub struct GtkSourceStyleSchemeChooserButton {
1523 pub parent: gtk::GtkButton,
1524}
1525
1526impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserButton {
1527 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1528 f.debug_struct(&format!(
1529 "GtkSourceStyleSchemeChooserButton @ {:?}",
1530 self as *const _
1531 ))
1532 .field("parent", &self.parent)
1533 .finish()
1534 }
1535}
1536
1537#[repr(C)]
1538#[derive(Copy, Clone)]
1539pub struct GtkSourceStyleSchemeChooserWidget {
1540 pub parent: gtk::GtkBin,
1541}
1542
1543impl ::std::fmt::Debug for GtkSourceStyleSchemeChooserWidget {
1544 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1545 f.debug_struct(&format!(
1546 "GtkSourceStyleSchemeChooserWidget @ {:?}",
1547 self as *const _
1548 ))
1549 .field("parent", &self.parent)
1550 .finish()
1551 }
1552}
1553
1554#[repr(C)]
1555#[derive(Copy, Clone)]
1556pub struct GtkSourceStyleSchemeManager {
1557 pub parent: gobject::GObject,
1558 pub priv_: *mut GtkSourceStyleSchemeManagerPrivate,
1559}
1560
1561impl ::std::fmt::Debug for GtkSourceStyleSchemeManager {
1562 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1563 f.debug_struct(&format!(
1564 "GtkSourceStyleSchemeManager @ {:?}",
1565 self as *const _
1566 ))
1567 .field("parent", &self.parent)
1568 .field("priv_", &self.priv_)
1569 .finish()
1570 }
1571}
1572
1573#[repr(C)]
1574#[derive(Copy, Clone)]
1575pub struct GtkSourceTag {
1576 pub parent_instance: gtk::GtkTextTag,
1577}
1578
1579impl ::std::fmt::Debug for GtkSourceTag {
1580 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1581 f.debug_struct(&format!("GtkSourceTag @ {:?}", self as *const _))
1582 .field("parent_instance", &self.parent_instance)
1583 .finish()
1584 }
1585}
1586
1587#[repr(C)]
1588#[derive(Copy, Clone)]
1589pub struct GtkSourceView {
1590 pub parent: gtk::GtkTextView,
1591 pub priv_: *mut GtkSourceViewPrivate,
1592}
1593
1594impl ::std::fmt::Debug for GtkSourceView {
1595 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1596 f.debug_struct(&format!("GtkSourceView @ {:?}", self as *const _))
1597 .field("parent", &self.parent)
1598 .field("priv_", &self.priv_)
1599 .finish()
1600 }
1601}
1602
1603#[repr(C)]
1605pub struct GtkSourceCompletionProposal(c_void);
1606
1607impl ::std::fmt::Debug for GtkSourceCompletionProposal {
1608 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1609 write!(f, "GtkSourceCompletionProposal @ {:?}", self as *const _)
1610 }
1611}
1612
1613#[repr(C)]
1614pub struct GtkSourceCompletionProvider(c_void);
1615
1616impl ::std::fmt::Debug for GtkSourceCompletionProvider {
1617 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1618 write!(f, "GtkSourceCompletionProvider @ {:?}", self as *const _)
1619 }
1620}
1621
1622#[repr(C)]
1623pub struct GtkSourceStyleSchemeChooser(c_void);
1624
1625impl ::std::fmt::Debug for GtkSourceStyleSchemeChooser {
1626 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1627 write!(f, "GtkSourceStyleSchemeChooser @ {:?}", self as *const _)
1628 }
1629}
1630
1631#[repr(C)]
1632pub struct GtkSourceUndoManager(c_void);
1633
1634impl ::std::fmt::Debug for GtkSourceUndoManager {
1635 fn fmt(&self, f: &mut ::std::fmt::Formatter) -> ::std::fmt::Result {
1636 write!(f, "GtkSourceUndoManager @ {:?}", self as *const _)
1637 }
1638}
1639
1640extern "C" {
1641
1642 pub fn gtk_source_background_pattern_type_get_type() -> GType;
1646
1647 pub fn gtk_source_bracket_match_type_get_type() -> GType;
1651
1652 pub fn gtk_source_change_case_type_get_type() -> GType;
1656
1657 pub fn gtk_source_completion_error_get_type() -> GType;
1661 pub fn gtk_source_completion_error_quark() -> glib::GQuark;
1662
1663 pub fn gtk_source_compression_type_get_type() -> GType;
1667
1668 pub fn gtk_source_file_loader_error_get_type() -> GType;
1672 pub fn gtk_source_file_loader_error_quark() -> glib::GQuark;
1673
1674 pub fn gtk_source_file_saver_error_get_type() -> GType;
1678 pub fn gtk_source_file_saver_error_quark() -> glib::GQuark;
1679
1680 pub fn gtk_source_gutter_renderer_alignment_mode_get_type() -> GType;
1684
1685 pub fn gtk_source_newline_type_get_type() -> GType;
1689
1690 pub fn gtk_source_smart_home_end_type_get_type() -> GType;
1694
1695 pub fn gtk_source_view_gutter_position_get_type() -> GType;
1699
1700 pub fn gtk_source_completion_activation_get_type() -> GType;
1704
1705 pub fn gtk_source_draw_spaces_flags_get_type() -> GType;
1709
1710 pub fn gtk_source_file_saver_flags_get_type() -> GType;
1714
1715 pub fn gtk_source_gutter_renderer_state_get_type() -> GType;
1719
1720 pub fn gtk_source_sort_flags_get_type() -> GType;
1724
1725 pub fn gtk_source_space_location_flags_get_type() -> GType;
1729
1730 pub fn gtk_source_space_type_flags_get_type() -> GType;
1734
1735 pub fn gtk_source_encoding_get_type() -> GType;
1739 #[cfg(any(feature = "v3_14", feature = "dox"))]
1740 pub fn gtk_source_encoding_copy(enc: *const GtkSourceEncoding) -> *mut GtkSourceEncoding;
1741 #[cfg(any(feature = "v3_14", feature = "dox"))]
1742 pub fn gtk_source_encoding_free(enc: *mut GtkSourceEncoding);
1743 #[cfg(any(feature = "v3_14", feature = "dox"))]
1744 pub fn gtk_source_encoding_get_charset(enc: *const GtkSourceEncoding) -> *const c_char;
1745 #[cfg(any(feature = "v3_14", feature = "dox"))]
1746 pub fn gtk_source_encoding_get_name(enc: *const GtkSourceEncoding) -> *const c_char;
1747 #[cfg(any(feature = "v3_14", feature = "dox"))]
1748 pub fn gtk_source_encoding_to_string(enc: *const GtkSourceEncoding) -> *mut c_char;
1749 #[cfg(any(feature = "v3_14", feature = "dox"))]
1750 pub fn gtk_source_encoding_get_all() -> *mut glib::GSList;
1751 #[cfg(any(feature = "v3_14", feature = "dox"))]
1752 pub fn gtk_source_encoding_get_current() -> *const GtkSourceEncoding;
1753 #[cfg(any(feature = "v3_18", feature = "dox"))]
1754 pub fn gtk_source_encoding_get_default_candidates() -> *mut glib::GSList;
1755 #[cfg(any(feature = "v3_14", feature = "dox"))]
1756 pub fn gtk_source_encoding_get_from_charset(charset: *const c_char)
1757 -> *const GtkSourceEncoding;
1758 #[cfg(any(feature = "v3_14", feature = "dox"))]
1759 pub fn gtk_source_encoding_get_utf8() -> *const GtkSourceEncoding;
1760
1761 #[cfg(any(feature = "v3_22", feature = "dox"))]
1765 pub fn gtk_source_region_iter_get_subregion(
1766 iter: *mut GtkSourceRegionIter,
1767 start: *mut gtk::GtkTextIter,
1768 end: *mut gtk::GtkTextIter,
1769 ) -> gboolean;
1770 #[cfg(any(feature = "v3_22", feature = "dox"))]
1771 pub fn gtk_source_region_iter_is_end(iter: *mut GtkSourceRegionIter) -> gboolean;
1772 #[cfg(any(feature = "v3_22", feature = "dox"))]
1773 pub fn gtk_source_region_iter_next(iter: *mut GtkSourceRegionIter) -> gboolean;
1774
1775 pub fn gtk_source_buffer_get_type() -> GType;
1779 pub fn gtk_source_buffer_new(table: *mut gtk::GtkTextTagTable) -> *mut GtkSourceBuffer;
1780 pub fn gtk_source_buffer_new_with_language(
1781 language: *mut GtkSourceLanguage,
1782 ) -> *mut GtkSourceBuffer;
1783 pub fn gtk_source_buffer_backward_iter_to_source_mark(
1784 buffer: *mut GtkSourceBuffer,
1785 iter: *mut gtk::GtkTextIter,
1786 category: *const c_char,
1787 ) -> gboolean;
1788 pub fn gtk_source_buffer_begin_not_undoable_action(buffer: *mut GtkSourceBuffer);
1789 pub fn gtk_source_buffer_can_redo(buffer: *mut GtkSourceBuffer) -> gboolean;
1790 pub fn gtk_source_buffer_can_undo(buffer: *mut GtkSourceBuffer) -> gboolean;
1791 #[cfg(any(feature = "v3_12", feature = "dox"))]
1792 pub fn gtk_source_buffer_change_case(
1793 buffer: *mut GtkSourceBuffer,
1794 case_type: GtkSourceChangeCaseType,
1795 start: *mut gtk::GtkTextIter,
1796 end: *mut gtk::GtkTextIter,
1797 );
1798 pub fn gtk_source_buffer_create_source_mark(
1799 buffer: *mut GtkSourceBuffer,
1800 name: *const c_char,
1801 category: *const c_char,
1802 where_: *const gtk::GtkTextIter,
1803 ) -> *mut GtkSourceMark;
1804 #[cfg(any(feature = "v3_20", feature = "dox"))]
1805 pub fn gtk_source_buffer_create_source_tag(
1806 buffer: *mut GtkSourceBuffer,
1807 tag_name: *const c_char,
1808 first_property_name: *const c_char,
1809 ...
1810 ) -> *mut gtk::GtkTextTag;
1811 pub fn gtk_source_buffer_end_not_undoable_action(buffer: *mut GtkSourceBuffer);
1812 pub fn gtk_source_buffer_ensure_highlight(
1813 buffer: *mut GtkSourceBuffer,
1814 start: *const gtk::GtkTextIter,
1815 end: *const gtk::GtkTextIter,
1816 );
1817 pub fn gtk_source_buffer_forward_iter_to_source_mark(
1818 buffer: *mut GtkSourceBuffer,
1819 iter: *mut gtk::GtkTextIter,
1820 category: *const c_char,
1821 ) -> gboolean;
1822 pub fn gtk_source_buffer_get_context_classes_at_iter(
1823 buffer: *mut GtkSourceBuffer,
1824 iter: *const gtk::GtkTextIter,
1825 ) -> *mut *mut c_char;
1826 pub fn gtk_source_buffer_get_highlight_matching_brackets(
1827 buffer: *mut GtkSourceBuffer,
1828 ) -> gboolean;
1829 pub fn gtk_source_buffer_get_highlight_syntax(buffer: *mut GtkSourceBuffer) -> gboolean;
1830 #[cfg(any(feature = "v3_14", feature = "dox"))]
1831 pub fn gtk_source_buffer_get_implicit_trailing_newline(
1832 buffer: *mut GtkSourceBuffer,
1833 ) -> gboolean;
1834 pub fn gtk_source_buffer_get_language(buffer: *mut GtkSourceBuffer) -> *mut GtkSourceLanguage;
1835 pub fn gtk_source_buffer_get_max_undo_levels(buffer: *mut GtkSourceBuffer) -> c_int;
1836 pub fn gtk_source_buffer_get_source_marks_at_iter(
1837 buffer: *mut GtkSourceBuffer,
1838 iter: *mut gtk::GtkTextIter,
1839 category: *const c_char,
1840 ) -> *mut glib::GSList;
1841 pub fn gtk_source_buffer_get_source_marks_at_line(
1842 buffer: *mut GtkSourceBuffer,
1843 line: c_int,
1844 category: *const c_char,
1845 ) -> *mut glib::GSList;
1846 pub fn gtk_source_buffer_get_style_scheme(
1847 buffer: *mut GtkSourceBuffer,
1848 ) -> *mut GtkSourceStyleScheme;
1849 pub fn gtk_source_buffer_get_undo_manager(
1850 buffer: *mut GtkSourceBuffer,
1851 ) -> *mut GtkSourceUndoManager;
1852 pub fn gtk_source_buffer_iter_backward_to_context_class_toggle(
1853 buffer: *mut GtkSourceBuffer,
1854 iter: *mut gtk::GtkTextIter,
1855 context_class: *const c_char,
1856 ) -> gboolean;
1857 pub fn gtk_source_buffer_iter_forward_to_context_class_toggle(
1858 buffer: *mut GtkSourceBuffer,
1859 iter: *mut gtk::GtkTextIter,
1860 context_class: *const c_char,
1861 ) -> gboolean;
1862 pub fn gtk_source_buffer_iter_has_context_class(
1863 buffer: *mut GtkSourceBuffer,
1864 iter: *const gtk::GtkTextIter,
1865 context_class: *const c_char,
1866 ) -> gboolean;
1867 #[cfg(any(feature = "v3_16", feature = "dox"))]
1868 pub fn gtk_source_buffer_join_lines(
1869 buffer: *mut GtkSourceBuffer,
1870 start: *mut gtk::GtkTextIter,
1871 end: *mut gtk::GtkTextIter,
1872 );
1873 pub fn gtk_source_buffer_redo(buffer: *mut GtkSourceBuffer);
1874 pub fn gtk_source_buffer_remove_source_marks(
1875 buffer: *mut GtkSourceBuffer,
1876 start: *const gtk::GtkTextIter,
1877 end: *const gtk::GtkTextIter,
1878 category: *const c_char,
1879 );
1880 pub fn gtk_source_buffer_set_highlight_matching_brackets(
1881 buffer: *mut GtkSourceBuffer,
1882 highlight: gboolean,
1883 );
1884 pub fn gtk_source_buffer_set_highlight_syntax(
1885 buffer: *mut GtkSourceBuffer,
1886 highlight: gboolean,
1887 );
1888 #[cfg(any(feature = "v3_14", feature = "dox"))]
1889 pub fn gtk_source_buffer_set_implicit_trailing_newline(
1890 buffer: *mut GtkSourceBuffer,
1891 implicit_trailing_newline: gboolean,
1892 );
1893 pub fn gtk_source_buffer_set_language(
1894 buffer: *mut GtkSourceBuffer,
1895 language: *mut GtkSourceLanguage,
1896 );
1897 pub fn gtk_source_buffer_set_max_undo_levels(
1898 buffer: *mut GtkSourceBuffer,
1899 max_undo_levels: c_int,
1900 );
1901 pub fn gtk_source_buffer_set_style_scheme(
1902 buffer: *mut GtkSourceBuffer,
1903 scheme: *mut GtkSourceStyleScheme,
1904 );
1905 pub fn gtk_source_buffer_set_undo_manager(
1906 buffer: *mut GtkSourceBuffer,
1907 manager: *mut GtkSourceUndoManager,
1908 );
1909 #[cfg(any(feature = "v3_18", feature = "dox"))]
1910 pub fn gtk_source_buffer_sort_lines(
1911 buffer: *mut GtkSourceBuffer,
1912 start: *mut gtk::GtkTextIter,
1913 end: *mut gtk::GtkTextIter,
1914 flags: GtkSourceSortFlags,
1915 column: c_int,
1916 );
1917 pub fn gtk_source_buffer_undo(buffer: *mut GtkSourceBuffer);
1918
1919 pub fn gtk_source_completion_get_type() -> GType;
1923 pub fn gtk_source_completion_add_provider(
1924 completion: *mut GtkSourceCompletion,
1925 provider: *mut GtkSourceCompletionProvider,
1926 error: *mut *mut glib::GError,
1927 ) -> gboolean;
1928 pub fn gtk_source_completion_block_interactive(completion: *mut GtkSourceCompletion);
1929 pub fn gtk_source_completion_create_context(
1930 completion: *mut GtkSourceCompletion,
1931 position: *mut gtk::GtkTextIter,
1932 ) -> *mut GtkSourceCompletionContext;
1933 pub fn gtk_source_completion_get_info_window(
1934 completion: *mut GtkSourceCompletion,
1935 ) -> *mut GtkSourceCompletionInfo;
1936 pub fn gtk_source_completion_get_providers(
1937 completion: *mut GtkSourceCompletion,
1938 ) -> *mut glib::GList;
1939 pub fn gtk_source_completion_get_view(
1940 completion: *mut GtkSourceCompletion,
1941 ) -> *mut GtkSourceView;
1942 pub fn gtk_source_completion_hide(completion: *mut GtkSourceCompletion);
1943 pub fn gtk_source_completion_move_window(
1944 completion: *mut GtkSourceCompletion,
1945 iter: *mut gtk::GtkTextIter,
1946 );
1947 pub fn gtk_source_completion_remove_provider(
1948 completion: *mut GtkSourceCompletion,
1949 provider: *mut GtkSourceCompletionProvider,
1950 error: *mut *mut glib::GError,
1951 ) -> gboolean;
1952 pub fn gtk_source_completion_show(
1953 completion: *mut GtkSourceCompletion,
1954 providers: *mut glib::GList,
1955 context: *mut GtkSourceCompletionContext,
1956 ) -> gboolean;
1957 pub fn gtk_source_completion_unblock_interactive(completion: *mut GtkSourceCompletion);
1958
1959 pub fn gtk_source_completion_context_get_type() -> GType;
1963 pub fn gtk_source_completion_context_add_proposals(
1964 context: *mut GtkSourceCompletionContext,
1965 provider: *mut GtkSourceCompletionProvider,
1966 proposals: *mut glib::GList,
1967 finished: gboolean,
1968 );
1969 pub fn gtk_source_completion_context_get_activation(
1970 context: *mut GtkSourceCompletionContext,
1971 ) -> GtkSourceCompletionActivation;
1972 pub fn gtk_source_completion_context_get_iter(
1973 context: *mut GtkSourceCompletionContext,
1974 iter: *mut gtk::GtkTextIter,
1975 ) -> gboolean;
1976
1977 pub fn gtk_source_completion_info_get_type() -> GType;
1981 pub fn gtk_source_completion_info_new() -> *mut GtkSourceCompletionInfo;
1982 pub fn gtk_source_completion_info_get_widget(
1983 info: *mut GtkSourceCompletionInfo,
1984 ) -> *mut gtk::GtkWidget;
1985 pub fn gtk_source_completion_info_move_to_iter(
1986 info: *mut GtkSourceCompletionInfo,
1987 view: *mut gtk::GtkTextView,
1988 iter: *mut gtk::GtkTextIter,
1989 );
1990 pub fn gtk_source_completion_info_set_widget(
1991 info: *mut GtkSourceCompletionInfo,
1992 widget: *mut gtk::GtkWidget,
1993 );
1994
1995 pub fn gtk_source_completion_item_get_type() -> GType;
1999 pub fn gtk_source_completion_item_new(
2000 label: *const c_char,
2001 text: *const c_char,
2002 icon: *mut gdk_pixbuf::GdkPixbuf,
2003 info: *const c_char,
2004 ) -> *mut GtkSourceCompletionItem;
2005 pub fn gtk_source_completion_item_new_from_stock(
2006 label: *const c_char,
2007 text: *const c_char,
2008 stock: *const c_char,
2009 info: *const c_char,
2010 ) -> *mut GtkSourceCompletionItem;
2011 pub fn gtk_source_completion_item_new_with_markup(
2012 markup: *const c_char,
2013 text: *const c_char,
2014 icon: *mut gdk_pixbuf::GdkPixbuf,
2015 info: *const c_char,
2016 ) -> *mut GtkSourceCompletionItem;
2017 #[cfg(any(feature = "v3_24", feature = "dox"))]
2018 pub fn gtk_source_completion_item_new2() -> *mut GtkSourceCompletionItem;
2019 #[cfg(any(feature = "v3_24", feature = "dox"))]
2020 pub fn gtk_source_completion_item_set_gicon(
2021 item: *mut GtkSourceCompletionItem,
2022 gicon: *mut gio::GIcon,
2023 );
2024 #[cfg(any(feature = "v3_24", feature = "dox"))]
2025 pub fn gtk_source_completion_item_set_icon(
2026 item: *mut GtkSourceCompletionItem,
2027 icon: *mut gdk_pixbuf::GdkPixbuf,
2028 );
2029 #[cfg(any(feature = "v3_24", feature = "dox"))]
2030 pub fn gtk_source_completion_item_set_icon_name(
2031 item: *mut GtkSourceCompletionItem,
2032 icon_name: *const c_char,
2033 );
2034 #[cfg(any(feature = "v3_24", feature = "dox"))]
2035 pub fn gtk_source_completion_item_set_info(
2036 item: *mut GtkSourceCompletionItem,
2037 info: *const c_char,
2038 );
2039 #[cfg(any(feature = "v3_24", feature = "dox"))]
2040 pub fn gtk_source_completion_item_set_label(
2041 item: *mut GtkSourceCompletionItem,
2042 label: *const c_char,
2043 );
2044 #[cfg(any(feature = "v3_24", feature = "dox"))]
2045 pub fn gtk_source_completion_item_set_markup(
2046 item: *mut GtkSourceCompletionItem,
2047 markup: *const c_char,
2048 );
2049 #[cfg(any(feature = "v3_24", feature = "dox"))]
2050 pub fn gtk_source_completion_item_set_text(
2051 item: *mut GtkSourceCompletionItem,
2052 text: *const c_char,
2053 );
2054
2055 pub fn gtk_source_completion_words_get_type() -> GType;
2059 pub fn gtk_source_completion_words_new(
2060 name: *const c_char,
2061 icon: *mut gdk_pixbuf::GdkPixbuf,
2062 ) -> *mut GtkSourceCompletionWords;
2063 pub fn gtk_source_completion_words_register(
2064 words: *mut GtkSourceCompletionWords,
2065 buffer: *mut gtk::GtkTextBuffer,
2066 );
2067 pub fn gtk_source_completion_words_unregister(
2068 words: *mut GtkSourceCompletionWords,
2069 buffer: *mut gtk::GtkTextBuffer,
2070 );
2071
2072 pub fn gtk_source_file_get_type() -> GType;
2076 #[cfg(any(feature = "v3_14", feature = "dox"))]
2077 pub fn gtk_source_file_new() -> *mut GtkSourceFile;
2078 #[cfg(any(feature = "v3_18", feature = "dox"))]
2079 pub fn gtk_source_file_check_file_on_disk(file: *mut GtkSourceFile);
2080 #[cfg(any(feature = "v3_14", feature = "dox"))]
2081 pub fn gtk_source_file_get_compression_type(
2082 file: *mut GtkSourceFile,
2083 ) -> GtkSourceCompressionType;
2084 #[cfg(any(feature = "v3_14", feature = "dox"))]
2085 pub fn gtk_source_file_get_encoding(file: *mut GtkSourceFile) -> *const GtkSourceEncoding;
2086 #[cfg(any(feature = "v3_14", feature = "dox"))]
2087 pub fn gtk_source_file_get_location(file: *mut GtkSourceFile) -> *mut gio::GFile;
2088 #[cfg(any(feature = "v3_14", feature = "dox"))]
2089 pub fn gtk_source_file_get_newline_type(file: *mut GtkSourceFile) -> GtkSourceNewlineType;
2090 #[cfg(any(feature = "v3_18", feature = "dox"))]
2091 pub fn gtk_source_file_is_deleted(file: *mut GtkSourceFile) -> gboolean;
2092 #[cfg(any(feature = "v3_18", feature = "dox"))]
2093 pub fn gtk_source_file_is_externally_modified(file: *mut GtkSourceFile) -> gboolean;
2094 #[cfg(any(feature = "v3_18", feature = "dox"))]
2095 pub fn gtk_source_file_is_local(file: *mut GtkSourceFile) -> gboolean;
2096 #[cfg(any(feature = "v3_18", feature = "dox"))]
2097 pub fn gtk_source_file_is_readonly(file: *mut GtkSourceFile) -> gboolean;
2098 #[cfg(any(feature = "v3_14", feature = "dox"))]
2099 pub fn gtk_source_file_set_location(file: *mut GtkSourceFile, location: *mut gio::GFile);
2100 #[cfg(any(feature = "v3_14", feature = "dox"))]
2101 pub fn gtk_source_file_set_mount_operation_factory(
2102 file: *mut GtkSourceFile,
2103 callback: GtkSourceMountOperationFactory,
2104 user_data: gpointer,
2105 notify: glib::GDestroyNotify,
2106 );
2107
2108 pub fn gtk_source_file_loader_get_type() -> GType;
2112 #[cfg(any(feature = "v3_14", feature = "dox"))]
2113 pub fn gtk_source_file_loader_new(
2114 buffer: *mut GtkSourceBuffer,
2115 file: *mut GtkSourceFile,
2116 ) -> *mut GtkSourceFileLoader;
2117 #[cfg(any(feature = "v3_14", feature = "dox"))]
2118 pub fn gtk_source_file_loader_new_from_stream(
2119 buffer: *mut GtkSourceBuffer,
2120 file: *mut GtkSourceFile,
2121 stream: *mut gio::GInputStream,
2122 ) -> *mut GtkSourceFileLoader;
2123 #[cfg(any(feature = "v3_14", feature = "dox"))]
2124 pub fn gtk_source_file_loader_get_buffer(
2125 loader: *mut GtkSourceFileLoader,
2126 ) -> *mut GtkSourceBuffer;
2127 #[cfg(any(feature = "v3_14", feature = "dox"))]
2128 pub fn gtk_source_file_loader_get_compression_type(
2129 loader: *mut GtkSourceFileLoader,
2130 ) -> GtkSourceCompressionType;
2131 #[cfg(any(feature = "v3_14", feature = "dox"))]
2132 pub fn gtk_source_file_loader_get_encoding(
2133 loader: *mut GtkSourceFileLoader,
2134 ) -> *const GtkSourceEncoding;
2135 #[cfg(any(feature = "v3_14", feature = "dox"))]
2136 pub fn gtk_source_file_loader_get_file(loader: *mut GtkSourceFileLoader) -> *mut GtkSourceFile;
2137 #[cfg(any(feature = "v3_14", feature = "dox"))]
2138 pub fn gtk_source_file_loader_get_input_stream(
2139 loader: *mut GtkSourceFileLoader,
2140 ) -> *mut gio::GInputStream;
2141 #[cfg(any(feature = "v3_14", feature = "dox"))]
2142 pub fn gtk_source_file_loader_get_location(loader: *mut GtkSourceFileLoader)
2143 -> *mut gio::GFile;
2144 #[cfg(any(feature = "v3_14", feature = "dox"))]
2145 pub fn gtk_source_file_loader_get_newline_type(
2146 loader: *mut GtkSourceFileLoader,
2147 ) -> GtkSourceNewlineType;
2148 #[cfg(any(feature = "v3_14", feature = "dox"))]
2149 pub fn gtk_source_file_loader_load_async(
2150 loader: *mut GtkSourceFileLoader,
2151 io_priority: c_int,
2152 cancellable: *mut gio::GCancellable,
2153 progress_callback: gio::GFileProgressCallback,
2154 progress_callback_data: gpointer,
2155 progress_callback_notify: glib::GDestroyNotify,
2156 callback: gio::GAsyncReadyCallback,
2157 user_data: gpointer,
2158 );
2159 #[cfg(any(feature = "v3_14", feature = "dox"))]
2160 pub fn gtk_source_file_loader_load_finish(
2161 loader: *mut GtkSourceFileLoader,
2162 result: *mut gio::GAsyncResult,
2163 error: *mut *mut glib::GError,
2164 ) -> gboolean;
2165 #[cfg(any(feature = "v3_14", feature = "dox"))]
2166 pub fn gtk_source_file_loader_set_candidate_encodings(
2167 loader: *mut GtkSourceFileLoader,
2168 candidate_encodings: *mut glib::GSList,
2169 );
2170
2171 pub fn gtk_source_file_saver_get_type() -> GType;
2175 #[cfg(any(feature = "v3_14", feature = "dox"))]
2176 pub fn gtk_source_file_saver_new(
2177 buffer: *mut GtkSourceBuffer,
2178 file: *mut GtkSourceFile,
2179 ) -> *mut GtkSourceFileSaver;
2180 #[cfg(any(feature = "v3_14", feature = "dox"))]
2181 pub fn gtk_source_file_saver_new_with_target(
2182 buffer: *mut GtkSourceBuffer,
2183 file: *mut GtkSourceFile,
2184 target_location: *mut gio::GFile,
2185 ) -> *mut GtkSourceFileSaver;
2186 #[cfg(any(feature = "v3_14", feature = "dox"))]
2187 pub fn gtk_source_file_saver_get_buffer(saver: *mut GtkSourceFileSaver)
2188 -> *mut GtkSourceBuffer;
2189 #[cfg(any(feature = "v3_14", feature = "dox"))]
2190 pub fn gtk_source_file_saver_get_compression_type(
2191 saver: *mut GtkSourceFileSaver,
2192 ) -> GtkSourceCompressionType;
2193 #[cfg(any(feature = "v3_14", feature = "dox"))]
2194 pub fn gtk_source_file_saver_get_encoding(
2195 saver: *mut GtkSourceFileSaver,
2196 ) -> *const GtkSourceEncoding;
2197 #[cfg(any(feature = "v3_14", feature = "dox"))]
2198 pub fn gtk_source_file_saver_get_file(saver: *mut GtkSourceFileSaver) -> *mut GtkSourceFile;
2199 #[cfg(any(feature = "v3_14", feature = "dox"))]
2200 pub fn gtk_source_file_saver_get_flags(
2201 saver: *mut GtkSourceFileSaver,
2202 ) -> GtkSourceFileSaverFlags;
2203 #[cfg(any(feature = "v3_14", feature = "dox"))]
2204 pub fn gtk_source_file_saver_get_location(saver: *mut GtkSourceFileSaver) -> *mut gio::GFile;
2205 #[cfg(any(feature = "v3_14", feature = "dox"))]
2206 pub fn gtk_source_file_saver_get_newline_type(
2207 saver: *mut GtkSourceFileSaver,
2208 ) -> GtkSourceNewlineType;
2209 #[cfg(any(feature = "v3_14", feature = "dox"))]
2210 pub fn gtk_source_file_saver_save_async(
2211 saver: *mut GtkSourceFileSaver,
2212 io_priority: c_int,
2213 cancellable: *mut gio::GCancellable,
2214 progress_callback: gio::GFileProgressCallback,
2215 progress_callback_data: gpointer,
2216 progress_callback_notify: glib::GDestroyNotify,
2217 callback: gio::GAsyncReadyCallback,
2218 user_data: gpointer,
2219 );
2220 #[cfg(any(feature = "v3_14", feature = "dox"))]
2221 pub fn gtk_source_file_saver_save_finish(
2222 saver: *mut GtkSourceFileSaver,
2223 result: *mut gio::GAsyncResult,
2224 error: *mut *mut glib::GError,
2225 ) -> gboolean;
2226 #[cfg(any(feature = "v3_14", feature = "dox"))]
2227 pub fn gtk_source_file_saver_set_compression_type(
2228 saver: *mut GtkSourceFileSaver,
2229 compression_type: GtkSourceCompressionType,
2230 );
2231 #[cfg(any(feature = "v3_14", feature = "dox"))]
2232 pub fn gtk_source_file_saver_set_encoding(
2233 saver: *mut GtkSourceFileSaver,
2234 encoding: *const GtkSourceEncoding,
2235 );
2236 #[cfg(any(feature = "v3_14", feature = "dox"))]
2237 pub fn gtk_source_file_saver_set_flags(
2238 saver: *mut GtkSourceFileSaver,
2239 flags: GtkSourceFileSaverFlags,
2240 );
2241 #[cfg(any(feature = "v3_14", feature = "dox"))]
2242 pub fn gtk_source_file_saver_set_newline_type(
2243 saver: *mut GtkSourceFileSaver,
2244 newline_type: GtkSourceNewlineType,
2245 );
2246
2247 pub fn gtk_source_gutter_get_type() -> GType;
2251 pub fn gtk_source_gutter_get_padding(
2252 gutter: *mut GtkSourceGutter,
2253 xpad: *mut c_int,
2254 ypad: *mut c_int,
2255 );
2256 pub fn gtk_source_gutter_get_renderer_at_pos(
2257 gutter: *mut GtkSourceGutter,
2258 x: c_int,
2259 y: c_int,
2260 ) -> *mut GtkSourceGutterRenderer;
2261 #[cfg(any(feature = "v3_24", feature = "dox"))]
2262 pub fn gtk_source_gutter_get_view(gutter: *mut GtkSourceGutter) -> *mut GtkSourceView;
2263 pub fn gtk_source_gutter_get_window(gutter: *mut GtkSourceGutter) -> *mut gdk::GdkWindow;
2264 #[cfg(any(feature = "v3_24", feature = "dox"))]
2265 pub fn gtk_source_gutter_get_window_type(
2266 gutter: *mut GtkSourceGutter,
2267 ) -> gtk::GtkTextWindowType;
2268 pub fn gtk_source_gutter_insert(
2269 gutter: *mut GtkSourceGutter,
2270 renderer: *mut GtkSourceGutterRenderer,
2271 position: c_int,
2272 ) -> gboolean;
2273 pub fn gtk_source_gutter_queue_draw(gutter: *mut GtkSourceGutter);
2274 pub fn gtk_source_gutter_remove(
2275 gutter: *mut GtkSourceGutter,
2276 renderer: *mut GtkSourceGutterRenderer,
2277 );
2278 pub fn gtk_source_gutter_reorder(
2279 gutter: *mut GtkSourceGutter,
2280 renderer: *mut GtkSourceGutterRenderer,
2281 position: c_int,
2282 );
2283 pub fn gtk_source_gutter_set_padding(gutter: *mut GtkSourceGutter, xpad: c_int, ypad: c_int);
2284
2285 pub fn gtk_source_gutter_renderer_get_type() -> GType;
2289 pub fn gtk_source_gutter_renderer_activate(
2290 renderer: *mut GtkSourceGutterRenderer,
2291 iter: *mut gtk::GtkTextIter,
2292 area: *mut gdk::GdkRectangle,
2293 event: *mut gdk::GdkEvent,
2294 );
2295 pub fn gtk_source_gutter_renderer_begin(
2296 renderer: *mut GtkSourceGutterRenderer,
2297 cr: *mut cairo::cairo_t,
2298 background_area: *mut gdk::GdkRectangle,
2299 cell_area: *mut gdk::GdkRectangle,
2300 start: *mut gtk::GtkTextIter,
2301 end: *mut gtk::GtkTextIter,
2302 );
2303 pub fn gtk_source_gutter_renderer_draw(
2304 renderer: *mut GtkSourceGutterRenderer,
2305 cr: *mut cairo::cairo_t,
2306 background_area: *mut gdk::GdkRectangle,
2307 cell_area: *mut gdk::GdkRectangle,
2308 start: *mut gtk::GtkTextIter,
2309 end: *mut gtk::GtkTextIter,
2310 state: GtkSourceGutterRendererState,
2311 );
2312 pub fn gtk_source_gutter_renderer_end(renderer: *mut GtkSourceGutterRenderer);
2313 pub fn gtk_source_gutter_renderer_get_alignment(
2314 renderer: *mut GtkSourceGutterRenderer,
2315 xalign: *mut c_float,
2316 yalign: *mut c_float,
2317 );
2318 pub fn gtk_source_gutter_renderer_get_alignment_mode(
2319 renderer: *mut GtkSourceGutterRenderer,
2320 ) -> GtkSourceGutterRendererAlignmentMode;
2321 pub fn gtk_source_gutter_renderer_get_background(
2322 renderer: *mut GtkSourceGutterRenderer,
2323 color: *mut gdk::GdkRGBA,
2324 ) -> gboolean;
2325 pub fn gtk_source_gutter_renderer_get_padding(
2326 renderer: *mut GtkSourceGutterRenderer,
2327 xpad: *mut c_int,
2328 ypad: *mut c_int,
2329 );
2330 pub fn gtk_source_gutter_renderer_get_size(renderer: *mut GtkSourceGutterRenderer) -> c_int;
2331 pub fn gtk_source_gutter_renderer_get_view(
2332 renderer: *mut GtkSourceGutterRenderer,
2333 ) -> *mut gtk::GtkTextView;
2334 pub fn gtk_source_gutter_renderer_get_visible(
2335 renderer: *mut GtkSourceGutterRenderer,
2336 ) -> gboolean;
2337 pub fn gtk_source_gutter_renderer_get_window_type(
2338 renderer: *mut GtkSourceGutterRenderer,
2339 ) -> gtk::GtkTextWindowType;
2340 pub fn gtk_source_gutter_renderer_query_activatable(
2341 renderer: *mut GtkSourceGutterRenderer,
2342 iter: *mut gtk::GtkTextIter,
2343 area: *mut gdk::GdkRectangle,
2344 event: *mut gdk::GdkEvent,
2345 ) -> gboolean;
2346 pub fn gtk_source_gutter_renderer_query_data(
2347 renderer: *mut GtkSourceGutterRenderer,
2348 start: *mut gtk::GtkTextIter,
2349 end: *mut gtk::GtkTextIter,
2350 state: GtkSourceGutterRendererState,
2351 );
2352 pub fn gtk_source_gutter_renderer_query_tooltip(
2353 renderer: *mut GtkSourceGutterRenderer,
2354 iter: *mut gtk::GtkTextIter,
2355 area: *mut gdk::GdkRectangle,
2356 x: c_int,
2357 y: c_int,
2358 tooltip: *mut gtk::GtkTooltip,
2359 ) -> gboolean;
2360 pub fn gtk_source_gutter_renderer_queue_draw(renderer: *mut GtkSourceGutterRenderer);
2361 pub fn gtk_source_gutter_renderer_set_alignment(
2362 renderer: *mut GtkSourceGutterRenderer,
2363 xalign: c_float,
2364 yalign: c_float,
2365 );
2366 pub fn gtk_source_gutter_renderer_set_alignment_mode(
2367 renderer: *mut GtkSourceGutterRenderer,
2368 mode: GtkSourceGutterRendererAlignmentMode,
2369 );
2370 pub fn gtk_source_gutter_renderer_set_background(
2371 renderer: *mut GtkSourceGutterRenderer,
2372 color: *const gdk::GdkRGBA,
2373 );
2374 pub fn gtk_source_gutter_renderer_set_padding(
2375 renderer: *mut GtkSourceGutterRenderer,
2376 xpad: c_int,
2377 ypad: c_int,
2378 );
2379 pub fn gtk_source_gutter_renderer_set_size(renderer: *mut GtkSourceGutterRenderer, size: c_int);
2380 pub fn gtk_source_gutter_renderer_set_visible(
2381 renderer: *mut GtkSourceGutterRenderer,
2382 visible: gboolean,
2383 );
2384
2385 pub fn gtk_source_gutter_renderer_pixbuf_get_type() -> GType;
2389 pub fn gtk_source_gutter_renderer_pixbuf_new() -> *mut GtkSourceGutterRenderer;
2390 pub fn gtk_source_gutter_renderer_pixbuf_get_gicon(
2391 renderer: *mut GtkSourceGutterRendererPixbuf,
2392 ) -> *mut gio::GIcon;
2393 pub fn gtk_source_gutter_renderer_pixbuf_get_icon_name(
2394 renderer: *mut GtkSourceGutterRendererPixbuf,
2395 ) -> *const c_char;
2396 pub fn gtk_source_gutter_renderer_pixbuf_get_pixbuf(
2397 renderer: *mut GtkSourceGutterRendererPixbuf,
2398 ) -> *mut gdk_pixbuf::GdkPixbuf;
2399 pub fn gtk_source_gutter_renderer_pixbuf_get_stock_id(
2400 renderer: *mut GtkSourceGutterRendererPixbuf,
2401 ) -> *const c_char;
2402 pub fn gtk_source_gutter_renderer_pixbuf_set_gicon(
2403 renderer: *mut GtkSourceGutterRendererPixbuf,
2404 icon: *mut gio::GIcon,
2405 );
2406 pub fn gtk_source_gutter_renderer_pixbuf_set_icon_name(
2407 renderer: *mut GtkSourceGutterRendererPixbuf,
2408 icon_name: *const c_char,
2409 );
2410 pub fn gtk_source_gutter_renderer_pixbuf_set_pixbuf(
2411 renderer: *mut GtkSourceGutterRendererPixbuf,
2412 pixbuf: *mut gdk_pixbuf::GdkPixbuf,
2413 );
2414 pub fn gtk_source_gutter_renderer_pixbuf_set_stock_id(
2415 renderer: *mut GtkSourceGutterRendererPixbuf,
2416 stock_id: *const c_char,
2417 );
2418
2419 pub fn gtk_source_gutter_renderer_text_get_type() -> GType;
2423 pub fn gtk_source_gutter_renderer_text_new() -> *mut GtkSourceGutterRenderer;
2424 pub fn gtk_source_gutter_renderer_text_measure(
2425 renderer: *mut GtkSourceGutterRendererText,
2426 text: *const c_char,
2427 width: *mut c_int,
2428 height: *mut c_int,
2429 );
2430 pub fn gtk_source_gutter_renderer_text_measure_markup(
2431 renderer: *mut GtkSourceGutterRendererText,
2432 markup: *const c_char,
2433 width: *mut c_int,
2434 height: *mut c_int,
2435 );
2436 pub fn gtk_source_gutter_renderer_text_set_markup(
2437 renderer: *mut GtkSourceGutterRendererText,
2438 markup: *const c_char,
2439 length: c_int,
2440 );
2441 pub fn gtk_source_gutter_renderer_text_set_text(
2442 renderer: *mut GtkSourceGutterRendererText,
2443 text: *const c_char,
2444 length: c_int,
2445 );
2446
2447 pub fn gtk_source_language_get_type() -> GType;
2451 pub fn gtk_source_language_get_globs(language: *mut GtkSourceLanguage) -> *mut *mut c_char;
2452 pub fn gtk_source_language_get_hidden(language: *mut GtkSourceLanguage) -> gboolean;
2453 pub fn gtk_source_language_get_id(language: *mut GtkSourceLanguage) -> *const c_char;
2454 pub fn gtk_source_language_get_metadata(
2455 language: *mut GtkSourceLanguage,
2456 name: *const c_char,
2457 ) -> *const c_char;
2458 pub fn gtk_source_language_get_mime_types(language: *mut GtkSourceLanguage)
2459 -> *mut *mut c_char;
2460 pub fn gtk_source_language_get_name(language: *mut GtkSourceLanguage) -> *const c_char;
2461 pub fn gtk_source_language_get_section(language: *mut GtkSourceLanguage) -> *const c_char;
2462 #[cfg(any(feature = "v3_4", feature = "dox"))]
2463 pub fn gtk_source_language_get_style_fallback(
2464 language: *mut GtkSourceLanguage,
2465 style_id: *const c_char,
2466 ) -> *const c_char;
2467 pub fn gtk_source_language_get_style_ids(language: *mut GtkSourceLanguage) -> *mut *mut c_char;
2468 pub fn gtk_source_language_get_style_name(
2469 language: *mut GtkSourceLanguage,
2470 style_id: *const c_char,
2471 ) -> *const c_char;
2472
2473 pub fn gtk_source_language_manager_get_type() -> GType;
2477 pub fn gtk_source_language_manager_new() -> *mut GtkSourceLanguageManager;
2478 pub fn gtk_source_language_manager_get_default() -> *mut GtkSourceLanguageManager;
2479 pub fn gtk_source_language_manager_get_language(
2480 lm: *mut GtkSourceLanguageManager,
2481 id: *const c_char,
2482 ) -> *mut GtkSourceLanguage;
2483 pub fn gtk_source_language_manager_get_language_ids(
2484 lm: *mut GtkSourceLanguageManager,
2485 ) -> *const *const c_char;
2486 pub fn gtk_source_language_manager_get_search_path(
2487 lm: *mut GtkSourceLanguageManager,
2488 ) -> *const *const c_char;
2489 pub fn gtk_source_language_manager_guess_language(
2490 lm: *mut GtkSourceLanguageManager,
2491 filename: *const c_char,
2492 content_type: *const c_char,
2493 ) -> *mut GtkSourceLanguage;
2494 pub fn gtk_source_language_manager_set_search_path(
2495 lm: *mut GtkSourceLanguageManager,
2496 dirs: *mut *mut c_char,
2497 );
2498
2499 pub fn gtk_source_map_get_type() -> GType;
2503 #[cfg(any(feature = "v3_18", feature = "dox"))]
2504 pub fn gtk_source_map_new() -> *mut gtk::GtkWidget;
2505 #[cfg(any(feature = "v3_18", feature = "dox"))]
2506 pub fn gtk_source_map_get_view(map: *mut GtkSourceMap) -> *mut GtkSourceView;
2507 #[cfg(any(feature = "v3_18", feature = "dox"))]
2508 pub fn gtk_source_map_set_view(map: *mut GtkSourceMap, view: *mut GtkSourceView);
2509
2510 pub fn gtk_source_mark_get_type() -> GType;
2514 pub fn gtk_source_mark_new(name: *const c_char, category: *const c_char) -> *mut GtkSourceMark;
2515 pub fn gtk_source_mark_get_category(mark: *mut GtkSourceMark) -> *const c_char;
2516 pub fn gtk_source_mark_next(
2517 mark: *mut GtkSourceMark,
2518 category: *const c_char,
2519 ) -> *mut GtkSourceMark;
2520 pub fn gtk_source_mark_prev(
2521 mark: *mut GtkSourceMark,
2522 category: *const c_char,
2523 ) -> *mut GtkSourceMark;
2524
2525 pub fn gtk_source_mark_attributes_get_type() -> GType;
2529 pub fn gtk_source_mark_attributes_new() -> *mut GtkSourceMarkAttributes;
2530 pub fn gtk_source_mark_attributes_get_background(
2531 attributes: *mut GtkSourceMarkAttributes,
2532 background: *mut gdk::GdkRGBA,
2533 ) -> gboolean;
2534 pub fn gtk_source_mark_attributes_get_gicon(
2535 attributes: *mut GtkSourceMarkAttributes,
2536 ) -> *mut gio::GIcon;
2537 pub fn gtk_source_mark_attributes_get_icon_name(
2538 attributes: *mut GtkSourceMarkAttributes,
2539 ) -> *const c_char;
2540 pub fn gtk_source_mark_attributes_get_pixbuf(
2541 attributes: *mut GtkSourceMarkAttributes,
2542 ) -> *const gdk_pixbuf::GdkPixbuf;
2543 pub fn gtk_source_mark_attributes_get_stock_id(
2544 attributes: *mut GtkSourceMarkAttributes,
2545 ) -> *const c_char;
2546 pub fn gtk_source_mark_attributes_get_tooltip_markup(
2547 attributes: *mut GtkSourceMarkAttributes,
2548 mark: *mut GtkSourceMark,
2549 ) -> *mut c_char;
2550 pub fn gtk_source_mark_attributes_get_tooltip_text(
2551 attributes: *mut GtkSourceMarkAttributes,
2552 mark: *mut GtkSourceMark,
2553 ) -> *mut c_char;
2554 pub fn gtk_source_mark_attributes_render_icon(
2555 attributes: *mut GtkSourceMarkAttributes,
2556 widget: *mut gtk::GtkWidget,
2557 size: c_int,
2558 ) -> *const gdk_pixbuf::GdkPixbuf;
2559 pub fn gtk_source_mark_attributes_set_background(
2560 attributes: *mut GtkSourceMarkAttributes,
2561 background: *const gdk::GdkRGBA,
2562 );
2563 pub fn gtk_source_mark_attributes_set_gicon(
2564 attributes: *mut GtkSourceMarkAttributes,
2565 gicon: *mut gio::GIcon,
2566 );
2567 pub fn gtk_source_mark_attributes_set_icon_name(
2568 attributes: *mut GtkSourceMarkAttributes,
2569 icon_name: *const c_char,
2570 );
2571 pub fn gtk_source_mark_attributes_set_pixbuf(
2572 attributes: *mut GtkSourceMarkAttributes,
2573 pixbuf: *const gdk_pixbuf::GdkPixbuf,
2574 );
2575 pub fn gtk_source_mark_attributes_set_stock_id(
2576 attributes: *mut GtkSourceMarkAttributes,
2577 stock_id: *const c_char,
2578 );
2579
2580 pub fn gtk_source_print_compositor_get_type() -> GType;
2584 pub fn gtk_source_print_compositor_new(
2585 buffer: *mut GtkSourceBuffer,
2586 ) -> *mut GtkSourcePrintCompositor;
2587 pub fn gtk_source_print_compositor_new_from_view(
2588 view: *mut GtkSourceView,
2589 ) -> *mut GtkSourcePrintCompositor;
2590 pub fn gtk_source_print_compositor_draw_page(
2591 compositor: *mut GtkSourcePrintCompositor,
2592 context: *mut gtk::GtkPrintContext,
2593 page_nr: c_int,
2594 );
2595 pub fn gtk_source_print_compositor_get_body_font_name(
2596 compositor: *mut GtkSourcePrintCompositor,
2597 ) -> *mut c_char;
2598 pub fn gtk_source_print_compositor_get_bottom_margin(
2599 compositor: *mut GtkSourcePrintCompositor,
2600 unit: gtk::GtkUnit,
2601 ) -> c_double;
2602 pub fn gtk_source_print_compositor_get_buffer(
2603 compositor: *mut GtkSourcePrintCompositor,
2604 ) -> *mut GtkSourceBuffer;
2605 pub fn gtk_source_print_compositor_get_footer_font_name(
2606 compositor: *mut GtkSourcePrintCompositor,
2607 ) -> *mut c_char;
2608 pub fn gtk_source_print_compositor_get_header_font_name(
2609 compositor: *mut GtkSourcePrintCompositor,
2610 ) -> *mut c_char;
2611 pub fn gtk_source_print_compositor_get_highlight_syntax(
2612 compositor: *mut GtkSourcePrintCompositor,
2613 ) -> gboolean;
2614 pub fn gtk_source_print_compositor_get_left_margin(
2615 compositor: *mut GtkSourcePrintCompositor,
2616 unit: gtk::GtkUnit,
2617 ) -> c_double;
2618 pub fn gtk_source_print_compositor_get_line_numbers_font_name(
2619 compositor: *mut GtkSourcePrintCompositor,
2620 ) -> *mut c_char;
2621 pub fn gtk_source_print_compositor_get_n_pages(
2622 compositor: *mut GtkSourcePrintCompositor,
2623 ) -> c_int;
2624 pub fn gtk_source_print_compositor_get_pagination_progress(
2625 compositor: *mut GtkSourcePrintCompositor,
2626 ) -> c_double;
2627 pub fn gtk_source_print_compositor_get_print_footer(
2628 compositor: *mut GtkSourcePrintCompositor,
2629 ) -> gboolean;
2630 pub fn gtk_source_print_compositor_get_print_header(
2631 compositor: *mut GtkSourcePrintCompositor,
2632 ) -> gboolean;
2633 pub fn gtk_source_print_compositor_get_print_line_numbers(
2634 compositor: *mut GtkSourcePrintCompositor,
2635 ) -> c_uint;
2636 pub fn gtk_source_print_compositor_get_right_margin(
2637 compositor: *mut GtkSourcePrintCompositor,
2638 unit: gtk::GtkUnit,
2639 ) -> c_double;
2640 pub fn gtk_source_print_compositor_get_tab_width(
2641 compositor: *mut GtkSourcePrintCompositor,
2642 ) -> c_uint;
2643 pub fn gtk_source_print_compositor_get_top_margin(
2644 compositor: *mut GtkSourcePrintCompositor,
2645 unit: gtk::GtkUnit,
2646 ) -> c_double;
2647 pub fn gtk_source_print_compositor_get_wrap_mode(
2648 compositor: *mut GtkSourcePrintCompositor,
2649 ) -> gtk::GtkWrapMode;
2650 pub fn gtk_source_print_compositor_paginate(
2651 compositor: *mut GtkSourcePrintCompositor,
2652 context: *mut gtk::GtkPrintContext,
2653 ) -> gboolean;
2654 pub fn gtk_source_print_compositor_set_body_font_name(
2655 compositor: *mut GtkSourcePrintCompositor,
2656 font_name: *const c_char,
2657 );
2658 pub fn gtk_source_print_compositor_set_bottom_margin(
2659 compositor: *mut GtkSourcePrintCompositor,
2660 margin: c_double,
2661 unit: gtk::GtkUnit,
2662 );
2663 pub fn gtk_source_print_compositor_set_footer_font_name(
2664 compositor: *mut GtkSourcePrintCompositor,
2665 font_name: *const c_char,
2666 );
2667 pub fn gtk_source_print_compositor_set_footer_format(
2668 compositor: *mut GtkSourcePrintCompositor,
2669 separator: gboolean,
2670 left: *const c_char,
2671 center: *const c_char,
2672 right: *const c_char,
2673 );
2674 pub fn gtk_source_print_compositor_set_header_font_name(
2675 compositor: *mut GtkSourcePrintCompositor,
2676 font_name: *const c_char,
2677 );
2678 pub fn gtk_source_print_compositor_set_header_format(
2679 compositor: *mut GtkSourcePrintCompositor,
2680 separator: gboolean,
2681 left: *const c_char,
2682 center: *const c_char,
2683 right: *const c_char,
2684 );
2685 pub fn gtk_source_print_compositor_set_highlight_syntax(
2686 compositor: *mut GtkSourcePrintCompositor,
2687 highlight: gboolean,
2688 );
2689 pub fn gtk_source_print_compositor_set_left_margin(
2690 compositor: *mut GtkSourcePrintCompositor,
2691 margin: c_double,
2692 unit: gtk::GtkUnit,
2693 );
2694 pub fn gtk_source_print_compositor_set_line_numbers_font_name(
2695 compositor: *mut GtkSourcePrintCompositor,
2696 font_name: *const c_char,
2697 );
2698 pub fn gtk_source_print_compositor_set_print_footer(
2699 compositor: *mut GtkSourcePrintCompositor,
2700 print: gboolean,
2701 );
2702 pub fn gtk_source_print_compositor_set_print_header(
2703 compositor: *mut GtkSourcePrintCompositor,
2704 print: gboolean,
2705 );
2706 pub fn gtk_source_print_compositor_set_print_line_numbers(
2707 compositor: *mut GtkSourcePrintCompositor,
2708 interval: c_uint,
2709 );
2710 pub fn gtk_source_print_compositor_set_right_margin(
2711 compositor: *mut GtkSourcePrintCompositor,
2712 margin: c_double,
2713 unit: gtk::GtkUnit,
2714 );
2715 pub fn gtk_source_print_compositor_set_tab_width(
2716 compositor: *mut GtkSourcePrintCompositor,
2717 width: c_uint,
2718 );
2719 pub fn gtk_source_print_compositor_set_top_margin(
2720 compositor: *mut GtkSourcePrintCompositor,
2721 margin: c_double,
2722 unit: gtk::GtkUnit,
2723 );
2724 pub fn gtk_source_print_compositor_set_wrap_mode(
2725 compositor: *mut GtkSourcePrintCompositor,
2726 wrap_mode: gtk::GtkWrapMode,
2727 );
2728
2729 pub fn gtk_source_region_get_type() -> GType;
2733 #[cfg(any(feature = "v3_22", feature = "dox"))]
2734 pub fn gtk_source_region_new(buffer: *mut gtk::GtkTextBuffer) -> *mut GtkSourceRegion;
2735 #[cfg(any(feature = "v3_22", feature = "dox"))]
2736 pub fn gtk_source_region_add_region(
2737 region: *mut GtkSourceRegion,
2738 region_to_add: *mut GtkSourceRegion,
2739 );
2740 #[cfg(any(feature = "v3_22", feature = "dox"))]
2741 pub fn gtk_source_region_add_subregion(
2742 region: *mut GtkSourceRegion,
2743 _start: *const gtk::GtkTextIter,
2744 _end: *const gtk::GtkTextIter,
2745 );
2746 #[cfg(any(feature = "v3_22", feature = "dox"))]
2747 pub fn gtk_source_region_get_bounds(
2748 region: *mut GtkSourceRegion,
2749 start: *mut gtk::GtkTextIter,
2750 end: *mut gtk::GtkTextIter,
2751 ) -> gboolean;
2752 #[cfg(any(feature = "v3_22", feature = "dox"))]
2753 pub fn gtk_source_region_get_buffer(region: *mut GtkSourceRegion) -> *mut gtk::GtkTextBuffer;
2754 #[cfg(any(feature = "v3_22", feature = "dox"))]
2755 pub fn gtk_source_region_get_start_region_iter(
2756 region: *mut GtkSourceRegion,
2757 iter: *mut GtkSourceRegionIter,
2758 );
2759 #[cfg(any(feature = "v3_22", feature = "dox"))]
2760 pub fn gtk_source_region_intersect_region(
2761 region1: *mut GtkSourceRegion,
2762 region2: *mut GtkSourceRegion,
2763 ) -> *mut GtkSourceRegion;
2764 #[cfg(any(feature = "v3_22", feature = "dox"))]
2765 pub fn gtk_source_region_intersect_subregion(
2766 region: *mut GtkSourceRegion,
2767 _start: *const gtk::GtkTextIter,
2768 _end: *const gtk::GtkTextIter,
2769 ) -> *mut GtkSourceRegion;
2770 #[cfg(any(feature = "v3_22", feature = "dox"))]
2771 pub fn gtk_source_region_is_empty(region: *mut GtkSourceRegion) -> gboolean;
2772 #[cfg(any(feature = "v3_22", feature = "dox"))]
2773 pub fn gtk_source_region_subtract_region(
2774 region: *mut GtkSourceRegion,
2775 region_to_subtract: *mut GtkSourceRegion,
2776 );
2777 #[cfg(any(feature = "v3_22", feature = "dox"))]
2778 pub fn gtk_source_region_subtract_subregion(
2779 region: *mut GtkSourceRegion,
2780 _start: *const gtk::GtkTextIter,
2781 _end: *const gtk::GtkTextIter,
2782 );
2783 #[cfg(any(feature = "v3_22", feature = "dox"))]
2784 pub fn gtk_source_region_to_string(region: *mut GtkSourceRegion) -> *mut c_char;
2785
2786 pub fn gtk_source_search_context_get_type() -> GType;
2790 #[cfg(any(feature = "v3_10", feature = "dox"))]
2791 pub fn gtk_source_search_context_new(
2792 buffer: *mut GtkSourceBuffer,
2793 settings: *mut GtkSourceSearchSettings,
2794 ) -> *mut GtkSourceSearchContext;
2795 #[cfg(any(feature = "v3_10", feature = "dox"))]
2796 pub fn gtk_source_search_context_backward(
2797 search: *mut GtkSourceSearchContext,
2798 iter: *const gtk::GtkTextIter,
2799 match_start: *mut gtk::GtkTextIter,
2800 match_end: *mut gtk::GtkTextIter,
2801 ) -> gboolean;
2802 #[cfg(any(feature = "v3_22", feature = "dox"))]
2803 pub fn gtk_source_search_context_backward2(
2804 search: *mut GtkSourceSearchContext,
2805 iter: *const gtk::GtkTextIter,
2806 match_start: *mut gtk::GtkTextIter,
2807 match_end: *mut gtk::GtkTextIter,
2808 has_wrapped_around: *mut gboolean,
2809 ) -> gboolean;
2810 #[cfg(any(feature = "v3_10", feature = "dox"))]
2811 pub fn gtk_source_search_context_backward_async(
2812 search: *mut GtkSourceSearchContext,
2813 iter: *const gtk::GtkTextIter,
2814 cancellable: *mut gio::GCancellable,
2815 callback: gio::GAsyncReadyCallback,
2816 user_data: gpointer,
2817 );
2818 #[cfg(any(feature = "v3_10", feature = "dox"))]
2819 pub fn gtk_source_search_context_backward_finish(
2820 search: *mut GtkSourceSearchContext,
2821 result: *mut gio::GAsyncResult,
2822 match_start: *mut gtk::GtkTextIter,
2823 match_end: *mut gtk::GtkTextIter,
2824 error: *mut *mut glib::GError,
2825 ) -> gboolean;
2826 #[cfg(any(feature = "v3_22", feature = "dox"))]
2827 pub fn gtk_source_search_context_backward_finish2(
2828 search: *mut GtkSourceSearchContext,
2829 result: *mut gio::GAsyncResult,
2830 match_start: *mut gtk::GtkTextIter,
2831 match_end: *mut gtk::GtkTextIter,
2832 has_wrapped_around: *mut gboolean,
2833 error: *mut *mut glib::GError,
2834 ) -> gboolean;
2835 #[cfg(any(feature = "v3_10", feature = "dox"))]
2836 pub fn gtk_source_search_context_forward(
2837 search: *mut GtkSourceSearchContext,
2838 iter: *const gtk::GtkTextIter,
2839 match_start: *mut gtk::GtkTextIter,
2840 match_end: *mut gtk::GtkTextIter,
2841 ) -> gboolean;
2842 #[cfg(any(feature = "v3_22", feature = "dox"))]
2843 pub fn gtk_source_search_context_forward2(
2844 search: *mut GtkSourceSearchContext,
2845 iter: *const gtk::GtkTextIter,
2846 match_start: *mut gtk::GtkTextIter,
2847 match_end: *mut gtk::GtkTextIter,
2848 has_wrapped_around: *mut gboolean,
2849 ) -> gboolean;
2850 #[cfg(any(feature = "v3_10", feature = "dox"))]
2851 pub fn gtk_source_search_context_forward_async(
2852 search: *mut GtkSourceSearchContext,
2853 iter: *const gtk::GtkTextIter,
2854 cancellable: *mut gio::GCancellable,
2855 callback: gio::GAsyncReadyCallback,
2856 user_data: gpointer,
2857 );
2858 #[cfg(any(feature = "v3_10", feature = "dox"))]
2859 pub fn gtk_source_search_context_forward_finish(
2860 search: *mut GtkSourceSearchContext,
2861 result: *mut gio::GAsyncResult,
2862 match_start: *mut gtk::GtkTextIter,
2863 match_end: *mut gtk::GtkTextIter,
2864 error: *mut *mut glib::GError,
2865 ) -> gboolean;
2866 #[cfg(any(feature = "v3_22", feature = "dox"))]
2867 pub fn gtk_source_search_context_forward_finish2(
2868 search: *mut GtkSourceSearchContext,
2869 result: *mut gio::GAsyncResult,
2870 match_start: *mut gtk::GtkTextIter,
2871 match_end: *mut gtk::GtkTextIter,
2872 has_wrapped_around: *mut gboolean,
2873 error: *mut *mut glib::GError,
2874 ) -> gboolean;
2875 #[cfg(any(feature = "v3_10", feature = "dox"))]
2876 pub fn gtk_source_search_context_get_buffer(
2877 search: *mut GtkSourceSearchContext,
2878 ) -> *mut GtkSourceBuffer;
2879 #[cfg(any(feature = "v3_10", feature = "dox"))]
2880 pub fn gtk_source_search_context_get_highlight(search: *mut GtkSourceSearchContext)
2881 -> gboolean;
2882 #[cfg(any(feature = "v3_16", feature = "dox"))]
2883 pub fn gtk_source_search_context_get_match_style(
2884 search: *mut GtkSourceSearchContext,
2885 ) -> *mut GtkSourceStyle;
2886 #[cfg(any(feature = "v3_10", feature = "dox"))]
2887 pub fn gtk_source_search_context_get_occurrence_position(
2888 search: *mut GtkSourceSearchContext,
2889 match_start: *const gtk::GtkTextIter,
2890 match_end: *const gtk::GtkTextIter,
2891 ) -> c_int;
2892 #[cfg(any(feature = "v3_10", feature = "dox"))]
2893 pub fn gtk_source_search_context_get_occurrences_count(
2894 search: *mut GtkSourceSearchContext,
2895 ) -> c_int;
2896 #[cfg(any(feature = "v3_10", feature = "dox"))]
2897 pub fn gtk_source_search_context_get_regex_error(
2898 search: *mut GtkSourceSearchContext,
2899 ) -> *mut glib::GError;
2900 #[cfg(any(feature = "v3_10", feature = "dox"))]
2901 pub fn gtk_source_search_context_get_settings(
2902 search: *mut GtkSourceSearchContext,
2903 ) -> *mut GtkSourceSearchSettings;
2904 #[cfg(any(feature = "v3_10", feature = "dox"))]
2905 pub fn gtk_source_search_context_replace(
2906 search: *mut GtkSourceSearchContext,
2907 match_start: *const gtk::GtkTextIter,
2908 match_end: *const gtk::GtkTextIter,
2909 replace: *const c_char,
2910 replace_length: c_int,
2911 error: *mut *mut glib::GError,
2912 ) -> gboolean;
2913 #[cfg(any(feature = "v3_22", feature = "dox"))]
2914 pub fn gtk_source_search_context_replace2(
2915 search: *mut GtkSourceSearchContext,
2916 match_start: *mut gtk::GtkTextIter,
2917 match_end: *mut gtk::GtkTextIter,
2918 replace: *const c_char,
2919 replace_length: c_int,
2920 error: *mut *mut glib::GError,
2921 ) -> gboolean;
2922 #[cfg(any(feature = "v3_10", feature = "dox"))]
2923 pub fn gtk_source_search_context_replace_all(
2924 search: *mut GtkSourceSearchContext,
2925 replace: *const c_char,
2926 replace_length: c_int,
2927 error: *mut *mut glib::GError,
2928 ) -> c_uint;
2929 #[cfg(any(feature = "v3_10", feature = "dox"))]
2930 pub fn gtk_source_search_context_set_highlight(
2931 search: *mut GtkSourceSearchContext,
2932 highlight: gboolean,
2933 );
2934 #[cfg(any(feature = "v3_16", feature = "dox"))]
2935 pub fn gtk_source_search_context_set_match_style(
2936 search: *mut GtkSourceSearchContext,
2937 match_style: *mut GtkSourceStyle,
2938 );
2939 #[cfg(any(feature = "v3_10", feature = "dox"))]
2940 pub fn gtk_source_search_context_set_settings(
2941 search: *mut GtkSourceSearchContext,
2942 settings: *mut GtkSourceSearchSettings,
2943 );
2944
2945 pub fn gtk_source_search_settings_get_type() -> GType;
2949 #[cfg(any(feature = "v3_10", feature = "dox"))]
2950 pub fn gtk_source_search_settings_new() -> *mut GtkSourceSearchSettings;
2951 #[cfg(any(feature = "v3_10", feature = "dox"))]
2952 pub fn gtk_source_search_settings_get_at_word_boundaries(
2953 settings: *mut GtkSourceSearchSettings,
2954 ) -> gboolean;
2955 #[cfg(any(feature = "v3_10", feature = "dox"))]
2956 pub fn gtk_source_search_settings_get_case_sensitive(
2957 settings: *mut GtkSourceSearchSettings,
2958 ) -> gboolean;
2959 #[cfg(any(feature = "v3_10", feature = "dox"))]
2960 pub fn gtk_source_search_settings_get_regex_enabled(
2961 settings: *mut GtkSourceSearchSettings,
2962 ) -> gboolean;
2963 #[cfg(any(feature = "v3_10", feature = "dox"))]
2964 pub fn gtk_source_search_settings_get_search_text(
2965 settings: *mut GtkSourceSearchSettings,
2966 ) -> *const c_char;
2967 #[cfg(any(feature = "v3_10", feature = "dox"))]
2968 pub fn gtk_source_search_settings_get_wrap_around(
2969 settings: *mut GtkSourceSearchSettings,
2970 ) -> gboolean;
2971 #[cfg(any(feature = "v3_10", feature = "dox"))]
2972 pub fn gtk_source_search_settings_set_at_word_boundaries(
2973 settings: *mut GtkSourceSearchSettings,
2974 at_word_boundaries: gboolean,
2975 );
2976 #[cfg(any(feature = "v3_10", feature = "dox"))]
2977 pub fn gtk_source_search_settings_set_case_sensitive(
2978 settings: *mut GtkSourceSearchSettings,
2979 case_sensitive: gboolean,
2980 );
2981 #[cfg(any(feature = "v3_10", feature = "dox"))]
2982 pub fn gtk_source_search_settings_set_regex_enabled(
2983 settings: *mut GtkSourceSearchSettings,
2984 regex_enabled: gboolean,
2985 );
2986 #[cfg(any(feature = "v3_10", feature = "dox"))]
2987 pub fn gtk_source_search_settings_set_search_text(
2988 settings: *mut GtkSourceSearchSettings,
2989 search_text: *const c_char,
2990 );
2991 #[cfg(any(feature = "v3_10", feature = "dox"))]
2992 pub fn gtk_source_search_settings_set_wrap_around(
2993 settings: *mut GtkSourceSearchSettings,
2994 wrap_around: gboolean,
2995 );
2996
2997 pub fn gtk_source_space_drawer_get_type() -> GType;
3001 #[cfg(any(feature = "v3_24", feature = "dox"))]
3002 pub fn gtk_source_space_drawer_new() -> *mut GtkSourceSpaceDrawer;
3003 #[cfg(any(feature = "v3_24", feature = "dox"))]
3004 pub fn gtk_source_space_drawer_bind_matrix_setting(
3005 drawer: *mut GtkSourceSpaceDrawer,
3006 settings: *mut gio::GSettings,
3007 key: *const c_char,
3008 flags: gio::GSettingsBindFlags,
3009 );
3010 #[cfg(any(feature = "v3_24", feature = "dox"))]
3011 pub fn gtk_source_space_drawer_get_enable_matrix(drawer: *mut GtkSourceSpaceDrawer)
3012 -> gboolean;
3013 #[cfg(any(feature = "v3_24", feature = "dox"))]
3014 pub fn gtk_source_space_drawer_get_matrix(
3015 drawer: *mut GtkSourceSpaceDrawer,
3016 ) -> *mut glib::GVariant;
3017 #[cfg(any(feature = "v3_24", feature = "dox"))]
3018 pub fn gtk_source_space_drawer_get_types_for_locations(
3019 drawer: *mut GtkSourceSpaceDrawer,
3020 locations: GtkSourceSpaceLocationFlags,
3021 ) -> GtkSourceSpaceTypeFlags;
3022 #[cfg(any(feature = "v3_24", feature = "dox"))]
3023 pub fn gtk_source_space_drawer_set_enable_matrix(
3024 drawer: *mut GtkSourceSpaceDrawer,
3025 enable_matrix: gboolean,
3026 );
3027 #[cfg(any(feature = "v3_24", feature = "dox"))]
3028 pub fn gtk_source_space_drawer_set_matrix(
3029 drawer: *mut GtkSourceSpaceDrawer,
3030 matrix: *mut glib::GVariant,
3031 );
3032 #[cfg(any(feature = "v3_24", feature = "dox"))]
3033 pub fn gtk_source_space_drawer_set_types_for_locations(
3034 drawer: *mut GtkSourceSpaceDrawer,
3035 locations: GtkSourceSpaceLocationFlags,
3036 types: GtkSourceSpaceTypeFlags,
3037 );
3038
3039 pub fn gtk_source_style_get_type() -> GType;
3043 #[cfg(any(feature = "v3_22", feature = "dox"))]
3044 pub fn gtk_source_style_apply(style: *const GtkSourceStyle, tag: *mut gtk::GtkTextTag);
3045 pub fn gtk_source_style_copy(style: *const GtkSourceStyle) -> *mut GtkSourceStyle;
3046
3047 pub fn gtk_source_style_scheme_get_type() -> GType;
3051 pub fn gtk_source_style_scheme_get_authors(
3052 scheme: *mut GtkSourceStyleScheme,
3053 ) -> *const *const c_char;
3054 pub fn gtk_source_style_scheme_get_description(
3055 scheme: *mut GtkSourceStyleScheme,
3056 ) -> *const c_char;
3057 pub fn gtk_source_style_scheme_get_filename(scheme: *mut GtkSourceStyleScheme)
3058 -> *const c_char;
3059 pub fn gtk_source_style_scheme_get_id(scheme: *mut GtkSourceStyleScheme) -> *const c_char;
3060 pub fn gtk_source_style_scheme_get_name(scheme: *mut GtkSourceStyleScheme) -> *const c_char;
3061 pub fn gtk_source_style_scheme_get_style(
3062 scheme: *mut GtkSourceStyleScheme,
3063 style_id: *const c_char,
3064 ) -> *mut GtkSourceStyle;
3065
3066 pub fn gtk_source_style_scheme_chooser_button_get_type() -> GType;
3070 #[cfg(any(feature = "v3_16", feature = "dox"))]
3071 pub fn gtk_source_style_scheme_chooser_button_new() -> *mut gtk::GtkWidget;
3072
3073 pub fn gtk_source_style_scheme_chooser_widget_get_type() -> GType;
3077 #[cfg(any(feature = "v3_16", feature = "dox"))]
3078 pub fn gtk_source_style_scheme_chooser_widget_new() -> *mut gtk::GtkWidget;
3079
3080 pub fn gtk_source_style_scheme_manager_get_type() -> GType;
3084 pub fn gtk_source_style_scheme_manager_new() -> *mut GtkSourceStyleSchemeManager;
3085 pub fn gtk_source_style_scheme_manager_get_default() -> *mut GtkSourceStyleSchemeManager;
3086 pub fn gtk_source_style_scheme_manager_append_search_path(
3087 manager: *mut GtkSourceStyleSchemeManager,
3088 path: *const c_char,
3089 );
3090 pub fn gtk_source_style_scheme_manager_force_rescan(manager: *mut GtkSourceStyleSchemeManager);
3091 pub fn gtk_source_style_scheme_manager_get_scheme(
3092 manager: *mut GtkSourceStyleSchemeManager,
3093 scheme_id: *const c_char,
3094 ) -> *mut GtkSourceStyleScheme;
3095 pub fn gtk_source_style_scheme_manager_get_scheme_ids(
3096 manager: *mut GtkSourceStyleSchemeManager,
3097 ) -> *const *const c_char;
3098 pub fn gtk_source_style_scheme_manager_get_search_path(
3099 manager: *mut GtkSourceStyleSchemeManager,
3100 ) -> *const *const c_char;
3101 pub fn gtk_source_style_scheme_manager_prepend_search_path(
3102 manager: *mut GtkSourceStyleSchemeManager,
3103 path: *const c_char,
3104 );
3105 pub fn gtk_source_style_scheme_manager_set_search_path(
3106 manager: *mut GtkSourceStyleSchemeManager,
3107 path: *mut *mut c_char,
3108 );
3109
3110 pub fn gtk_source_tag_get_type() -> GType;
3114 #[cfg(any(feature = "v3_20", feature = "dox"))]
3115 pub fn gtk_source_tag_new(name: *const c_char) -> *mut gtk::GtkTextTag;
3116
3117 pub fn gtk_source_view_get_type() -> GType;
3121 pub fn gtk_source_view_new() -> *mut gtk::GtkWidget;
3122 pub fn gtk_source_view_new_with_buffer(buffer: *mut GtkSourceBuffer) -> *mut gtk::GtkWidget;
3123 pub fn gtk_source_view_get_auto_indent(view: *mut GtkSourceView) -> gboolean;
3124 #[cfg(any(feature = "v3_16", feature = "dox"))]
3125 pub fn gtk_source_view_get_background_pattern(
3126 view: *mut GtkSourceView,
3127 ) -> GtkSourceBackgroundPatternType;
3128 pub fn gtk_source_view_get_completion(view: *mut GtkSourceView) -> *mut GtkSourceCompletion;
3129 pub fn gtk_source_view_get_draw_spaces(view: *mut GtkSourceView) -> GtkSourceDrawSpacesFlags;
3130 pub fn gtk_source_view_get_gutter(
3131 view: *mut GtkSourceView,
3132 window_type: gtk::GtkTextWindowType,
3133 ) -> *mut GtkSourceGutter;
3134 pub fn gtk_source_view_get_highlight_current_line(view: *mut GtkSourceView) -> gboolean;
3135 pub fn gtk_source_view_get_indent_on_tab(view: *mut GtkSourceView) -> gboolean;
3136 pub fn gtk_source_view_get_indent_width(view: *mut GtkSourceView) -> c_int;
3137 pub fn gtk_source_view_get_insert_spaces_instead_of_tabs(view: *mut GtkSourceView) -> gboolean;
3138 pub fn gtk_source_view_get_mark_attributes(
3139 view: *mut GtkSourceView,
3140 category: *const c_char,
3141 priority: *mut c_int,
3142 ) -> *mut GtkSourceMarkAttributes;
3143 pub fn gtk_source_view_get_right_margin_position(view: *mut GtkSourceView) -> c_uint;
3144 pub fn gtk_source_view_get_show_line_marks(view: *mut GtkSourceView) -> gboolean;
3145 pub fn gtk_source_view_get_show_line_numbers(view: *mut GtkSourceView) -> gboolean;
3146 pub fn gtk_source_view_get_show_right_margin(view: *mut GtkSourceView) -> gboolean;
3147 #[cfg(any(feature = "v3_18", feature = "dox"))]
3148 pub fn gtk_source_view_get_smart_backspace(view: *mut GtkSourceView) -> gboolean;
3149 pub fn gtk_source_view_get_smart_home_end(
3150 view: *mut GtkSourceView,
3151 ) -> GtkSourceSmartHomeEndType;
3152 #[cfg(any(feature = "v3_24", feature = "dox"))]
3153 pub fn gtk_source_view_get_space_drawer(view: *mut GtkSourceView) -> *mut GtkSourceSpaceDrawer;
3154 pub fn gtk_source_view_get_tab_width(view: *mut GtkSourceView) -> c_uint;
3155 pub fn gtk_source_view_get_visual_column(
3156 view: *mut GtkSourceView,
3157 iter: *const gtk::GtkTextIter,
3158 ) -> c_uint;
3159 #[cfg(any(feature = "v3_16", feature = "dox"))]
3160 pub fn gtk_source_view_indent_lines(
3161 view: *mut GtkSourceView,
3162 start: *mut gtk::GtkTextIter,
3163 end: *mut gtk::GtkTextIter,
3164 );
3165 pub fn gtk_source_view_set_auto_indent(view: *mut GtkSourceView, enable: gboolean);
3166 #[cfg(any(feature = "v3_16", feature = "dox"))]
3167 pub fn gtk_source_view_set_background_pattern(
3168 view: *mut GtkSourceView,
3169 background_pattern: GtkSourceBackgroundPatternType,
3170 );
3171 pub fn gtk_source_view_set_draw_spaces(
3172 view: *mut GtkSourceView,
3173 flags: GtkSourceDrawSpacesFlags,
3174 );
3175 pub fn gtk_source_view_set_highlight_current_line(
3176 view: *mut GtkSourceView,
3177 highlight: gboolean,
3178 );
3179 pub fn gtk_source_view_set_indent_on_tab(view: *mut GtkSourceView, enable: gboolean);
3180 pub fn gtk_source_view_set_indent_width(view: *mut GtkSourceView, width: c_int);
3181 pub fn gtk_source_view_set_insert_spaces_instead_of_tabs(
3182 view: *mut GtkSourceView,
3183 enable: gboolean,
3184 );
3185 pub fn gtk_source_view_set_mark_attributes(
3186 view: *mut GtkSourceView,
3187 category: *const c_char,
3188 attributes: *mut GtkSourceMarkAttributes,
3189 priority: c_int,
3190 );
3191 pub fn gtk_source_view_set_right_margin_position(view: *mut GtkSourceView, pos: c_uint);
3192 pub fn gtk_source_view_set_show_line_marks(view: *mut GtkSourceView, show: gboolean);
3193 pub fn gtk_source_view_set_show_line_numbers(view: *mut GtkSourceView, show: gboolean);
3194 pub fn gtk_source_view_set_show_right_margin(view: *mut GtkSourceView, show: gboolean);
3195 #[cfg(any(feature = "v3_18", feature = "dox"))]
3196 pub fn gtk_source_view_set_smart_backspace(view: *mut GtkSourceView, smart_backspace: gboolean);
3197 pub fn gtk_source_view_set_smart_home_end(
3198 view: *mut GtkSourceView,
3199 smart_home_end: GtkSourceSmartHomeEndType,
3200 );
3201 pub fn gtk_source_view_set_tab_width(view: *mut GtkSourceView, width: c_uint);
3202 #[cfg(any(feature = "v3_16", feature = "dox"))]
3203 pub fn gtk_source_view_unindent_lines(
3204 view: *mut GtkSourceView,
3205 start: *mut gtk::GtkTextIter,
3206 end: *mut gtk::GtkTextIter,
3207 );
3208
3209 pub fn gtk_source_completion_proposal_get_type() -> GType;
3213 pub fn gtk_source_completion_proposal_changed(proposal: *mut GtkSourceCompletionProposal);
3214 pub fn gtk_source_completion_proposal_equal(
3215 proposal: *mut GtkSourceCompletionProposal,
3216 other: *mut GtkSourceCompletionProposal,
3217 ) -> gboolean;
3218 #[cfg(any(feature = "v3_18", feature = "dox"))]
3219 pub fn gtk_source_completion_proposal_get_gicon(
3220 proposal: *mut GtkSourceCompletionProposal,
3221 ) -> *mut gio::GIcon;
3222 pub fn gtk_source_completion_proposal_get_icon(
3223 proposal: *mut GtkSourceCompletionProposal,
3224 ) -> *mut gdk_pixbuf::GdkPixbuf;
3225 #[cfg(any(feature = "v3_18", feature = "dox"))]
3226 pub fn gtk_source_completion_proposal_get_icon_name(
3227 proposal: *mut GtkSourceCompletionProposal,
3228 ) -> *const c_char;
3229 pub fn gtk_source_completion_proposal_get_info(
3230 proposal: *mut GtkSourceCompletionProposal,
3231 ) -> *mut c_char;
3232 pub fn gtk_source_completion_proposal_get_label(
3233 proposal: *mut GtkSourceCompletionProposal,
3234 ) -> *mut c_char;
3235 pub fn gtk_source_completion_proposal_get_markup(
3236 proposal: *mut GtkSourceCompletionProposal,
3237 ) -> *mut c_char;
3238 pub fn gtk_source_completion_proposal_get_text(
3239 proposal: *mut GtkSourceCompletionProposal,
3240 ) -> *mut c_char;
3241 pub fn gtk_source_completion_proposal_hash(
3242 proposal: *mut GtkSourceCompletionProposal,
3243 ) -> c_uint;
3244
3245 pub fn gtk_source_completion_provider_get_type() -> GType;
3249 pub fn gtk_source_completion_provider_activate_proposal(
3250 provider: *mut GtkSourceCompletionProvider,
3251 proposal: *mut GtkSourceCompletionProposal,
3252 iter: *mut gtk::GtkTextIter,
3253 ) -> gboolean;
3254 pub fn gtk_source_completion_provider_get_activation(
3255 provider: *mut GtkSourceCompletionProvider,
3256 ) -> GtkSourceCompletionActivation;
3257 #[cfg(any(feature = "v3_18", feature = "dox"))]
3258 pub fn gtk_source_completion_provider_get_gicon(
3259 provider: *mut GtkSourceCompletionProvider,
3260 ) -> *mut gio::GIcon;
3261 pub fn gtk_source_completion_provider_get_icon(
3262 provider: *mut GtkSourceCompletionProvider,
3263 ) -> *mut gdk_pixbuf::GdkPixbuf;
3264 #[cfg(any(feature = "v3_18", feature = "dox"))]
3265 pub fn gtk_source_completion_provider_get_icon_name(
3266 provider: *mut GtkSourceCompletionProvider,
3267 ) -> *const c_char;
3268 pub fn gtk_source_completion_provider_get_info_widget(
3269 provider: *mut GtkSourceCompletionProvider,
3270 proposal: *mut GtkSourceCompletionProposal,
3271 ) -> *mut gtk::GtkWidget;
3272 pub fn gtk_source_completion_provider_get_interactive_delay(
3273 provider: *mut GtkSourceCompletionProvider,
3274 ) -> c_int;
3275 pub fn gtk_source_completion_provider_get_name(
3276 provider: *mut GtkSourceCompletionProvider,
3277 ) -> *mut c_char;
3278 pub fn gtk_source_completion_provider_get_priority(
3279 provider: *mut GtkSourceCompletionProvider,
3280 ) -> c_int;
3281 pub fn gtk_source_completion_provider_get_start_iter(
3282 provider: *mut GtkSourceCompletionProvider,
3283 context: *mut GtkSourceCompletionContext,
3284 proposal: *mut GtkSourceCompletionProposal,
3285 iter: *mut gtk::GtkTextIter,
3286 ) -> gboolean;
3287 pub fn gtk_source_completion_provider_match(
3288 provider: *mut GtkSourceCompletionProvider,
3289 context: *mut GtkSourceCompletionContext,
3290 ) -> gboolean;
3291 pub fn gtk_source_completion_provider_populate(
3292 provider: *mut GtkSourceCompletionProvider,
3293 context: *mut GtkSourceCompletionContext,
3294 );
3295 pub fn gtk_source_completion_provider_update_info(
3296 provider: *mut GtkSourceCompletionProvider,
3297 proposal: *mut GtkSourceCompletionProposal,
3298 info: *mut GtkSourceCompletionInfo,
3299 );
3300
3301 pub fn gtk_source_style_scheme_chooser_get_type() -> GType;
3305 #[cfg(any(feature = "v3_16", feature = "dox"))]
3306 pub fn gtk_source_style_scheme_chooser_get_style_scheme(
3307 chooser: *mut GtkSourceStyleSchemeChooser,
3308 ) -> *mut GtkSourceStyleScheme;
3309 #[cfg(any(feature = "v3_16", feature = "dox"))]
3310 pub fn gtk_source_style_scheme_chooser_set_style_scheme(
3311 chooser: *mut GtkSourceStyleSchemeChooser,
3312 scheme: *mut GtkSourceStyleScheme,
3313 );
3314
3315 pub fn gtk_source_undo_manager_get_type() -> GType;
3319 pub fn gtk_source_undo_manager_begin_not_undoable_action(manager: *mut GtkSourceUndoManager);
3320 pub fn gtk_source_undo_manager_can_redo(manager: *mut GtkSourceUndoManager) -> gboolean;
3321 pub fn gtk_source_undo_manager_can_redo_changed(manager: *mut GtkSourceUndoManager);
3322 pub fn gtk_source_undo_manager_can_undo(manager: *mut GtkSourceUndoManager) -> gboolean;
3323 pub fn gtk_source_undo_manager_can_undo_changed(manager: *mut GtkSourceUndoManager);
3324 pub fn gtk_source_undo_manager_end_not_undoable_action(manager: *mut GtkSourceUndoManager);
3325 pub fn gtk_source_undo_manager_redo(manager: *mut GtkSourceUndoManager);
3326 pub fn gtk_source_undo_manager_undo(manager: *mut GtkSourceUndoManager);
3327
3328 #[cfg(any(feature = "v3_10", feature = "dox"))]
3332 pub fn gtk_source_utils_escape_search_text(text: *const c_char) -> *mut c_char;
3333 #[cfg(any(feature = "v3_10", feature = "dox"))]
3334 pub fn gtk_source_utils_unescape_search_text(text: *const c_char) -> *mut c_char;
3335
3336}