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