1// Package gtk was automatically generated by github.com/bnema/puregotk DO NOT EDIT
2package gtk
3
4import (
5 "structs"
6 "unsafe"
7
8 "github.com/ebitengine/purego"
9
10 "github.com/bnema/puregotk/pkg/core"
11 "github.com/bnema/puregotk/v4/gdk"
12 "github.com/bnema/puregotk/v4/glib"
13 "github.com/bnema/puregotk/v4/gobject"
14 "github.com/bnema/puregotk/v4/gobject/types"
15 "github.com/bnema/puregotk/v4/pango"
16)
17
18// The predicate function used by gtk_text_iter_forward_find_char() and
19// gtk_text_iter_backward_find_char().
20type TextCharPredicate func(uint32, uintptr) bool
21
22// Iterates over the contents of a `GtkTextBuffer`.
23//
24// You may wish to begin by reading the
25// [text widget conceptual overview](section-text-widget.html),
26// which gives an overview of all the objects and data types
27// related to the text widget and how they work together.
28type TextIter struct {
29 _ structs.HostLayout
30
31 Dummy1 uintptr
32
33 Dummy2 uintptr
34
35 Dummy3 int
36
37 Dummy4 int
38
39 Dummy5 int
40
41 Dummy6 int
42
43 Dummy7 int
44
45 Dummy8 int
46
47 Dummy9 uintptr
48
49 Dummy10 uintptr
50
51 Dummy11 int
52
53 Dummy12 int
54
55 Dummy13 int
56
57 Dummy14 uintptr
58}
59
60var xTextIterGLibType func() types.GType
61
62func TextIterGLibType() types.GType {
63 return xTextIterGLibType()
64}
65
66func (x *TextIter) GoPointer() uintptr {
67 return uintptr(unsafe.Pointer(x))
68}
69
70var xTextIterAssign func(uintptr, *TextIter)
71
72// Assigns the value of @other to @iter.
73//
74// This function is not useful in applications, because
75// iterators can be assigned with `GtkTextIter i = j;`.
76//
77// The function is used by language bindings.
78func (x *TextIter) Assign(OtherVar *TextIter) {
79
80 xTextIterAssign(x.GoPointer(), OtherVar)
81
82}
83
84var xTextIterBackwardChar func(uintptr) bool
85
86// Moves backward by one character offset.
87//
88// Returns %TRUE if movement was possible; if @iter was the first
89// in the buffer (character offset 0), this function returns %FALSE
90// for convenience when writing loops.
91func (x *TextIter) BackwardChar() bool {
92
93 cret := xTextIterBackwardChar(x.GoPointer())
94 return cret
95}
96
97var xTextIterBackwardChars func(uintptr, int) bool
98
99// Moves @count characters backward, if possible.
100//
101// If @count would move past the start or end of the buffer, moves
102// to the start or end of the buffer.
103//
104// The return value indicates whether the iterator moved
105// onto a dereferenceable position; if the iterator didn’t move, or
106// moved onto the end iterator, then %FALSE is returned. If @count is 0,
107// the function does nothing and returns %FALSE.
108func (x *TextIter) BackwardChars(CountVar int) bool {
109
110 cret := xTextIterBackwardChars(x.GoPointer(), CountVar)
111 return cret
112}
113
114var xTextIterBackwardCursorPosition func(uintptr) bool
115
116// Like [method@Gtk.TextIter.forward_cursor_position], but moves backward.
117func (x *TextIter) BackwardCursorPosition() bool {
118
119 cret := xTextIterBackwardCursorPosition(x.GoPointer())
120 return cret
121}
122
123var xTextIterBackwardCursorPositions func(uintptr, int) bool
124
125// Moves up to @count cursor positions.
126//
127// See [method@Gtk.TextIter.forward_cursor_position] for details.
128func (x *TextIter) BackwardCursorPositions(CountVar int) bool {
129
130 cret := xTextIterBackwardCursorPositions(x.GoPointer(), CountVar)
131 return cret
132}
133
134var xTextIterBackwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
135
136// Same as [method@Gtk.TextIter.forward_find_char],
137// but goes backward from @iter.
138func (x *TextIter) BackwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
139
140 var PredVarRef uintptr
141 if PredVar != nil {
142 PredVarPtr := uintptr(unsafe.Pointer(PredVar))
143 if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
144 PredVarRef = cbRefPtr
145 } else {
146 fcb := func(arg0 uint32, arg1 uintptr) bool {
147 cbFn := *PredVar
148 return cbFn(arg0, arg1)
149 }
150 PredVarRef = purego.NewCallback(fcb)
151 glib.SaveCallbackWithClosure(PredVarPtr, PredVarRef, PredVar)
152 }
153 }
154
155 cret := xTextIterBackwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)
156 return cret
157}
158
159var xTextIterBackwardLine func(uintptr) bool
160
161// Moves @iter to the start of the previous line.
162//
163// Returns %TRUE if @iter could be moved; i.e. if @iter was at
164// character offset 0, this function returns %FALSE. Therefore,
165// if @iter was already on line 0, but not at the start of the line,
166// @iter is snapped to the start of the line and the function returns
167// %TRUE. (Note that this implies that
168// in a loop calling this function, the line number may not change on
169// every iteration, if your first iteration is on line 0.)
170func (x *TextIter) BackwardLine() bool {
171
172 cret := xTextIterBackwardLine(x.GoPointer())
173 return cret
174}
175
176var xTextIterBackwardLines func(uintptr, int) bool
177
178// Moves @count lines backward, if possible.
179//
180// If @count would move past the start or end of the buffer, moves to
181// the start or end of the buffer.
182//
183// The return value indicates whether the iterator moved
184// onto a dereferenceable position; if the iterator didn’t move, or
185// moved onto the end iterator, then %FALSE is returned. If @count is 0,
186// the function does nothing and returns %FALSE. If @count is negative,
187// moves forward by 0 - @count lines.
188func (x *TextIter) BackwardLines(CountVar int) bool {
189
190 cret := xTextIterBackwardLines(x.GoPointer(), CountVar)
191 return cret
192}
193
194var xTextIterBackwardSearch func(uintptr, string, TextSearchFlags, *TextIter, *TextIter, *TextIter) bool
195
196// Same as [method@Gtk.TextIter.forward_search], but moves backward.
197//
198// @match_end will never be set to a `GtkTextIter` located after @iter,
199// even if there is a possible @match_start before or at @iter.
200func (x *TextIter) BackwardSearch(StrVar string, FlagsVar TextSearchFlags, MatchStartVar *TextIter, MatchEndVar *TextIter, LimitVar *TextIter) bool {
201
202 cret := xTextIterBackwardSearch(x.GoPointer(), StrVar, FlagsVar, MatchStartVar, MatchEndVar, LimitVar)
203 return cret
204}
205
206var xTextIterBackwardSentenceStart func(uintptr) bool
207
208// Moves backward to the previous sentence start.
209//
210// If @iter is already at the start of a sentence, moves backward
211// to the next one.
212//
213// Sentence boundaries are determined by Pango and should
214// be correct for nearly any language.
215func (x *TextIter) BackwardSentenceStart() bool {
216
217 cret := xTextIterBackwardSentenceStart(x.GoPointer())
218 return cret
219}
220
221var xTextIterBackwardSentenceStarts func(uintptr, int) bool
222
223// Calls [method@Gtk.TextIter.backward_sentence_start] up to @count times.
224//
225// If @count is negative, moves forward instead of backward.
226func (x *TextIter) BackwardSentenceStarts(CountVar int) bool {
227
228 cret := xTextIterBackwardSentenceStarts(x.GoPointer(), CountVar)
229 return cret
230}
231
232var xTextIterBackwardToTagToggle func(uintptr, uintptr) bool
233
234// Moves backward to the next toggle (on or off) of the
235// @tag, or to the next toggle of any tag if
236// @tag is %NULL.
237//
238// If no matching tag toggles are found,
239// returns %FALSE, otherwise %TRUE. Does not return toggles
240// located at @iter, only toggles before @iter. Sets @iter
241// to the location of the toggle, or the start of the buffer
242// if no toggle is found.
243func (x *TextIter) BackwardToTagToggle(TagVar *TextTag) bool {
244
245 cret := xTextIterBackwardToTagToggle(x.GoPointer(), TagVar.GoPointer())
246 return cret
247}
248
249var xTextIterBackwardVisibleCursorPosition func(uintptr) bool
250
251// Moves @iter backward to the previous visible cursor position.
252//
253// See [method@Gtk.TextIter.backward_cursor_position] for details.
254func (x *TextIter) BackwardVisibleCursorPosition() bool {
255
256 cret := xTextIterBackwardVisibleCursorPosition(x.GoPointer())
257 return cret
258}
259
260var xTextIterBackwardVisibleCursorPositions func(uintptr, int) bool
261
262// Moves up to @count visible cursor positions.
263//
264// See [method@Gtk.TextIter.backward_cursor_position] for details.
265func (x *TextIter) BackwardVisibleCursorPositions(CountVar int) bool {
266
267 cret := xTextIterBackwardVisibleCursorPositions(x.GoPointer(), CountVar)
268 return cret
269}
270
271var xTextIterBackwardVisibleLine func(uintptr) bool
272
273// Moves @iter to the start of the previous visible line.
274//
275// Returns %TRUE if
276// @iter could be moved; i.e. if @iter was at character offset 0, this
277// function returns %FALSE. Therefore if @iter was already on line 0,
278// but not at the start of the line, @iter is snapped to the start of
279// the line and the function returns %TRUE. (Note that this implies that
280// in a loop calling this function, the line number may not change on
281// every iteration, if your first iteration is on line 0.)
282func (x *TextIter) BackwardVisibleLine() bool {
283
284 cret := xTextIterBackwardVisibleLine(x.GoPointer())
285 return cret
286}
287
288var xTextIterBackwardVisibleLines func(uintptr, int) bool
289
290// Moves @count visible lines backward, if possible.
291//
292// If @count would move past the start or end of the buffer, moves to
293// the start or end of the buffer.
294//
295// The return value indicates whether the iterator moved
296// onto a dereferenceable position; if the iterator didn’t move, or
297// moved onto the end iterator, then %FALSE is returned. If @count is 0,
298// the function does nothing and returns %FALSE. If @count is negative,
299// moves forward by 0 - @count lines.
300func (x *TextIter) BackwardVisibleLines(CountVar int) bool {
301
302 cret := xTextIterBackwardVisibleLines(x.GoPointer(), CountVar)
303 return cret
304}
305
306var xTextIterBackwardVisibleWordStart func(uintptr) bool
307
308// Moves backward to the previous visible word start.
309//
310// If @iter is currently on a word start, moves backward to the
311// next one after that.
312//
313// Word breaks are determined by Pango and should be correct
314// for nearly any language.
315func (x *TextIter) BackwardVisibleWordStart() bool {
316
317 cret := xTextIterBackwardVisibleWordStart(x.GoPointer())
318 return cret
319}
320
321var xTextIterBackwardVisibleWordStarts func(uintptr, int) bool
322
323// Calls [method@Gtk.TextIter.backward_visible_word_start] up to @count times.
324func (x *TextIter) BackwardVisibleWordStarts(CountVar int) bool {
325
326 cret := xTextIterBackwardVisibleWordStarts(x.GoPointer(), CountVar)
327 return cret
328}
329
330var xTextIterBackwardWordStart func(uintptr) bool
331
332// Moves backward to the previous word start.
333//
334// If @iter is currently on a word start, moves backward to the
335// next one after that.
336//
337// Word breaks are determined by Pango and should be correct
338// for nearly any language
339func (x *TextIter) BackwardWordStart() bool {
340
341 cret := xTextIterBackwardWordStart(x.GoPointer())
342 return cret
343}
344
345var xTextIterBackwardWordStarts func(uintptr, int) bool
346
347// Calls [method@Gtk.TextIter.backward_word_start] up to @count times.
348func (x *TextIter) BackwardWordStarts(CountVar int) bool {
349
350 cret := xTextIterBackwardWordStarts(x.GoPointer(), CountVar)
351 return cret
352}
353
354var xTextIterCanInsert func(uintptr, bool) bool
355
356// Considering the default editability of the buffer, and tags that
357// affect editability, determines whether text inserted at @iter would
358// be editable.
359//
360// If text inserted at @iter would be editable then the
361// user should be allowed to insert text at @iter.
362// [method@Gtk.TextBuffer.insert_interactive] uses this function
363// to decide whether insertions are allowed at a given position.
364func (x *TextIter) CanInsert(DefaultEditabilityVar bool) bool {
365
366 cret := xTextIterCanInsert(x.GoPointer(), DefaultEditabilityVar)
367 return cret
368}
369
370var xTextIterCompare func(uintptr, *TextIter) int
371
372// A qsort()-style function that returns negative if @lhs is less than
373// @rhs, positive if @lhs is greater than @rhs, and 0 if they’re equal.
374//
375// Ordering is in character offset order, i.e. the first character
376// in the buffer is less than the second character in the buffer.
377func (x *TextIter) Compare(RhsVar *TextIter) int {
378
379 cret := xTextIterCompare(x.GoPointer(), RhsVar)
380 return cret
381}
382
383var xTextIterCopy func(uintptr) *TextIter
384
385// Creates a dynamically-allocated copy of an iterator.
386//
387// This function is not useful in applications, because
388// iterators can be copied with a simple assignment
389// (`GtkTextIter i = j;`).
390//
391// The function is used by language bindings.
392func (x *TextIter) Copy() *TextIter {
393
394 cret := xTextIterCopy(x.GoPointer())
395 return cret
396}
397
398var xTextIterEditable func(uintptr, bool) bool
399
400// Returns whether the character at @iter is within an editable region
401// of text.
402//
403// Non-editable text is “locked” and can’t be changed by the
404// user via `GtkTextView`. If no tags applied to this text affect
405// editability, @default_setting will be returned.
406//
407// You don’t want to use this function to decide whether text can be
408// inserted at @iter, because for insertion you don’t want to know
409// whether the char at @iter is inside an editable range, you want to
410// know whether a new character inserted at @iter would be inside an
411// editable range. Use [method@Gtk.TextIter.can_insert] to handle this
412// case.
413func (x *TextIter) Editable(DefaultSettingVar bool) bool {
414
415 cret := xTextIterEditable(x.GoPointer(), DefaultSettingVar)
416 return cret
417}
418
419var xTextIterEndsLine func(uintptr) bool
420
421// Returns %TRUE if @iter points to the start of the paragraph
422// delimiter characters for a line.
423//
424// Delimiters will be either a newline, a carriage return, a carriage
425// return followed by a newline, or a Unicode paragraph separator
426// character.
427//
428// Note that an iterator pointing to the \n of a \r\n pair will not be
429// counted as the end of a line, the line ends before the \r. The end
430// iterator is considered to be at the end of a line, even though there
431// are no paragraph delimiter chars there.
432func (x *TextIter) EndsLine() bool {
433
434 cret := xTextIterEndsLine(x.GoPointer())
435 return cret
436}
437
438var xTextIterEndsSentence func(uintptr) bool
439
440// Determines whether @iter ends a sentence.
441//
442// Sentence boundaries are determined by Pango and should
443// be correct for nearly any language.
444func (x *TextIter) EndsSentence() bool {
445
446 cret := xTextIterEndsSentence(x.GoPointer())
447 return cret
448}
449
450var xTextIterEndsTag func(uintptr, uintptr) bool
451
452// Returns %TRUE if @tag is toggled off at exactly this point.
453//
454// If @tag is %NULL, returns %TRUE if any tag is toggled off at this point.
455//
456// Note that if this function returns %TRUE, it means that
457// @iter is at the end of the tagged range, but that the character
458// at @iter is outside the tagged range. In other words,
459// unlike [method@Gtk.TextIter.starts_tag], if this function
460// returns %TRUE, [method@Gtk.TextIter.has_tag] will return
461// %FALSE for the same parameters.
462func (x *TextIter) EndsTag(TagVar *TextTag) bool {
463
464 cret := xTextIterEndsTag(x.GoPointer(), TagVar.GoPointer())
465 return cret
466}
467
468var xTextIterEndsWord func(uintptr) bool
469
470// Determines whether @iter ends a natural-language word.
471//
472// Word breaks are determined by Pango and should be correct
473// for nearly any language.
474func (x *TextIter) EndsWord() bool {
475
476 cret := xTextIterEndsWord(x.GoPointer())
477 return cret
478}
479
480var xTextIterEqual func(uintptr, *TextIter) bool
481
482// Tests whether two iterators are equal, using the fastest possible
483// mechanism.
484//
485// This function is very fast; you can expect it to perform
486// better than e.g. getting the character offset for each
487// iterator and comparing the offsets yourself. Also, it’s a
488// bit faster than [method@Gtk.TextIter.compare].
489func (x *TextIter) Equal(RhsVar *TextIter) bool {
490
491 cret := xTextIterEqual(x.GoPointer(), RhsVar)
492 return cret
493}
494
495var xTextIterForwardChar func(uintptr) bool
496
497// Moves @iter forward by one character offset.
498//
499// Note that images embedded in the buffer occupy 1 character slot, so
500// this function may actually move onto an image instead of a character,
501// if you have images in your buffer. If @iter is the end iterator or
502// one character before it, @iter will now point at the end iterator,
503// and this function returns %FALSE for convenience when writing loops.
504func (x *TextIter) ForwardChar() bool {
505
506 cret := xTextIterForwardChar(x.GoPointer())
507 return cret
508}
509
510var xTextIterForwardChars func(uintptr, int) bool
511
512// Moves @count characters if possible.
513//
514// If @count would move past the start or end of the buffer,
515// moves to the start or end of the buffer.
516//
517// The return value indicates whether the new position of
518// @iter is different from its original position, and dereferenceable
519// (the last iterator in the buffer is not dereferenceable). If @count
520// is 0, the function does nothing and returns %FALSE.
521func (x *TextIter) ForwardChars(CountVar int) bool {
522
523 cret := xTextIterForwardChars(x.GoPointer(), CountVar)
524 return cret
525}
526
527var xTextIterForwardCursorPosition func(uintptr) bool
528
529// Moves @iter forward by a single cursor position.
530//
531// Cursor positions are (unsurprisingly) positions where the
532// cursor can appear. Perhaps surprisingly, there may not be
533// a cursor position between all characters. The most common
534// example for European languages would be a carriage return/newline
535// sequence.
536//
537// For some Unicode characters, the equivalent of say the letter “a”
538// with an accent mark will be represented as two characters, first
539// the letter then a "combining mark" that causes the accent to be
540// rendered; so the cursor can’t go between those two characters.
541//
542// See also the [struct@Pango.LogAttr] struct and the [func@Pango.break]
543// function.
544func (x *TextIter) ForwardCursorPosition() bool {
545
546 cret := xTextIterForwardCursorPosition(x.GoPointer())
547 return cret
548}
549
550var xTextIterForwardCursorPositions func(uintptr, int) bool
551
552// Moves up to @count cursor positions.
553//
554// See [method@Gtk.TextIter.forward_cursor_position] for details.
555func (x *TextIter) ForwardCursorPositions(CountVar int) bool {
556
557 cret := xTextIterForwardCursorPositions(x.GoPointer(), CountVar)
558 return cret
559}
560
561var xTextIterForwardFindChar func(uintptr, uintptr, uintptr, *TextIter) bool
562
563// Advances @iter, calling @pred on each character.
564//
565// If @pred returns %TRUE, returns %TRUE and stops scanning.
566// If @pred never returns %TRUE, @iter is set to @limit if
567// @limit is non-%NULL, otherwise to the end iterator.
568func (x *TextIter) ForwardFindChar(PredVar *TextCharPredicate, UserDataVar uintptr, LimitVar *TextIter) bool {
569
570 var PredVarRef uintptr
571 if PredVar != nil {
572 PredVarPtr := uintptr(unsafe.Pointer(PredVar))
573 if cbRefPtr, ok := glib.GetCallback(PredVarPtr); ok {
574 PredVarRef = cbRefPtr
575 } else {
576 fcb := func(arg0 uint32, arg1 uintptr) bool {
577 cbFn := *PredVar
578 return cbFn(arg0, arg1)
579 }
580 PredVarRef = purego.NewCallback(fcb)
581 glib.SaveCallbackWithClosure(PredVarPtr, PredVarRef, PredVar)
582 }
583 }
584
585 cret := xTextIterForwardFindChar(x.GoPointer(), PredVarRef, UserDataVar, LimitVar)
586 return cret
587}
588
589var xTextIterForwardLine func(uintptr) bool
590
591// Moves @iter to the start of the next line.
592//
593// If the iter is already on the last line of the buffer,
594// moves the iter to the end of the current line. If after
595// the operation, the iter is at the end of the buffer and not
596// dereferenceable, returns %FALSE. Otherwise, returns %TRUE.
597func (x *TextIter) ForwardLine() bool {
598
599 cret := xTextIterForwardLine(x.GoPointer())
600 return cret
601}
602
603var xTextIterForwardLines func(uintptr, int) bool
604
605// Moves @count lines forward, if possible.
606//
607// If @count would move past the start or end of the buffer, moves to
608// the start or end of the buffer.
609//
610// The return value indicates whether the iterator moved
611// onto a dereferenceable position; if the iterator didn’t move, or
612// moved onto the end iterator, then %FALSE is returned. If @count is 0,
613// the function does nothing and returns %FALSE. If @count is negative,
614// moves backward by 0 - @count lines.
615func (x *TextIter) ForwardLines(CountVar int) bool {
616
617 cret := xTextIterForwardLines(x.GoPointer(), CountVar)
618 return cret
619}
620
621var xTextIterForwardSearch func(uintptr, string, TextSearchFlags, *TextIter, *TextIter, *TextIter) bool
622
623// Searches forward for @str.
624//
625// Any match is returned by setting @match_start to the first character
626// of the match and @match_end to the first character after the match.
627// The search will not continue past @limit. Note that a search is a
628// linear or O(n) operation, so you may wish to use @limit to avoid
629// locking up your UI on large buffers.
630//
631// @match_start will never be set to a `GtkTextIter` located before @iter,
632// even if there is a possible @match_end after or at @iter.
633func (x *TextIter) ForwardSearch(StrVar string, FlagsVar TextSearchFlags, MatchStartVar *TextIter, MatchEndVar *TextIter, LimitVar *TextIter) bool {
634
635 cret := xTextIterForwardSearch(x.GoPointer(), StrVar, FlagsVar, MatchStartVar, MatchEndVar, LimitVar)
636 return cret
637}
638
639var xTextIterForwardSentenceEnd func(uintptr) bool
640
641// Moves forward to the next sentence end.
642//
643// If @iter is at the end of a sentence, moves to the next
644// end of sentence.
645//
646// Sentence boundaries are determined by Pango and should
647// be correct for nearly any language.
648func (x *TextIter) ForwardSentenceEnd() bool {
649
650 cret := xTextIterForwardSentenceEnd(x.GoPointer())
651 return cret
652}
653
654var xTextIterForwardSentenceEnds func(uintptr, int) bool
655
656// Calls [method@Gtk.TextIter.forward_sentence_end] @count times.
657//
658// If @count is negative, moves backward instead of forward.
659func (x *TextIter) ForwardSentenceEnds(CountVar int) bool {
660
661 cret := xTextIterForwardSentenceEnds(x.GoPointer(), CountVar)
662 return cret
663}
664
665var xTextIterForwardToEnd func(uintptr)
666
667// Moves @iter forward to the “end iterator”, which points
668// one past the last valid character in the buffer.
669//
670// [method@Gtk.TextIter.get_char] called on the end iterator
671// returns 0, which is convenient for writing loops.
672func (x *TextIter) ForwardToEnd() {
673
674 xTextIterForwardToEnd(x.GoPointer())
675
676}
677
678var xTextIterForwardToLineEnd func(uintptr) bool
679
680// Moves the iterator to point to the paragraph delimiter characters.
681//
682// The possible characters are either a newline, a carriage return,
683// a carriage return/newline in sequence, or the Unicode paragraph
684// separator character.
685//
686// If the iterator is already at the paragraph delimiter
687// characters, moves to the paragraph delimiter characters for the
688// next line. If @iter is on the last line in the buffer, which does
689// not end in paragraph delimiters, moves to the end iterator (end of
690// the last line), and returns %FALSE.
691func (x *TextIter) ForwardToLineEnd() bool {
692
693 cret := xTextIterForwardToLineEnd(x.GoPointer())
694 return cret
695}
696
697var xTextIterForwardToTagToggle func(uintptr, uintptr) bool
698
699// Moves forward to the next toggle (on or off) of the
700// @tag, or to the next toggle of any tag if
701// @tag is %NULL.
702//
703// If no matching tag toggles are found,
704// returns %FALSE, otherwise %TRUE. Does not return toggles
705// located at @iter, only toggles after @iter. Sets @iter to
706// the location of the toggle, or to the end of the buffer
707// if no toggle is found.
708func (x *TextIter) ForwardToTagToggle(TagVar *TextTag) bool {
709
710 cret := xTextIterForwardToTagToggle(x.GoPointer(), TagVar.GoPointer())
711 return cret
712}
713
714var xTextIterForwardVisibleCursorPosition func(uintptr) bool
715
716// Moves @iter forward to the next visible cursor position.
717//
718// See [method@Gtk.TextIter.forward_cursor_position] for details.
719func (x *TextIter) ForwardVisibleCursorPosition() bool {
720
721 cret := xTextIterForwardVisibleCursorPosition(x.GoPointer())
722 return cret
723}
724
725var xTextIterForwardVisibleCursorPositions func(uintptr, int) bool
726
727// Moves up to @count visible cursor positions.
728//
729// See [method@Gtk.TextIter.forward_cursor_position] for details.
730func (x *TextIter) ForwardVisibleCursorPositions(CountVar int) bool {
731
732 cret := xTextIterForwardVisibleCursorPositions(x.GoPointer(), CountVar)
733 return cret
734}
735
736var xTextIterForwardVisibleLine func(uintptr) bool
737
738// Moves @iter to the start of the next visible line.
739//
740// Returns %TRUE if there
741// was a next line to move to, and %FALSE if @iter was simply moved to
742// the end of the buffer and is now not dereferenceable, or if @iter was
743// already at the end of the buffer.
744func (x *TextIter) ForwardVisibleLine() bool {
745
746 cret := xTextIterForwardVisibleLine(x.GoPointer())
747 return cret
748}
749
750var xTextIterForwardVisibleLines func(uintptr, int) bool
751
752// Moves @count visible lines forward, if possible.
753//
754// If @count would move past the start or end of the buffer, moves to
755// the start or end of the buffer.
756//
757// The return value indicates whether the iterator moved
758// onto a dereferenceable position; if the iterator didn’t move, or
759// moved onto the end iterator, then %FALSE is returned. If @count is 0,
760// the function does nothing and returns %FALSE. If @count is negative,
761// moves backward by 0 - @count lines.
762func (x *TextIter) ForwardVisibleLines(CountVar int) bool {
763
764 cret := xTextIterForwardVisibleLines(x.GoPointer(), CountVar)
765 return cret
766}
767
768var xTextIterForwardVisibleWordEnd func(uintptr) bool
769
770// Moves forward to the next visible word end.
771//
772// If @iter is currently on a word end, moves forward to the
773// next one after that.
774//
775// Word breaks are determined by Pango and should be correct
776// for nearly any language
777func (x *TextIter) ForwardVisibleWordEnd() bool {
778
779 cret := xTextIterForwardVisibleWordEnd(x.GoPointer())
780 return cret
781}
782
783var xTextIterForwardVisibleWordEnds func(uintptr, int) bool
784
785// Calls [method@Gtk.TextIter.forward_visible_word_end] up to @count times.
786func (x *TextIter) ForwardVisibleWordEnds(CountVar int) bool {
787
788 cret := xTextIterForwardVisibleWordEnds(x.GoPointer(), CountVar)
789 return cret
790}
791
792var xTextIterForwardWordEnd func(uintptr) bool
793
794// Moves forward to the next word end.
795//
796// If @iter is currently on a word end, moves forward to the
797// next one after that.
798//
799// Word breaks are determined by Pango and should be correct
800// for nearly any language.
801func (x *TextIter) ForwardWordEnd() bool {
802
803 cret := xTextIterForwardWordEnd(x.GoPointer())
804 return cret
805}
806
807var xTextIterForwardWordEnds func(uintptr, int) bool
808
809// Calls [method@Gtk.TextIter.forward_word_end] up to @count times.
810func (x *TextIter) ForwardWordEnds(CountVar int) bool {
811
812 cret := xTextIterForwardWordEnds(x.GoPointer(), CountVar)
813 return cret
814}
815
816var xTextIterFree func(uintptr)
817
818// Free an iterator allocated on the heap.
819//
820// This function is intended for use in language bindings,
821// and is not especially useful for applications, because
822// iterators can simply be allocated on the stack.
823func (x *TextIter) Free() {
824
825 xTextIterFree(x.GoPointer())
826
827}
828
829var xTextIterGetBuffer func(uintptr) uintptr
830
831// Returns the `GtkTextBuffer` this iterator is associated with.
832func (x *TextIter) GetBuffer() *TextBuffer {
833 var cls *TextBuffer
834
835 cret := xTextIterGetBuffer(x.GoPointer())
836
837 if cret == 0 {
838 return nil
839 }
840 gobject.IncreaseRef(cret)
841 cls = &TextBuffer{}
842 cls.Ptr = cret
843 return cls
844}
845
846var xTextIterGetBytesInLine func(uintptr) int
847
848// Returns the number of bytes in the line containing @iter,
849// including the paragraph delimiters.
850func (x *TextIter) GetBytesInLine() int {
851
852 cret := xTextIterGetBytesInLine(x.GoPointer())
853 return cret
854}
855
856var xTextIterGetChar func(uintptr) uint32
857
858// The Unicode character at this iterator is returned.
859//
860// Equivalent to operator* on a C++ iterator. If the element at
861// this iterator is a non-character element, such as an image
862// embedded in the buffer, the Unicode “unknown” character 0xFFFC
863// is returned. If invoked on the end iterator, zero is returned;
864// zero is not a valid Unicode character.
865//
866// So you can write a loop which ends when this function returns 0.
867func (x *TextIter) GetChar() uint32 {
868
869 cret := xTextIterGetChar(x.GoPointer())
870 return cret
871}
872
873var xTextIterGetCharsInLine func(uintptr) int
874
875// Returns the number of characters in the line containing @iter,
876// including the paragraph delimiters.
877func (x *TextIter) GetCharsInLine() int {
878
879 cret := xTextIterGetCharsInLine(x.GoPointer())
880 return cret
881}
882
883var xTextIterGetChildAnchor func(uintptr) uintptr
884
885// If the location at @iter contains a child anchor, the
886// anchor is returned.
887//
888// Otherwise, %NULL is returned.
889func (x *TextIter) GetChildAnchor() *TextChildAnchor {
890 var cls *TextChildAnchor
891
892 cret := xTextIterGetChildAnchor(x.GoPointer())
893
894 if cret == 0 {
895 return nil
896 }
897 gobject.IncreaseRef(cret)
898 cls = &TextChildAnchor{}
899 cls.Ptr = cret
900 return cls
901}
902
903var xTextIterGetLanguage func(uintptr) *pango.Language
904
905// Returns the language in effect at @iter.
906//
907// If no tags affecting language apply to @iter, the return
908// value is identical to that of [func@Gtk.get_default_language].
909func (x *TextIter) GetLanguage() *pango.Language {
910
911 cret := xTextIterGetLanguage(x.GoPointer())
912 return cret
913}
914
915var xTextIterGetLine func(uintptr) int
916
917// Returns the line number containing the iterator.
918//
919// Lines in a `GtkTextBuffer` are numbered beginning
920// with 0 for the first line in the buffer.
921func (x *TextIter) GetLine() int {
922
923 cret := xTextIterGetLine(x.GoPointer())
924 return cret
925}
926
927var xTextIterGetLineIndex func(uintptr) int
928
929// Returns the byte index of the iterator, counting
930// from the start of a newline-terminated line.
931//
932// Remember that `GtkTextBuffer` encodes text in
933// UTF-8, and that characters can require a variable
934// number of bytes to represent.
935func (x *TextIter) GetLineIndex() int {
936
937 cret := xTextIterGetLineIndex(x.GoPointer())
938 return cret
939}
940
941var xTextIterGetLineOffset func(uintptr) int
942
943// Returns the character offset of the iterator,
944// counting from the start of a newline-terminated line.
945//
946// The first character on the line has offset 0.
947func (x *TextIter) GetLineOffset() int {
948
949 cret := xTextIterGetLineOffset(x.GoPointer())
950 return cret
951}
952
953var xTextIterGetMarks func(uintptr) *glib.SList
954
955// Returns a list of all `GtkTextMark` at this location.
956//
957// Because marks are not iterable (they don’t take up any "space"
958// in the buffer, they are just marks in between iterable locations),
959// multiple marks can exist in the same place.
960//
961// The returned list is not in any meaningful order.
962func (x *TextIter) GetMarks() *glib.SList {
963
964 cret := xTextIterGetMarks(x.GoPointer())
965 return cret
966}
967
968var xTextIterGetOffset func(uintptr) int
969
970// Returns the character offset of an iterator.
971//
972// Each character in a `GtkTextBuffer` has an offset,
973// starting with 0 for the first character in the buffer.
974// Use [method@Gtk.TextBuffer.get_iter_at_offset] to convert
975// an offset back into an iterator.
976func (x *TextIter) GetOffset() int {
977
978 cret := xTextIterGetOffset(x.GoPointer())
979 return cret
980}
981
982var xTextIterGetPaintable func(uintptr) uintptr
983
984// If the element at @iter is a paintable, the paintable is returned.
985//
986// Otherwise, %NULL is returned.
987func (x *TextIter) GetPaintable() *gdk.PaintableBase {
988 var cls *gdk.PaintableBase
989
990 cret := xTextIterGetPaintable(x.GoPointer())
991
992 if cret == 0 {
993 return nil
994 }
995 gobject.IncreaseRef(cret)
996 cls = &gdk.PaintableBase{}
997 cls.Ptr = cret
998 return cls
999}
1000
1001var xTextIterGetSlice func(uintptr, *TextIter) string
1002
1003// Returns the text in the given range.
1004//
1005// A “slice” is an array of characters encoded in UTF-8 format,
1006// including the Unicode “unknown” character 0xFFFC for iterable
1007// non-character elements in the buffer, such as images.
1008// Because images are encoded in the slice, byte and
1009// character offsets in the returned array will correspond to byte
1010// offsets in the text buffer. Note that 0xFFFC can occur in normal
1011// text as well, so it is not a reliable indicator that a paintable or
1012// widget is in the buffer.
1013func (x *TextIter) GetSlice(EndVar *TextIter) string {
1014
1015 cret := xTextIterGetSlice(x.GoPointer(), EndVar)
1016 return cret
1017}
1018
1019var xTextIterGetTags func(uintptr) *glib.SList
1020
1021// Returns a list of tags that apply to @iter, in ascending order of
1022// priority.
1023//
1024// The highest-priority tags are last.
1025//
1026// The `GtkTextTag`s in the list don’t have a reference added,
1027// but you have to free the list itself.
1028func (x *TextIter) GetTags() *glib.SList {
1029
1030 cret := xTextIterGetTags(x.GoPointer())
1031 return cret
1032}
1033
1034var xTextIterGetText func(uintptr, *TextIter) string
1035
1036// Returns text in the given range.
1037//
1038// If the range
1039// contains non-text elements such as images, the character and byte
1040// offsets in the returned string will not correspond to character and
1041// byte offsets in the buffer. If you want offsets to correspond, see
1042// [method@Gtk.TextIter.get_slice].
1043func (x *TextIter) GetText(EndVar *TextIter) string {
1044
1045 cret := xTextIterGetText(x.GoPointer(), EndVar)
1046 return cret
1047}
1048
1049var xTextIterGetToggledTags func(uintptr, bool) *glib.SList
1050
1051// Returns a list of `GtkTextTag` that are toggled on or off at this
1052// point.
1053//
1054// If @toggled_on is %TRUE, the list contains tags that are
1055// toggled on. If a tag is toggled on at @iter, then some non-empty
1056// range of characters following @iter has that tag applied to it. If
1057// a tag is toggled off, then some non-empty range following @iter
1058// does not have the tag applied to it.
1059func (x *TextIter) GetToggledTags(ToggledOnVar bool) *glib.SList {
1060
1061 cret := xTextIterGetToggledTags(x.GoPointer(), ToggledOnVar)
1062 return cret
1063}
1064
1065var xTextIterGetVisibleLineIndex func(uintptr) int
1066
1067// Returns the number of bytes from the start of the
1068// line to the given @iter, not counting bytes that
1069// are invisible due to tags with the “invisible” flag
1070// toggled on.
1071func (x *TextIter) GetVisibleLineIndex() int {
1072
1073 cret := xTextIterGetVisibleLineIndex(x.GoPointer())
1074 return cret
1075}
1076
1077var xTextIterGetVisibleLineOffset func(uintptr) int
1078
1079// Returns the offset in characters from the start of the
1080// line to the given @iter, not counting characters that
1081// are invisible due to tags with the “invisible” flag
1082// toggled on.
1083func (x *TextIter) GetVisibleLineOffset() int {
1084
1085 cret := xTextIterGetVisibleLineOffset(x.GoPointer())
1086 return cret
1087}
1088
1089var xTextIterGetVisibleSlice func(uintptr, *TextIter) string
1090
1091// Returns visible text in the given range.
1092//
1093// Like [method@Gtk.TextIter.get_slice], but invisible text
1094// is not included. Invisible text is usually invisible because
1095// a `GtkTextTag` with the “invisible” attribute turned on has
1096// been applied to it.
1097func (x *TextIter) GetVisibleSlice(EndVar *TextIter) string {
1098
1099 cret := xTextIterGetVisibleSlice(x.GoPointer(), EndVar)
1100 return cret
1101}
1102
1103var xTextIterGetVisibleText func(uintptr, *TextIter) string
1104
1105// Returns visible text in the given range.
1106//
1107// Like [method@Gtk.TextIter.get_text], but invisible text
1108// is not included. Invisible text is usually invisible because
1109// a `GtkTextTag` with the “invisible” attribute turned on has
1110// been applied to it.
1111func (x *TextIter) GetVisibleText(EndVar *TextIter) string {
1112
1113 cret := xTextIterGetVisibleText(x.GoPointer(), EndVar)
1114 return cret
1115}
1116
1117var xTextIterHasTag func(uintptr, uintptr) bool
1118
1119// Returns %TRUE if @iter points to a character that is part
1120// of a range tagged with @tag.
1121//
1122// See also [method@Gtk.TextIter.starts_tag] and
1123// [method@Gtk.TextIter.ends_tag].
1124func (x *TextIter) HasTag(TagVar *TextTag) bool {
1125
1126 cret := xTextIterHasTag(x.GoPointer(), TagVar.GoPointer())
1127 return cret
1128}
1129
1130var xTextIterInRange func(uintptr, *TextIter, *TextIter) bool
1131
1132// Checks whether @iter falls in the range [@start, @end).
1133//
1134// @start and @end must be in ascending order.
1135func (x *TextIter) InRange(StartVar *TextIter, EndVar *TextIter) bool {
1136
1137 cret := xTextIterInRange(x.GoPointer(), StartVar, EndVar)
1138 return cret
1139}
1140
1141var xTextIterInsideSentence func(uintptr) bool
1142
1143// Determines whether @iter is inside a sentence (as opposed to in
1144// between two sentences, e.g. after a period and before the first
1145// letter of the next sentence).
1146//
1147// Sentence boundaries are determined by Pango and should be correct
1148// for nearly any language.
1149func (x *TextIter) InsideSentence() bool {
1150
1151 cret := xTextIterInsideSentence(x.GoPointer())
1152 return cret
1153}
1154
1155var xTextIterInsideWord func(uintptr) bool
1156
1157// Determines whether the character pointed by @iter is part of a
1158// natural-language word (as opposed to say inside some whitespace).
1159//
1160// Word breaks are determined by Pango and should be correct
1161// for nearly any language.
1162//
1163// Note that if [method@Gtk.TextIter.starts_word] returns %TRUE,
1164// then this function returns %TRUE too, since @iter points to
1165// the first character of the word.
1166func (x *TextIter) InsideWord() bool {
1167
1168 cret := xTextIterInsideWord(x.GoPointer())
1169 return cret
1170}
1171
1172var xTextIterIsCursorPosition func(uintptr) bool
1173
1174// Determine if @iter is at a cursor position.
1175//
1176// See [method@Gtk.TextIter.forward_cursor_position] or
1177// [struct@Pango.LogAttr] or [func@Pango.break] for details
1178// on what a cursor position is.
1179func (x *TextIter) IsCursorPosition() bool {
1180
1181 cret := xTextIterIsCursorPosition(x.GoPointer())
1182 return cret
1183}
1184
1185var xTextIterIsEnd func(uintptr) bool
1186
1187// Returns %TRUE if @iter is the end iterator.
1188//
1189// This means it is one past the last dereferenceable iterator
1190// in the buffer. [method@Gtk.TextIter.is_end] is the most efficient
1191// way to check whether an iterator is the end iterator.
1192func (x *TextIter) IsEnd() bool {
1193
1194 cret := xTextIterIsEnd(x.GoPointer())
1195 return cret
1196}
1197
1198var xTextIterIsStart func(uintptr) bool
1199
1200// Returns %TRUE if @iter is the first iterator in the buffer.
1201func (x *TextIter) IsStart() bool {
1202
1203 cret := xTextIterIsStart(x.GoPointer())
1204 return cret
1205}
1206
1207var xTextIterOrder func(uintptr, *TextIter)
1208
1209// Swaps the value of @first and @second if @second comes before
1210// @first in the buffer.
1211//
1212// That is, ensures that @first and @second are in sequence.
1213// Most text buffer functions that take a range call this
1214// automatically on your behalf, so there’s no real reason to
1215// call it yourself in those cases. There are some exceptions,
1216// such as [method@Gtk.TextIter.in_range], that expect a
1217// pre-sorted range.
1218func (x *TextIter) Order(SecondVar *TextIter) {
1219
1220 xTextIterOrder(x.GoPointer(), SecondVar)
1221
1222}
1223
1224var xTextIterSetLine func(uintptr, int)
1225
1226// Moves iterator @iter to the start of the line @line_number.
1227//
1228// If @line_number is negative or larger than or equal to the number of lines
1229// in the buffer, moves @iter to the start of the last line in the buffer.
1230func (x *TextIter) SetLine(LineNumberVar int) {
1231
1232 xTextIterSetLine(x.GoPointer(), LineNumberVar)
1233
1234}
1235
1236var xTextIterSetLineIndex func(uintptr, int)
1237
1238// Same as [method@Gtk.TextIter.set_line_offset], but works with a
1239// byte index. The given byte index must be at
1240// the start of a character, it can’t be in the middle of a UTF-8
1241// encoded character.
1242func (x *TextIter) SetLineIndex(ByteOnLineVar int) {
1243
1244 xTextIterSetLineIndex(x.GoPointer(), ByteOnLineVar)
1245
1246}
1247
1248var xTextIterSetLineOffset func(uintptr, int)
1249
1250// Moves @iter within a line, to a new character (not byte) offset.
1251//
1252// The given character offset must be less than or equal to the number
1253// of characters in the line; if equal, @iter moves to the start of the
1254// next line. See [method@Gtk.TextIter.set_line_index] if you have a byte
1255// index rather than a character offset.
1256func (x *TextIter) SetLineOffset(CharOnLineVar int) {
1257
1258 xTextIterSetLineOffset(x.GoPointer(), CharOnLineVar)
1259
1260}
1261
1262var xTextIterSetOffset func(uintptr, int)
1263
1264// Sets @iter to point to @char_offset.
1265//
1266// @char_offset counts from the start
1267// of the entire text buffer, starting with 0.
1268func (x *TextIter) SetOffset(CharOffsetVar int) {
1269
1270 xTextIterSetOffset(x.GoPointer(), CharOffsetVar)
1271
1272}
1273
1274var xTextIterSetVisibleLineIndex func(uintptr, int)
1275
1276// Like [method@Gtk.TextIter.set_line_index], but the index is in visible
1277// bytes, i.e. text with a tag making it invisible is not counted
1278// in the index.
1279func (x *TextIter) SetVisibleLineIndex(ByteOnLineVar int) {
1280
1281 xTextIterSetVisibleLineIndex(x.GoPointer(), ByteOnLineVar)
1282
1283}
1284
1285var xTextIterSetVisibleLineOffset func(uintptr, int)
1286
1287// Like [method@Gtk.TextIter.set_line_offset], but the offset is in visible
1288// characters, i.e. text with a tag making it invisible is not
1289// counted in the offset.
1290func (x *TextIter) SetVisibleLineOffset(CharOnLineVar int) {
1291
1292 xTextIterSetVisibleLineOffset(x.GoPointer(), CharOnLineVar)
1293
1294}
1295
1296var xTextIterStartsLine func(uintptr) bool
1297
1298// Returns %TRUE if @iter begins a paragraph.
1299//
1300// This is the case if [method@Gtk.TextIter.get_line_offset]
1301// would return 0. However this function is potentially more
1302// efficient than [method@Gtk.TextIter.get_line_offset], because
1303// it doesn’t have to compute the offset, it just has to see
1304// whether it’s 0.
1305func (x *TextIter) StartsLine() bool {
1306
1307 cret := xTextIterStartsLine(x.GoPointer())
1308 return cret
1309}
1310
1311var xTextIterStartsSentence func(uintptr) bool
1312
1313// Determines whether @iter begins a sentence.
1314//
1315// Sentence boundaries are determined by Pango and
1316// should be correct for nearly any language.
1317func (x *TextIter) StartsSentence() bool {
1318
1319 cret := xTextIterStartsSentence(x.GoPointer())
1320 return cret
1321}
1322
1323var xTextIterStartsTag func(uintptr, uintptr) bool
1324
1325// Returns %TRUE if @tag is toggled on at exactly this point.
1326//
1327// If @tag is %NULL, returns %TRUE if any tag is toggled on at this point.
1328//
1329// Note that if this function returns %TRUE, it means that
1330// @iter is at the beginning of the tagged range, and that the
1331// character at @iter is inside the tagged range. In other
1332// words, unlike [method@Gtk.TextIter.ends_tag], if
1333// this function returns %TRUE, [method@Gtk.TextIter.has_tag]
1334// will also return %TRUE for the same parameters.
1335func (x *TextIter) StartsTag(TagVar *TextTag) bool {
1336
1337 cret := xTextIterStartsTag(x.GoPointer(), TagVar.GoPointer())
1338 return cret
1339}
1340
1341var xTextIterStartsWord func(uintptr) bool
1342
1343// Determines whether @iter begins a natural-language word.
1344//
1345// Word breaks are determined by Pango and should be correct
1346// for nearly any language.
1347func (x *TextIter) StartsWord() bool {
1348
1349 cret := xTextIterStartsWord(x.GoPointer())
1350 return cret
1351}
1352
1353var xTextIterTogglesTag func(uintptr, uintptr) bool
1354
1355// Gets whether a range with @tag applied to it begins
1356// or ends at @iter.
1357//
1358// This is equivalent to (gtk_text_iter_starts_tag() ||
1359// gtk_text_iter_ends_tag())
1360func (x *TextIter) TogglesTag(TagVar *TextTag) bool {
1361
1362 cret := xTextIterTogglesTag(x.GoPointer(), TagVar.GoPointer())
1363 return cret
1364}
1365
1366// Flags affecting how a search is done.
1367//
1368// If neither `GTK_TEXT_SEARCH_VISIBLE_ONLY` nor `GTK_TEXT_SEARCH_TEXT_ONLY`
1369// are enabled, the match must be exact; the special 0xFFFC character will
1370// match embedded paintables or child widgets.
1371type TextSearchFlags int
1372
1373var xTextSearchFlagsGLibType func() types.GType
1374
1375func TextSearchFlagsGLibType() types.GType {
1376 return xTextSearchFlagsGLibType()
1377}
1378
1379const (
1380
1381 // Search only visible data. A search match may
1382 // have invisible text interspersed.
1383 TextSearchVisibleOnlyValue TextSearchFlags = 1
1384 // Search only text. A match may have paintables or
1385 // child widgets mixed inside the matched range.
1386 TextSearchTextOnlyValue TextSearchFlags = 2
1387 // The text will be matched regardless of
1388 // what case it is in.
1389 TextSearchCaseInsensitiveValue TextSearchFlags = 4
1390)
1391
1392func init() {
1393 core.SetPackageName("GTK", "gtk4")
1394 core.SetSharedLibraries("GTK", []string{"libgtk-4.so.1"})
1395 var libs []uintptr
1396 for _, libPath := range core.GetPaths("GTK") {
1397 lib, err := purego.Dlopen(libPath, purego.RTLD_NOW|purego.RTLD_GLOBAL)
1398 if err != nil {
1399 panic(err)
1400 }
1401 libs = append(libs, lib)
1402 }
1403
1404 core.PuregoSafeRegister(&xTextSearchFlagsGLibType, libs, "gtk_text_search_flags_get_type")
1405
1406 core.PuregoSafeRegister(&xTextIterGLibType, libs, "gtk_text_iter_get_type")
1407
1408 core.PuregoSafeRegister(&xTextIterAssign, libs, "gtk_text_iter_assign")
1409 core.PuregoSafeRegister(&xTextIterBackwardChar, libs, "gtk_text_iter_backward_char")
1410 core.PuregoSafeRegister(&xTextIterBackwardChars, libs, "gtk_text_iter_backward_chars")
1411 core.PuregoSafeRegister(&xTextIterBackwardCursorPosition, libs, "gtk_text_iter_backward_cursor_position")
1412 core.PuregoSafeRegister(&xTextIterBackwardCursorPositions, libs, "gtk_text_iter_backward_cursor_positions")
1413 core.PuregoSafeRegister(&xTextIterBackwardFindChar, libs, "gtk_text_iter_backward_find_char")
1414 core.PuregoSafeRegister(&xTextIterBackwardLine, libs, "gtk_text_iter_backward_line")
1415 core.PuregoSafeRegister(&xTextIterBackwardLines, libs, "gtk_text_iter_backward_lines")
1416 core.PuregoSafeRegister(&xTextIterBackwardSearch, libs, "gtk_text_iter_backward_search")
1417 core.PuregoSafeRegister(&xTextIterBackwardSentenceStart, libs, "gtk_text_iter_backward_sentence_start")
1418 core.PuregoSafeRegister(&xTextIterBackwardSentenceStarts, libs, "gtk_text_iter_backward_sentence_starts")
1419 core.PuregoSafeRegister(&xTextIterBackwardToTagToggle, libs, "gtk_text_iter_backward_to_tag_toggle")
1420 core.PuregoSafeRegister(&xTextIterBackwardVisibleCursorPosition, libs, "gtk_text_iter_backward_visible_cursor_position")
1421 core.PuregoSafeRegister(&xTextIterBackwardVisibleCursorPositions, libs, "gtk_text_iter_backward_visible_cursor_positions")
1422 core.PuregoSafeRegister(&xTextIterBackwardVisibleLine, libs, "gtk_text_iter_backward_visible_line")
1423 core.PuregoSafeRegister(&xTextIterBackwardVisibleLines, libs, "gtk_text_iter_backward_visible_lines")
1424 core.PuregoSafeRegister(&xTextIterBackwardVisibleWordStart, libs, "gtk_text_iter_backward_visible_word_start")
1425 core.PuregoSafeRegister(&xTextIterBackwardVisibleWordStarts, libs, "gtk_text_iter_backward_visible_word_starts")
1426 core.PuregoSafeRegister(&xTextIterBackwardWordStart, libs, "gtk_text_iter_backward_word_start")
1427 core.PuregoSafeRegister(&xTextIterBackwardWordStarts, libs, "gtk_text_iter_backward_word_starts")
1428 core.PuregoSafeRegister(&xTextIterCanInsert, libs, "gtk_text_iter_can_insert")
1429 core.PuregoSafeRegister(&xTextIterCompare, libs, "gtk_text_iter_compare")
1430 core.PuregoSafeRegister(&xTextIterCopy, libs, "gtk_text_iter_copy")
1431 core.PuregoSafeRegister(&xTextIterEditable, libs, "gtk_text_iter_editable")
1432 core.PuregoSafeRegister(&xTextIterEndsLine, libs, "gtk_text_iter_ends_line")
1433 core.PuregoSafeRegister(&xTextIterEndsSentence, libs, "gtk_text_iter_ends_sentence")
1434 core.PuregoSafeRegister(&xTextIterEndsTag, libs, "gtk_text_iter_ends_tag")
1435 core.PuregoSafeRegister(&xTextIterEndsWord, libs, "gtk_text_iter_ends_word")
1436 core.PuregoSafeRegister(&xTextIterEqual, libs, "gtk_text_iter_equal")
1437 core.PuregoSafeRegister(&xTextIterForwardChar, libs, "gtk_text_iter_forward_char")
1438 core.PuregoSafeRegister(&xTextIterForwardChars, libs, "gtk_text_iter_forward_chars")
1439 core.PuregoSafeRegister(&xTextIterForwardCursorPosition, libs, "gtk_text_iter_forward_cursor_position")
1440 core.PuregoSafeRegister(&xTextIterForwardCursorPositions, libs, "gtk_text_iter_forward_cursor_positions")
1441 core.PuregoSafeRegister(&xTextIterForwardFindChar, libs, "gtk_text_iter_forward_find_char")
1442 core.PuregoSafeRegister(&xTextIterForwardLine, libs, "gtk_text_iter_forward_line")
1443 core.PuregoSafeRegister(&xTextIterForwardLines, libs, "gtk_text_iter_forward_lines")
1444 core.PuregoSafeRegister(&xTextIterForwardSearch, libs, "gtk_text_iter_forward_search")
1445 core.PuregoSafeRegister(&xTextIterForwardSentenceEnd, libs, "gtk_text_iter_forward_sentence_end")
1446 core.PuregoSafeRegister(&xTextIterForwardSentenceEnds, libs, "gtk_text_iter_forward_sentence_ends")
1447 core.PuregoSafeRegister(&xTextIterForwardToEnd, libs, "gtk_text_iter_forward_to_end")
1448 core.PuregoSafeRegister(&xTextIterForwardToLineEnd, libs, "gtk_text_iter_forward_to_line_end")
1449 core.PuregoSafeRegister(&xTextIterForwardToTagToggle, libs, "gtk_text_iter_forward_to_tag_toggle")
1450 core.PuregoSafeRegister(&xTextIterForwardVisibleCursorPosition, libs, "gtk_text_iter_forward_visible_cursor_position")
1451 core.PuregoSafeRegister(&xTextIterForwardVisibleCursorPositions, libs, "gtk_text_iter_forward_visible_cursor_positions")
1452 core.PuregoSafeRegister(&xTextIterForwardVisibleLine, libs, "gtk_text_iter_forward_visible_line")
1453 core.PuregoSafeRegister(&xTextIterForwardVisibleLines, libs, "gtk_text_iter_forward_visible_lines")
1454 core.PuregoSafeRegister(&xTextIterForwardVisibleWordEnd, libs, "gtk_text_iter_forward_visible_word_end")
1455 core.PuregoSafeRegister(&xTextIterForwardVisibleWordEnds, libs, "gtk_text_iter_forward_visible_word_ends")
1456 core.PuregoSafeRegister(&xTextIterForwardWordEnd, libs, "gtk_text_iter_forward_word_end")
1457 core.PuregoSafeRegister(&xTextIterForwardWordEnds, libs, "gtk_text_iter_forward_word_ends")
1458 core.PuregoSafeRegister(&xTextIterFree, libs, "gtk_text_iter_free")
1459 core.PuregoSafeRegister(&xTextIterGetBuffer, libs, "gtk_text_iter_get_buffer")
1460 core.PuregoSafeRegister(&xTextIterGetBytesInLine, libs, "gtk_text_iter_get_bytes_in_line")
1461 core.PuregoSafeRegister(&xTextIterGetChar, libs, "gtk_text_iter_get_char")
1462 core.PuregoSafeRegister(&xTextIterGetCharsInLine, libs, "gtk_text_iter_get_chars_in_line")
1463 core.PuregoSafeRegister(&xTextIterGetChildAnchor, libs, "gtk_text_iter_get_child_anchor")
1464 core.PuregoSafeRegister(&xTextIterGetLanguage, libs, "gtk_text_iter_get_language")
1465 core.PuregoSafeRegister(&xTextIterGetLine, libs, "gtk_text_iter_get_line")
1466 core.PuregoSafeRegister(&xTextIterGetLineIndex, libs, "gtk_text_iter_get_line_index")
1467 core.PuregoSafeRegister(&xTextIterGetLineOffset, libs, "gtk_text_iter_get_line_offset")
1468 core.PuregoSafeRegister(&xTextIterGetMarks, libs, "gtk_text_iter_get_marks")
1469 core.PuregoSafeRegister(&xTextIterGetOffset, libs, "gtk_text_iter_get_offset")
1470 core.PuregoSafeRegister(&xTextIterGetPaintable, libs, "gtk_text_iter_get_paintable")
1471 core.PuregoSafeRegister(&xTextIterGetSlice, libs, "gtk_text_iter_get_slice")
1472 core.PuregoSafeRegister(&xTextIterGetTags, libs, "gtk_text_iter_get_tags")
1473 core.PuregoSafeRegister(&xTextIterGetText, libs, "gtk_text_iter_get_text")
1474 core.PuregoSafeRegister(&xTextIterGetToggledTags, libs, "gtk_text_iter_get_toggled_tags")
1475 core.PuregoSafeRegister(&xTextIterGetVisibleLineIndex, libs, "gtk_text_iter_get_visible_line_index")
1476 core.PuregoSafeRegister(&xTextIterGetVisibleLineOffset, libs, "gtk_text_iter_get_visible_line_offset")
1477 core.PuregoSafeRegister(&xTextIterGetVisibleSlice, libs, "gtk_text_iter_get_visible_slice")
1478 core.PuregoSafeRegister(&xTextIterGetVisibleText, libs, "gtk_text_iter_get_visible_text")
1479 core.PuregoSafeRegister(&xTextIterHasTag, libs, "gtk_text_iter_has_tag")
1480 core.PuregoSafeRegister(&xTextIterInRange, libs, "gtk_text_iter_in_range")
1481 core.PuregoSafeRegister(&xTextIterInsideSentence, libs, "gtk_text_iter_inside_sentence")
1482 core.PuregoSafeRegister(&xTextIterInsideWord, libs, "gtk_text_iter_inside_word")
1483 core.PuregoSafeRegister(&xTextIterIsCursorPosition, libs, "gtk_text_iter_is_cursor_position")
1484 core.PuregoSafeRegister(&xTextIterIsEnd, libs, "gtk_text_iter_is_end")
1485 core.PuregoSafeRegister(&xTextIterIsStart, libs, "gtk_text_iter_is_start")
1486 core.PuregoSafeRegister(&xTextIterOrder, libs, "gtk_text_iter_order")
1487 core.PuregoSafeRegister(&xTextIterSetLine, libs, "gtk_text_iter_set_line")
1488 core.PuregoSafeRegister(&xTextIterSetLineIndex, libs, "gtk_text_iter_set_line_index")
1489 core.PuregoSafeRegister(&xTextIterSetLineOffset, libs, "gtk_text_iter_set_line_offset")
1490 core.PuregoSafeRegister(&xTextIterSetOffset, libs, "gtk_text_iter_set_offset")
1491 core.PuregoSafeRegister(&xTextIterSetVisibleLineIndex, libs, "gtk_text_iter_set_visible_line_index")
1492 core.PuregoSafeRegister(&xTextIterSetVisibleLineOffset, libs, "gtk_text_iter_set_visible_line_offset")
1493 core.PuregoSafeRegister(&xTextIterStartsLine, libs, "gtk_text_iter_starts_line")
1494 core.PuregoSafeRegister(&xTextIterStartsSentence, libs, "gtk_text_iter_starts_sentence")
1495 core.PuregoSafeRegister(&xTextIterStartsTag, libs, "gtk_text_iter_starts_tag")
1496 core.PuregoSafeRegister(&xTextIterStartsWord, libs, "gtk_text_iter_starts_word")
1497 core.PuregoSafeRegister(&xTextIterTogglesTag, libs, "gtk_text_iter_toggles_tag")
1498
1499}