1use crate::{ffi, TextBuffer, TextChildAnchor, TextMark, TextSearchFlags, TextTag};
6use glib::{prelude::*, translate::*};
7
8glib::wrapper! {
9 #[derive(Debug)]
10 pub struct TextIter(BoxedInline<ffi::GtkTextIter>);
11
12 match fn {
13 copy => |ptr| ffi::gtk_text_iter_copy(ptr),
14 free => |ptr| ffi::gtk_text_iter_free(ptr),
15 type_ => || ffi::gtk_text_iter_get_type(),
16 }
17}
18
19impl TextIter {
20 #[doc(alias = "gtk_text_iter_assign")]
21 pub fn assign(&mut self, other: &TextIter) {
22 unsafe {
23 ffi::gtk_text_iter_assign(self.to_glib_none_mut().0, other.to_glib_none().0);
24 }
25 }
26
27 #[doc(alias = "gtk_text_iter_backward_char")]
28 pub fn backward_char(&mut self) -> bool {
29 unsafe { from_glib(ffi::gtk_text_iter_backward_char(self.to_glib_none_mut().0)) }
30 }
31
32 #[doc(alias = "gtk_text_iter_backward_chars")]
33 pub fn backward_chars(&mut self, count: i32) -> bool {
34 unsafe {
35 from_glib(ffi::gtk_text_iter_backward_chars(
36 self.to_glib_none_mut().0,
37 count,
38 ))
39 }
40 }
41
42 #[doc(alias = "gtk_text_iter_backward_cursor_position")]
43 pub fn backward_cursor_position(&mut self) -> bool {
44 unsafe {
45 from_glib(ffi::gtk_text_iter_backward_cursor_position(
46 self.to_glib_none_mut().0,
47 ))
48 }
49 }
50
51 #[doc(alias = "gtk_text_iter_backward_cursor_positions")]
52 pub fn backward_cursor_positions(&mut self, count: i32) -> bool {
53 unsafe {
54 from_glib(ffi::gtk_text_iter_backward_cursor_positions(
55 self.to_glib_none_mut().0,
56 count,
57 ))
58 }
59 }
60
61 #[doc(alias = "gtk_text_iter_backward_find_char")]
62 pub fn backward_find_char<P: FnMut(char) -> bool>(
63 &mut self,
64 pred: P,
65 limit: Option<&TextIter>,
66 ) -> bool {
67 let mut pred_data: P = pred;
68 unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
69 ch: u32,
70 user_data: glib::ffi::gpointer,
71 ) -> glib::ffi::gboolean {
72 let ch = std::convert::TryFrom::try_from(ch)
73 .expect("conversion from an invalid Unicode value attempted");
74 let callback = user_data as *mut P;
75 (*callback)(ch).into_glib()
76 }
77 let pred = Some(pred_func::<P> as _);
78 let super_callback0: &mut P = &mut pred_data;
79 unsafe {
80 from_glib(ffi::gtk_text_iter_backward_find_char(
81 self.to_glib_none_mut().0,
82 pred,
83 super_callback0 as *mut _ as *mut _,
84 limit.to_glib_none().0,
85 ))
86 }
87 }
88
89 #[doc(alias = "gtk_text_iter_backward_line")]
90 pub fn backward_line(&mut self) -> bool {
91 unsafe { from_glib(ffi::gtk_text_iter_backward_line(self.to_glib_none_mut().0)) }
92 }
93
94 #[doc(alias = "gtk_text_iter_backward_lines")]
95 pub fn backward_lines(&mut self, count: i32) -> bool {
96 unsafe {
97 from_glib(ffi::gtk_text_iter_backward_lines(
98 self.to_glib_none_mut().0,
99 count,
100 ))
101 }
102 }
103
104 #[doc(alias = "gtk_text_iter_backward_search")]
105 pub fn backward_search(
106 &self,
107 str: &str,
108 flags: TextSearchFlags,
109 limit: Option<&TextIter>,
110 ) -> Option<(TextIter, TextIter)> {
111 unsafe {
112 let mut match_start = TextIter::uninitialized();
113 let mut match_end = TextIter::uninitialized();
114 let ret = from_glib(ffi::gtk_text_iter_backward_search(
115 self.to_glib_none().0,
116 str.to_glib_none().0,
117 flags.into_glib(),
118 match_start.to_glib_none_mut().0,
119 match_end.to_glib_none_mut().0,
120 limit.to_glib_none().0,
121 ));
122 if ret {
123 Some((match_start, match_end))
124 } else {
125 None
126 }
127 }
128 }
129
130 #[doc(alias = "gtk_text_iter_backward_sentence_start")]
131 pub fn backward_sentence_start(&mut self) -> bool {
132 unsafe {
133 from_glib(ffi::gtk_text_iter_backward_sentence_start(
134 self.to_glib_none_mut().0,
135 ))
136 }
137 }
138
139 #[doc(alias = "gtk_text_iter_backward_sentence_starts")]
140 pub fn backward_sentence_starts(&mut self, count: i32) -> bool {
141 unsafe {
142 from_glib(ffi::gtk_text_iter_backward_sentence_starts(
143 self.to_glib_none_mut().0,
144 count,
145 ))
146 }
147 }
148
149 #[doc(alias = "gtk_text_iter_backward_to_tag_toggle")]
150 pub fn backward_to_tag_toggle(&mut self, tag: Option<&impl IsA<TextTag>>) -> bool {
151 unsafe {
152 from_glib(ffi::gtk_text_iter_backward_to_tag_toggle(
153 self.to_glib_none_mut().0,
154 tag.map(|p| p.as_ref()).to_glib_none().0,
155 ))
156 }
157 }
158
159 #[doc(alias = "gtk_text_iter_backward_visible_cursor_position")]
160 pub fn backward_visible_cursor_position(&mut self) -> bool {
161 unsafe {
162 from_glib(ffi::gtk_text_iter_backward_visible_cursor_position(
163 self.to_glib_none_mut().0,
164 ))
165 }
166 }
167
168 #[doc(alias = "gtk_text_iter_backward_visible_cursor_positions")]
169 pub fn backward_visible_cursor_positions(&mut self, count: i32) -> bool {
170 unsafe {
171 from_glib(ffi::gtk_text_iter_backward_visible_cursor_positions(
172 self.to_glib_none_mut().0,
173 count,
174 ))
175 }
176 }
177
178 #[doc(alias = "gtk_text_iter_backward_visible_line")]
179 pub fn backward_visible_line(&mut self) -> bool {
180 unsafe {
181 from_glib(ffi::gtk_text_iter_backward_visible_line(
182 self.to_glib_none_mut().0,
183 ))
184 }
185 }
186
187 #[doc(alias = "gtk_text_iter_backward_visible_lines")]
188 pub fn backward_visible_lines(&mut self, count: i32) -> bool {
189 unsafe {
190 from_glib(ffi::gtk_text_iter_backward_visible_lines(
191 self.to_glib_none_mut().0,
192 count,
193 ))
194 }
195 }
196
197 #[doc(alias = "gtk_text_iter_backward_visible_word_start")]
198 pub fn backward_visible_word_start(&mut self) -> bool {
199 unsafe {
200 from_glib(ffi::gtk_text_iter_backward_visible_word_start(
201 self.to_glib_none_mut().0,
202 ))
203 }
204 }
205
206 #[doc(alias = "gtk_text_iter_backward_visible_word_starts")]
207 pub fn backward_visible_word_starts(&mut self, count: i32) -> bool {
208 unsafe {
209 from_glib(ffi::gtk_text_iter_backward_visible_word_starts(
210 self.to_glib_none_mut().0,
211 count,
212 ))
213 }
214 }
215
216 #[doc(alias = "gtk_text_iter_backward_word_start")]
217 pub fn backward_word_start(&mut self) -> bool {
218 unsafe {
219 from_glib(ffi::gtk_text_iter_backward_word_start(
220 self.to_glib_none_mut().0,
221 ))
222 }
223 }
224
225 #[doc(alias = "gtk_text_iter_backward_word_starts")]
226 pub fn backward_word_starts(&mut self, count: i32) -> bool {
227 unsafe {
228 from_glib(ffi::gtk_text_iter_backward_word_starts(
229 self.to_glib_none_mut().0,
230 count,
231 ))
232 }
233 }
234
235 #[doc(alias = "gtk_text_iter_can_insert")]
236 pub fn can_insert(&self, default_editability: bool) -> bool {
237 unsafe {
238 from_glib(ffi::gtk_text_iter_can_insert(
239 self.to_glib_none().0,
240 default_editability.into_glib(),
241 ))
242 }
243 }
244
245 #[doc(alias = "gtk_text_iter_compare")]
246 fn compare(&self, rhs: &TextIter) -> i32 {
247 unsafe { ffi::gtk_text_iter_compare(self.to_glib_none().0, rhs.to_glib_none().0) }
248 }
249
250 #[doc(alias = "gtk_text_iter_editable")]
251 pub fn editable(&self, default_setting: bool) -> bool {
252 unsafe {
253 from_glib(ffi::gtk_text_iter_editable(
254 self.to_glib_none().0,
255 default_setting.into_glib(),
256 ))
257 }
258 }
259
260 #[doc(alias = "gtk_text_iter_ends_line")]
261 pub fn ends_line(&self) -> bool {
262 unsafe { from_glib(ffi::gtk_text_iter_ends_line(self.to_glib_none().0)) }
263 }
264
265 #[doc(alias = "gtk_text_iter_ends_sentence")]
266 pub fn ends_sentence(&self) -> bool {
267 unsafe { from_glib(ffi::gtk_text_iter_ends_sentence(self.to_glib_none().0)) }
268 }
269
270 #[doc(alias = "gtk_text_iter_ends_tag")]
271 pub fn ends_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
272 unsafe {
273 from_glib(ffi::gtk_text_iter_ends_tag(
274 self.to_glib_none().0,
275 tag.map(|p| p.as_ref()).to_glib_none().0,
276 ))
277 }
278 }
279
280 #[doc(alias = "gtk_text_iter_ends_word")]
281 pub fn ends_word(&self) -> bool {
282 unsafe { from_glib(ffi::gtk_text_iter_ends_word(self.to_glib_none().0)) }
283 }
284
285 #[doc(alias = "gtk_text_iter_equal")]
286 fn equal(&self, rhs: &TextIter) -> bool {
287 unsafe {
288 from_glib(ffi::gtk_text_iter_equal(
289 self.to_glib_none().0,
290 rhs.to_glib_none().0,
291 ))
292 }
293 }
294
295 #[doc(alias = "gtk_text_iter_forward_char")]
296 pub fn forward_char(&mut self) -> bool {
297 unsafe { from_glib(ffi::gtk_text_iter_forward_char(self.to_glib_none_mut().0)) }
298 }
299
300 #[doc(alias = "gtk_text_iter_forward_chars")]
301 pub fn forward_chars(&mut self, count: i32) -> bool {
302 unsafe {
303 from_glib(ffi::gtk_text_iter_forward_chars(
304 self.to_glib_none_mut().0,
305 count,
306 ))
307 }
308 }
309
310 #[doc(alias = "gtk_text_iter_forward_cursor_position")]
311 pub fn forward_cursor_position(&mut self) -> bool {
312 unsafe {
313 from_glib(ffi::gtk_text_iter_forward_cursor_position(
314 self.to_glib_none_mut().0,
315 ))
316 }
317 }
318
319 #[doc(alias = "gtk_text_iter_forward_cursor_positions")]
320 pub fn forward_cursor_positions(&mut self, count: i32) -> bool {
321 unsafe {
322 from_glib(ffi::gtk_text_iter_forward_cursor_positions(
323 self.to_glib_none_mut().0,
324 count,
325 ))
326 }
327 }
328
329 #[doc(alias = "gtk_text_iter_forward_find_char")]
330 pub fn forward_find_char<P: FnMut(char) -> bool>(
331 &mut self,
332 pred: P,
333 limit: Option<&TextIter>,
334 ) -> bool {
335 let mut pred_data: P = pred;
336 unsafe extern "C" fn pred_func<P: FnMut(char) -> bool>(
337 ch: u32,
338 user_data: glib::ffi::gpointer,
339 ) -> glib::ffi::gboolean {
340 let ch = std::convert::TryFrom::try_from(ch)
341 .expect("conversion from an invalid Unicode value attempted");
342 let callback = user_data as *mut P;
343 (*callback)(ch).into_glib()
344 }
345 let pred = Some(pred_func::<P> as _);
346 let super_callback0: &mut P = &mut pred_data;
347 unsafe {
348 from_glib(ffi::gtk_text_iter_forward_find_char(
349 self.to_glib_none_mut().0,
350 pred,
351 super_callback0 as *mut _ as *mut _,
352 limit.to_glib_none().0,
353 ))
354 }
355 }
356
357 #[doc(alias = "gtk_text_iter_forward_line")]
358 pub fn forward_line(&mut self) -> bool {
359 unsafe { from_glib(ffi::gtk_text_iter_forward_line(self.to_glib_none_mut().0)) }
360 }
361
362 #[doc(alias = "gtk_text_iter_forward_lines")]
363 pub fn forward_lines(&mut self, count: i32) -> bool {
364 unsafe {
365 from_glib(ffi::gtk_text_iter_forward_lines(
366 self.to_glib_none_mut().0,
367 count,
368 ))
369 }
370 }
371
372 #[doc(alias = "gtk_text_iter_forward_search")]
373 pub fn forward_search(
374 &self,
375 str: &str,
376 flags: TextSearchFlags,
377 limit: Option<&TextIter>,
378 ) -> Option<(TextIter, TextIter)> {
379 unsafe {
380 let mut match_start = TextIter::uninitialized();
381 let mut match_end = TextIter::uninitialized();
382 let ret = from_glib(ffi::gtk_text_iter_forward_search(
383 self.to_glib_none().0,
384 str.to_glib_none().0,
385 flags.into_glib(),
386 match_start.to_glib_none_mut().0,
387 match_end.to_glib_none_mut().0,
388 limit.to_glib_none().0,
389 ));
390 if ret {
391 Some((match_start, match_end))
392 } else {
393 None
394 }
395 }
396 }
397
398 #[doc(alias = "gtk_text_iter_forward_sentence_end")]
399 pub fn forward_sentence_end(&mut self) -> bool {
400 unsafe {
401 from_glib(ffi::gtk_text_iter_forward_sentence_end(
402 self.to_glib_none_mut().0,
403 ))
404 }
405 }
406
407 #[doc(alias = "gtk_text_iter_forward_sentence_ends")]
408 pub fn forward_sentence_ends(&mut self, count: i32) -> bool {
409 unsafe {
410 from_glib(ffi::gtk_text_iter_forward_sentence_ends(
411 self.to_glib_none_mut().0,
412 count,
413 ))
414 }
415 }
416
417 #[doc(alias = "gtk_text_iter_forward_to_end")]
418 pub fn forward_to_end(&mut self) {
419 unsafe {
420 ffi::gtk_text_iter_forward_to_end(self.to_glib_none_mut().0);
421 }
422 }
423
424 #[doc(alias = "gtk_text_iter_forward_to_line_end")]
425 pub fn forward_to_line_end(&mut self) -> bool {
426 unsafe {
427 from_glib(ffi::gtk_text_iter_forward_to_line_end(
428 self.to_glib_none_mut().0,
429 ))
430 }
431 }
432
433 #[doc(alias = "gtk_text_iter_forward_to_tag_toggle")]
434 pub fn forward_to_tag_toggle(&mut self, tag: Option<&impl IsA<TextTag>>) -> bool {
435 unsafe {
436 from_glib(ffi::gtk_text_iter_forward_to_tag_toggle(
437 self.to_glib_none_mut().0,
438 tag.map(|p| p.as_ref()).to_glib_none().0,
439 ))
440 }
441 }
442
443 #[doc(alias = "gtk_text_iter_forward_visible_cursor_position")]
444 pub fn forward_visible_cursor_position(&mut self) -> bool {
445 unsafe {
446 from_glib(ffi::gtk_text_iter_forward_visible_cursor_position(
447 self.to_glib_none_mut().0,
448 ))
449 }
450 }
451
452 #[doc(alias = "gtk_text_iter_forward_visible_cursor_positions")]
453 pub fn forward_visible_cursor_positions(&mut self, count: i32) -> bool {
454 unsafe {
455 from_glib(ffi::gtk_text_iter_forward_visible_cursor_positions(
456 self.to_glib_none_mut().0,
457 count,
458 ))
459 }
460 }
461
462 #[doc(alias = "gtk_text_iter_forward_visible_line")]
463 pub fn forward_visible_line(&mut self) -> bool {
464 unsafe {
465 from_glib(ffi::gtk_text_iter_forward_visible_line(
466 self.to_glib_none_mut().0,
467 ))
468 }
469 }
470
471 #[doc(alias = "gtk_text_iter_forward_visible_lines")]
472 pub fn forward_visible_lines(&mut self, count: i32) -> bool {
473 unsafe {
474 from_glib(ffi::gtk_text_iter_forward_visible_lines(
475 self.to_glib_none_mut().0,
476 count,
477 ))
478 }
479 }
480
481 #[doc(alias = "gtk_text_iter_forward_visible_word_end")]
482 pub fn forward_visible_word_end(&mut self) -> bool {
483 unsafe {
484 from_glib(ffi::gtk_text_iter_forward_visible_word_end(
485 self.to_glib_none_mut().0,
486 ))
487 }
488 }
489
490 #[doc(alias = "gtk_text_iter_forward_visible_word_ends")]
491 pub fn forward_visible_word_ends(&mut self, count: i32) -> bool {
492 unsafe {
493 from_glib(ffi::gtk_text_iter_forward_visible_word_ends(
494 self.to_glib_none_mut().0,
495 count,
496 ))
497 }
498 }
499
500 #[doc(alias = "gtk_text_iter_forward_word_end")]
501 pub fn forward_word_end(&mut self) -> bool {
502 unsafe {
503 from_glib(ffi::gtk_text_iter_forward_word_end(
504 self.to_glib_none_mut().0,
505 ))
506 }
507 }
508
509 #[doc(alias = "gtk_text_iter_forward_word_ends")]
510 pub fn forward_word_ends(&mut self, count: i32) -> bool {
511 unsafe {
512 from_glib(ffi::gtk_text_iter_forward_word_ends(
513 self.to_glib_none_mut().0,
514 count,
515 ))
516 }
517 }
518
519 #[doc(alias = "gtk_text_iter_get_buffer")]
520 #[doc(alias = "get_buffer")]
521 pub fn buffer(&self) -> TextBuffer {
522 unsafe { from_glib_none(ffi::gtk_text_iter_get_buffer(self.to_glib_none().0)) }
523 }
524
525 #[doc(alias = "gtk_text_iter_get_bytes_in_line")]
526 #[doc(alias = "get_bytes_in_line")]
527 pub fn bytes_in_line(&self) -> i32 {
528 unsafe { ffi::gtk_text_iter_get_bytes_in_line(self.to_glib_none().0) }
529 }
530
531 #[doc(alias = "gtk_text_iter_get_char")]
532 #[doc(alias = "get_char")]
533 pub fn char(&self) -> char {
534 unsafe {
535 std::convert::TryFrom::try_from(ffi::gtk_text_iter_get_char(self.to_glib_none().0))
536 .expect("conversion from an invalid Unicode value attempted")
537 }
538 }
539
540 #[doc(alias = "gtk_text_iter_get_chars_in_line")]
541 #[doc(alias = "get_chars_in_line")]
542 pub fn chars_in_line(&self) -> i32 {
543 unsafe { ffi::gtk_text_iter_get_chars_in_line(self.to_glib_none().0) }
544 }
545
546 #[doc(alias = "gtk_text_iter_get_child_anchor")]
547 #[doc(alias = "get_child_anchor")]
548 pub fn child_anchor(&self) -> Option<TextChildAnchor> {
549 unsafe { from_glib_none(ffi::gtk_text_iter_get_child_anchor(self.to_glib_none().0)) }
550 }
551
552 #[doc(alias = "gtk_text_iter_get_language")]
553 #[doc(alias = "get_language")]
554 pub fn language(&self) -> pango::Language {
555 unsafe { from_glib_full(ffi::gtk_text_iter_get_language(self.to_glib_none().0)) }
556 }
557
558 #[doc(alias = "gtk_text_iter_get_line")]
559 #[doc(alias = "get_line")]
560 pub fn line(&self) -> i32 {
561 unsafe { ffi::gtk_text_iter_get_line(self.to_glib_none().0) }
562 }
563
564 #[doc(alias = "gtk_text_iter_get_line_index")]
565 #[doc(alias = "get_line_index")]
566 pub fn line_index(&self) -> i32 {
567 unsafe { ffi::gtk_text_iter_get_line_index(self.to_glib_none().0) }
568 }
569
570 #[doc(alias = "gtk_text_iter_get_line_offset")]
571 #[doc(alias = "get_line_offset")]
572 pub fn line_offset(&self) -> i32 {
573 unsafe { ffi::gtk_text_iter_get_line_offset(self.to_glib_none().0) }
574 }
575
576 #[doc(alias = "gtk_text_iter_get_marks")]
577 #[doc(alias = "get_marks")]
578 pub fn marks(&self) -> Vec<TextMark> {
579 unsafe {
580 FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_marks(
581 self.to_glib_none().0,
582 ))
583 }
584 }
585
586 #[doc(alias = "gtk_text_iter_get_offset")]
587 #[doc(alias = "get_offset")]
588 pub fn offset(&self) -> i32 {
589 unsafe { ffi::gtk_text_iter_get_offset(self.to_glib_none().0) }
590 }
591
592 #[doc(alias = "gtk_text_iter_get_paintable")]
593 #[doc(alias = "get_paintable")]
594 pub fn paintable(&self) -> Option<gdk::Paintable> {
595 unsafe { from_glib_none(ffi::gtk_text_iter_get_paintable(self.to_glib_none().0)) }
596 }
597
598 #[doc(alias = "gtk_text_iter_get_slice")]
599 #[doc(alias = "get_slice")]
600 pub fn slice(&self, end: &TextIter) -> glib::GString {
601 unsafe {
602 from_glib_full(ffi::gtk_text_iter_get_slice(
603 self.to_glib_none().0,
604 end.to_glib_none().0,
605 ))
606 }
607 }
608
609 #[doc(alias = "gtk_text_iter_get_tags")]
610 #[doc(alias = "get_tags")]
611 pub fn tags(&self) -> Vec<TextTag> {
612 unsafe {
613 FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_tags(
614 self.to_glib_none().0,
615 ))
616 }
617 }
618
619 #[doc(alias = "gtk_text_iter_get_text")]
620 #[doc(alias = "get_text")]
621 pub fn text(&self, end: &TextIter) -> glib::GString {
622 unsafe {
623 from_glib_full(ffi::gtk_text_iter_get_text(
624 self.to_glib_none().0,
625 end.to_glib_none().0,
626 ))
627 }
628 }
629
630 #[doc(alias = "gtk_text_iter_get_toggled_tags")]
631 #[doc(alias = "get_toggled_tags")]
632 pub fn toggled_tags(&self, toggled_on: bool) -> Vec<TextTag> {
633 unsafe {
634 FromGlibPtrContainer::from_glib_container(ffi::gtk_text_iter_get_toggled_tags(
635 self.to_glib_none().0,
636 toggled_on.into_glib(),
637 ))
638 }
639 }
640
641 #[doc(alias = "gtk_text_iter_get_visible_line_index")]
642 #[doc(alias = "get_visible_line_index")]
643 pub fn visible_line_index(&self) -> i32 {
644 unsafe { ffi::gtk_text_iter_get_visible_line_index(self.to_glib_none().0) }
645 }
646
647 #[doc(alias = "gtk_text_iter_get_visible_line_offset")]
648 #[doc(alias = "get_visible_line_offset")]
649 pub fn visible_line_offset(&self) -> i32 {
650 unsafe { ffi::gtk_text_iter_get_visible_line_offset(self.to_glib_none().0) }
651 }
652
653 #[doc(alias = "gtk_text_iter_get_visible_slice")]
654 #[doc(alias = "get_visible_slice")]
655 pub fn visible_slice(&self, end: &TextIter) -> glib::GString {
656 unsafe {
657 from_glib_full(ffi::gtk_text_iter_get_visible_slice(
658 self.to_glib_none().0,
659 end.to_glib_none().0,
660 ))
661 }
662 }
663
664 #[doc(alias = "gtk_text_iter_get_visible_text")]
665 #[doc(alias = "get_visible_text")]
666 pub fn visible_text(&self, end: &TextIter) -> glib::GString {
667 unsafe {
668 from_glib_full(ffi::gtk_text_iter_get_visible_text(
669 self.to_glib_none().0,
670 end.to_glib_none().0,
671 ))
672 }
673 }
674
675 #[doc(alias = "gtk_text_iter_has_tag")]
676 pub fn has_tag(&self, tag: &impl IsA<TextTag>) -> bool {
677 unsafe {
678 from_glib(ffi::gtk_text_iter_has_tag(
679 self.to_glib_none().0,
680 tag.as_ref().to_glib_none().0,
681 ))
682 }
683 }
684
685 #[doc(alias = "gtk_text_iter_in_range")]
686 pub fn in_range(&self, start: &TextIter, end: &TextIter) -> bool {
687 unsafe {
688 from_glib(ffi::gtk_text_iter_in_range(
689 self.to_glib_none().0,
690 start.to_glib_none().0,
691 end.to_glib_none().0,
692 ))
693 }
694 }
695
696 #[doc(alias = "gtk_text_iter_inside_sentence")]
697 pub fn inside_sentence(&self) -> bool {
698 unsafe { from_glib(ffi::gtk_text_iter_inside_sentence(self.to_glib_none().0)) }
699 }
700
701 #[doc(alias = "gtk_text_iter_inside_word")]
702 pub fn inside_word(&self) -> bool {
703 unsafe { from_glib(ffi::gtk_text_iter_inside_word(self.to_glib_none().0)) }
704 }
705
706 #[doc(alias = "gtk_text_iter_is_cursor_position")]
707 pub fn is_cursor_position(&self) -> bool {
708 unsafe { from_glib(ffi::gtk_text_iter_is_cursor_position(self.to_glib_none().0)) }
709 }
710
711 #[doc(alias = "gtk_text_iter_is_end")]
712 pub fn is_end(&self) -> bool {
713 unsafe { from_glib(ffi::gtk_text_iter_is_end(self.to_glib_none().0)) }
714 }
715
716 #[doc(alias = "gtk_text_iter_is_start")]
717 pub fn is_start(&self) -> bool {
718 unsafe { from_glib(ffi::gtk_text_iter_is_start(self.to_glib_none().0)) }
719 }
720
721 #[doc(alias = "gtk_text_iter_order")]
722 pub fn order(&mut self, second: &mut TextIter) {
723 unsafe {
724 ffi::gtk_text_iter_order(self.to_glib_none_mut().0, second.to_glib_none_mut().0);
725 }
726 }
727
728 #[doc(alias = "gtk_text_iter_set_line")]
729 pub fn set_line(&mut self, line_number: i32) {
730 unsafe {
731 ffi::gtk_text_iter_set_line(self.to_glib_none_mut().0, line_number);
732 }
733 }
734
735 #[doc(alias = "gtk_text_iter_set_line_index")]
736 pub fn set_line_index(&mut self, byte_on_line: i32) {
737 unsafe {
738 ffi::gtk_text_iter_set_line_index(self.to_glib_none_mut().0, byte_on_line);
739 }
740 }
741
742 #[doc(alias = "gtk_text_iter_set_line_offset")]
743 pub fn set_line_offset(&mut self, char_on_line: i32) {
744 unsafe {
745 ffi::gtk_text_iter_set_line_offset(self.to_glib_none_mut().0, char_on_line);
746 }
747 }
748
749 #[doc(alias = "gtk_text_iter_set_offset")]
750 pub fn set_offset(&mut self, char_offset: i32) {
751 unsafe {
752 ffi::gtk_text_iter_set_offset(self.to_glib_none_mut().0, char_offset);
753 }
754 }
755
756 #[doc(alias = "gtk_text_iter_set_visible_line_index")]
757 pub fn set_visible_line_index(&mut self, byte_on_line: i32) {
758 unsafe {
759 ffi::gtk_text_iter_set_visible_line_index(self.to_glib_none_mut().0, byte_on_line);
760 }
761 }
762
763 #[doc(alias = "gtk_text_iter_set_visible_line_offset")]
764 pub fn set_visible_line_offset(&mut self, char_on_line: i32) {
765 unsafe {
766 ffi::gtk_text_iter_set_visible_line_offset(self.to_glib_none_mut().0, char_on_line);
767 }
768 }
769
770 #[doc(alias = "gtk_text_iter_starts_line")]
771 pub fn starts_line(&self) -> bool {
772 unsafe { from_glib(ffi::gtk_text_iter_starts_line(self.to_glib_none().0)) }
773 }
774
775 #[doc(alias = "gtk_text_iter_starts_sentence")]
776 pub fn starts_sentence(&self) -> bool {
777 unsafe { from_glib(ffi::gtk_text_iter_starts_sentence(self.to_glib_none().0)) }
778 }
779
780 #[doc(alias = "gtk_text_iter_starts_tag")]
781 pub fn starts_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
782 unsafe {
783 from_glib(ffi::gtk_text_iter_starts_tag(
784 self.to_glib_none().0,
785 tag.map(|p| p.as_ref()).to_glib_none().0,
786 ))
787 }
788 }
789
790 #[doc(alias = "gtk_text_iter_starts_word")]
791 pub fn starts_word(&self) -> bool {
792 unsafe { from_glib(ffi::gtk_text_iter_starts_word(self.to_glib_none().0)) }
793 }
794
795 #[doc(alias = "gtk_text_iter_toggles_tag")]
796 pub fn toggles_tag(&self, tag: Option<&impl IsA<TextTag>>) -> bool {
797 unsafe {
798 from_glib(ffi::gtk_text_iter_toggles_tag(
799 self.to_glib_none().0,
800 tag.map(|p| p.as_ref()).to_glib_none().0,
801 ))
802 }
803 }
804}
805
806impl PartialOrd for TextIter {
807 #[inline]
808 fn partial_cmp(&self, other: &Self) -> Option<std::cmp::Ordering> {
809 Some(self.cmp(other))
810 }
811}
812
813impl Ord for TextIter {
814 #[inline]
815 fn cmp(&self, other: &Self) -> std::cmp::Ordering {
816 self.compare(other).cmp(&0)
817 }
818}
819
820impl PartialEq for TextIter {
821 #[inline]
822 fn eq(&self, other: &Self) -> bool {
823 self.equal(other)
824 }
825}
826
827impl Eq for TextIter {}