Impressum gtktextiter.c
Sprache: C
/* GTK - The GIMP Toolkit * gtktextiter . c Copyright ( C ) 2000 Red Hat , Inc . * * This library is free software ; you can redistribute it and / or * modify it under the terms of the GNU Lesser General Public * License as published by the Free Software Foundation ; either * version 2 of the License , or ( at your option ) any later version . * * This library is distributed in the hope that it will be useful , * but WITHOUT ANY WARRANTY ; without even the implied warranty of * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE . See the GNU * Lesser General Public License for more details . * * You should have received a copy of the GNU Lesser General Public * License along with this library . If not , see < http : //www.gnu.org/licenses/>. /* * Modified by the GTK + Team and others 1997 - 2000 . See the AUTHORS * file for a list of people on the GTK + Team . See the ChangeLog * files for a list of changes . These files are distributed with * GTK + at ftp : //ftp.gtk.org/pub/gtk/. #include "config.h" #include "gtktextiter.h" #include "gtktextbtreeprivate.h" #include "gtktextbufferprivate.h" #include "gtktextiterprivate.h" #include "gtkdebug.h" #include <string.h>/** * GtkTextIter : * * Iterates over the contents of a ` GtkTextBuffer ` . * * You may wish to begin by reading the * [ text widget conceptual overview ] ( section - text - widget . html ) , * which gives an overview of all the objects and data types * related to the text widget and how they work together . #define FIX_OVERFLOWS(varname) if ((varname) == G_MININT) (varname) = G_MININT + 1 typedef struct _GtkTextRealIter GtkTextRealIter;struct G_GNUC_MAY_ALIAS _GtkTextRealIter/* Always-valid information */ /* At least one of these is always valid; if invalid , they are - 1 . If the line byte offset is valid , so is the segment byte offset ; int line_byte_offset;int line_char_offset;/* These two are valid if >= 0 */ int cached_char_index;int cached_line_number;/* Stamps to detect the buffer changing under us */ int chars_changed_stamp;int segments_changed_stamp;/* Valid if the segments_changed_stamp is up-to-date */ /* indexable segment we index */ /* first segment in our location, /* One of these will always be valid if segments_changed_stamp is up - to - date . If invalid , they are - 1 . If the line byte offset is valid , so is the segment byte offset ; int segment_byte_offset;int segment_char_offset;/* padding */ int pad1;/* These "set" functions should not assume any fields other than the char stamp and the tree are valid . static void /* Update segments stamp */ 1 ;1 ;1 ;1 ;1 ;1 ;static void int byte_offset)if (!_gtk_text_line_byte_locate (iter->line,"Byte index %d is off the end of the line" ,static void int char_offset)if (!_gtk_text_line_char_locate (iter->line,"Char offset %d is off the end of the line" ,static void int byte_offset;/* This could theoretically be optimized by computing all the iter 0 ;while (seg != segment)/* This function ensures that the segment-dependent information is truly computed lazily ; often we don ' t need to do the full make_real work . This ensures the btree and line are valid , but doesn ' t static GtkTextRealIter*const GtkTextIter *_iter)if (iter->chars_changed_stamp !="Invalid text buffer iterator: either the iterator " "is uninitialized, or the characters/paintables/widgets " "in the buffer have been modified since the iterator " "was created.\nYou must use marks, character numbers, " "or line numbers to preserve a position across buffer " "modifications.\nYou can apply tags and insert marks " "without invalidating your iterators,\n" "but any mutation that affects 'indexable' buffer contents " "(contents that can be referred to by character offset)\n" "will invalidate all outstanding iterators" );return NULL;/* We don't update the segments information since we are becoming only surreal . However we do invalidate the segments information if appropriate , to be sure we segfault if we try to use it and we if (iter->segments_changed_stamp !=/* set to segfault-causing values. */ 10000 ;10000 ;return iter;static GtkTextRealIter*const GtkTextIter *_iter)if (iter == NULL)return NULL;if (iter->segments_changed_stamp !=if (iter->line_byte_offset >= 0 )else 0 );0 );return iter;static GtkTextRealIter*0 , sizeof (GtkTextRealIter));return iter;static GtkTextRealIter*return real;static GtkTextRealIter*int line_byte_offset)if (real->segment->type == >k_text_char_type &&0 xc0) == 0 x80)"Incorrect line byte index %d falls in the middle of a UTF-8 " "character; this will crash the text buffer. " "Byte indexes must refer to the start of a character." ,return real;static GtkTextRealIter*int line_char_offset)return real;static inline void 1 ;static inline void int count)if (iter->cached_char_index >= 0 )static inline void int count)if (iter->cached_line_number >= 0 )static inline void if (iter->line_char_offset < 0 )0 );static inline void if (iter->line_byte_offset < 0 )0 );static inline gbooleanreturn real->segment_byte_offset == 0 || real->segment_char_offset == 0 ;static void const GtkTextIter *iter)if (GTK_DEBUG_CHECK (TEXT))/** * gtk_text_iter_get_buffer : * @ iter : an iterator * * Returns the ` GtkTextBuffer ` this iterator is associated with . * * Returns : ( transfer none ) : the buffer const GtkTextIter *iter)if (real == NULL)return NULL;return _gtk_text_btree_get_buffer (real->tree);/** * gtk_text_iter_copy : * @ iter : an iterator * * Creates a dynamically - allocated copy of an iterator . * * This function is not useful in applications , because * iterators can be copied with a simple assignment * ( ` GtkTextIter i = j ; ` ) . * * The function is used by language bindings . * * Returns : a copy of the @ iter , free with [ method @ Gtk . TextIter . free ] const GtkTextIter *iter)1 );return new_iter;/** * gtk_text_iter_free : * @ iter : a dynamically - allocated iterator * * Free an iterator allocated on the heap . * * This function is intended for use in language bindings , * and is not especially useful for applications , because * iterators can simply be allocated on the stack . void /** * gtk_text_iter_assign : * @ iter : a ` GtkTextIter ` * @ other : another ` GtkTextIter ` * * Assigns the value of @ other to @ iter . * * This function is not useful in applications , because * iterators can be assigned with ` GtkTextIter i = j ; ` . * * The function is used by language bindings . void const GtkTextIter *other)const GtkTextIter *iter)if (real == NULL)return NULL;return real->segment;const GtkTextIter *iter)if (real == NULL)return NULL;return real->any_segment;int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;return real->segment_byte_offset;int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;return real->segment_char_offset;/* This function does not require a still-valid const GtkTextIter *iter)const GtkTextRealIter *real;const GtkTextRealIter*)iter;return real->line;/* This function does not require a still-valid const GtkTextIter *iter)const GtkTextRealIter *real;const GtkTextRealIter*)iter;return real->tree;/* * Conversions /** * gtk_text_iter_get_offset : * @ iter : an iterator * * Returns the character offset of an iterator . * * Each character in a ` GtkTextBuffer ` has an offset , * starting with 0 for the first character in the buffer . * Use [ method @ Gtk . TextBuffer . get_iter_at_offset ] to convert * an offset back into an iterator . * * Returns : a character offset int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;if (real->cached_char_index < 0 )return real->cached_char_index;/** * gtk_text_iter_get_line : * @ iter : an iterator * * Returns the line number containing the iterator . * * Lines in a ` GtkTextBuffer ` are numbered beginning * with 0 for the first line in the buffer . * * Returns : a line number int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;if (real->cached_line_number < 0 )return real->cached_line_number;/** * gtk_text_iter_get_line_offset : * @ iter : an iterator * * Returns the character offset of the iterator , * counting from the start of a newline - terminated line . * * The first character on the line has offset 0 . * * Returns : offset from start of line int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;return real->line_char_offset;/** * gtk_text_iter_get_line_index : * @ iter : an iterator * * Returns the byte index of the iterator , counting * from the start of a newline - terminated line . * * Remember that ` GtkTextBuffer ` encodes text in * UTF - 8 , and that characters can require a variable * number of bytes to represent . * * Returns : distance from start of line , in bytes int const GtkTextIter *iter)0 );if (real == NULL)return 0 ;return real->line_byte_offset;/** * gtk_text_iter_get_visible_line_offset : * @ iter : a ` GtkTextIter ` * * Returns the offset in characters from the start of the * line to the given @ iter , not counting characters that * are invisible due to tags with the “ invisible ” flag * toggled on . * * Returns : offset in visible characters from the start of the line int const GtkTextIter *iter)int vis_offset;0 );if (real == NULL)return 0 ;0 );0 );while (seg != real->segment)/* This is a pretty expensive call, making the * whole function pretty lame ; we could keep track * of current invisibility state by looking at toggle * segments as we loop , and then call this function * only once per line , in order to speed up the loop * quite a lot . if (_gtk_text_btree_char_is_invisible (&pos))if (_gtk_text_btree_char_is_invisible (&pos))return vis_offset;/** * gtk_text_iter_get_visible_line_index : * @ iter : a ` GtkTextIter ` * * Returns the number of bytes from the start of the * line to the given @ iter , not counting bytes that * are invisible due to tags with the “ invisible ” flag * toggled on . * * Returns : byte index of @ iter with respect to the start of the line int const GtkTextIter *iter)int vis_offset;0 );if (real == NULL)return 0 ;0 );0 );while (seg != real->segment)/* This is a pretty expensive call, making the * whole function pretty lame ; we could keep track * of current invisibility state by looking at toggle * segments as we loop , and then call this function * only once per line , in order to speed up the loop * quite a lot . if (_gtk_text_btree_char_is_invisible (&pos))if (_gtk_text_btree_char_is_invisible (&pos))return vis_offset;/* * Dereferencing /** * gtk_text_iter_get_char : * @ iter : an iterator * * The Unicode character at this iterator is returned . * * Equivalent to operator * on a C + + iterator . If the element at * this iterator is a non - character element , such as an image * embedded in the buffer , the Unicode “ unknown ” character 0 xFFFC * is returned . If invoked on the end iterator , zero is returned ; * zero is not a valid Unicode character . * * So you can write a loop which ends when this function returns 0 . * * Returns : a Unicode character , or 0 if @ iter is not dereferenceable const GtkTextIter *iter)0 );if (real == NULL)return 0 ;if (gtk_text_iter_is_end (iter))return 0 ;else if (real->segment->type == >k_text_char_type)return g_utf8_get_char (real->segment->body.chars +else if (real->segment->type == >k_text_child_type)return g_utf8_get_char (gtk_text_child_anchor_get_replacement (real->segment->body.child.obj));else /* Unicode "unknown character" 0xFFFC */ return GTK_TEXT_UNKNOWN_CHAR;/** * gtk_text_iter_get_slice : * @ start : iterator at start of a range * @ end : iterator at end of a range * * Returns the text in the given range . * * A “ slice ” is an array of characters encoded in UTF - 8 format , * including the Unicode “ unknown ” character 0 xFFFC for iterable * non - character elements in the buffer , such as images . * Because images are encoded in the slice , byte and * character offsets in the returned array will correspond to byte * offsets in the text buffer . Note that 0 xFFFC can occur in normal * text as well , so it is not a reliable indicator that a paintable or * widget is in the buffer . * * Returns : ( transfer full ) : slice of text from the buffer char *const GtkTextIter *start,const GtkTextIter *end)return _gtk_text_btree_get_text (start, end, TRUE , TRUE );/** * gtk_text_iter_get_text : * @ start : iterator at start of a range * @ end : iterator at end of a range * * Returns text in the given range . * * If the range * contains non - text elements such as images , the character and byte * offsets in the returned string will not correspond to character and * byte offsets in the buffer . If you want offsets to correspond , see * [ method @ Gtk . TextIter . get_slice ] . * * Returns : ( transfer full ) : array of characters from the buffer char *const GtkTextIter *start,const GtkTextIter *end)return _gtk_text_btree_get_text (start, end, TRUE , FALSE );/** * gtk_text_iter_get_visible_slice : * @ start : iterator at start of range * @ end : iterator at end of range * * Returns visible text in the given range . * * Like [ method @ Gtk . TextIter . get_slice ] , but invisible text * is not included . Invisible text is usually invisible because * a ` GtkTextTag ` with the “ invisible ” attribute turned on has * been applied to it . * * Returns : ( transfer full ) : slice of text from the buffer char *const GtkTextIter *start,const GtkTextIter *end)return _gtk_text_btree_get_text (start, end, FALSE , TRUE );/** * gtk_text_iter_get_visible_text : * @ start : iterator at start of range * @ end : iterator at end of range * * Returns visible text in the given range . * * Like [ method @ Gtk . TextIter . get_text ] , but invisible text * is not included . Invisible text is usually invisible because * a ` GtkTextTag ` with the “ invisible ” attribute turned on has * been applied to it . * * Returns : ( transfer full ) : string containing visible text in the * range char *const GtkTextIter *start,const GtkTextIter *end)return _gtk_text_btree_get_text (start, end, FALSE , FALSE );/** * gtk_text_iter_get_paintable : * @ iter : an iterator * * If the element at @ iter is a paintable , the paintable is returned . * * Otherwise , % NULL is returned . * * Returns : ( transfer none ) ( nullable ) : the paintable at @ iter const GtkTextIter *iter)if (real == NULL)return NULL;if (real->segment->type != >k_text_paintable_type)return NULL;else return real->segment->body.paintable.paintable;/** * gtk_text_iter_get_child_anchor : * @ iter : an iterator * * If the location at @ iter contains a child anchor , the * anchor is returned . * * Otherwise , % NULL is returned . * * Returns : ( transfer none ) ( nullable ) : the anchor at @ iter const GtkTextIter *iter)if (real == NULL)return NULL;if (real->segment->type != >k_text_child_type)return NULL;else return real->segment->body.child.obj;/** * gtk_text_iter_get_marks : * @ iter : an iterator * * Returns a list of all ` GtkTextMark ` at this location . * * Because marks are not iterable ( they don ’ t take up any " space " * in the buffer , they are just marks in between iterable locations ) , * multiple marks can exist in the same place . * * The returned list is not in any meaningful order . * * Returns : ( element - type GtkTextMark ) ( transfer container ) : * list of ` GtkTextMark ` const GtkTextIter *iter)if (real == NULL)return NULL;while (seg != real->segment)if (seg->type == >k_text_left_mark_type ||/* The returned list isn't guaranteed to be in any special order, return retval;/** * gtk_text_iter_get_toggled_tags : * @ iter : an iterator * @ toggled_on : % TRUE to get toggled - on tags * * Returns a list of ` GtkTextTag ` that are toggled on or off at this * point . * * If @ toggled_on is % TRUE , the list contains tags that are * toggled on . If a tag is toggled on at @ iter , then some non - empty * range of characters following @ iter has that tag applied to it . If * a tag is toggled off , then some non - empty range following @ iter * does not have the tag applied to it . * * Returns : ( element - type GtkTextTag ) ( transfer container ) : tags * toggled at this point const GtkTextIter *iter,if (real == NULL)return NULL;while (seg != real->segment)if (toggled_on)if (seg->type == >k_text_toggle_on_type)else if (seg->type == >k_text_toggle_off_type)/* The returned list isn't guaranteed to be in any special order, return retval;/** * gtk_text_iter_starts_tag : * @ iter : an iterator * @ tag : ( nullable ) : a ` GtkTextTag ` * * Returns % TRUE if @ tag is toggled on at exactly this point . * * If @ tag is % NULL , returns % TRUE if any tag is toggled on at this point . * * Note that if this function returns % TRUE , it means that * @ iter is at the beginning of the tagged range , and that the * character at @ iter is inside the tagged range . In other * words , unlike [ method @ Gtk . TextIter . ends_tag ] , if * this function returns % TRUE , [ method @ Gtk . TextIter . has_tag ] * will also return % TRUE for the same parameters . * * Returns : whether @ iter is the start of a range tagged with @ tag const GtkTextIter *iter,FALSE );if (real == NULL)return FALSE ;while (seg != real->segment)if (seg->type == >k_text_toggle_on_type)if (tag == NULL ||return TRUE ;return FALSE ;/** * gtk_text_iter_ends_tag : * @ iter : an iterator * @ tag : ( nullable ) : a ` GtkTextTag ` * * Returns % TRUE if @ tag is toggled off at exactly this point . * * If @ tag is % NULL , returns % TRUE if any tag is toggled off at this point . * * Note that if this function returns % TRUE , it means that * @ iter is at the end of the tagged range , but that the character * at @ iter is outside the tagged range . In other words , * unlike [ method @ Gtk . TextIter . starts_tag ] , if this function * returns % TRUE , [ method @ Gtk . TextIter . has_tag ] will return * % FALSE for the same parameters . * * Returns : whether @ iter is the end of a range tagged with @ tag const GtkTextIter *iter,FALSE );if (real == NULL)return FALSE ;while (seg != real->segment)if (seg->type == >k_text_toggle_off_type)if (tag == NULL ||return TRUE ;return FALSE ;/** * gtk_text_iter_toggles_tag : * @ iter : an iterator * @ tag : ( nullable ) : a ` GtkTextTag ` * * Gets whether a range with @ tag applied to it begins * or ends at @ iter . * * This is equivalent to ( gtk_text_iter_starts_tag ( ) | | * gtk_text_iter_ends_tag ( ) ) * * Returns : whether @ tag is toggled on or off at @ iter const GtkTextIter *iter,FALSE );if (real == NULL)return FALSE ;while (seg != real->segment)if ( (seg->type == >k_text_toggle_off_type ||return TRUE ;return FALSE ;/** * gtk_text_iter_has_tag : * @ iter : an iterator * @ tag : a ` GtkTextTag ` * * Returns % TRUE if @ iter points to a character that is part * of a range tagged with @ tag . * * See also [ method @ Gtk . TextIter . starts_tag ] and * [ method @ Gtk . TextIter . ends_tag ] . * * Returns : whether @ iter is tagged with @ tag const GtkTextIter *iter,FALSE );FALSE );if (real == NULL)return FALSE ;if (real->line_byte_offset >= 0 )return _gtk_text_line_byte_has_tag (real->line, real->tree,else 0 );return _gtk_text_line_char_has_tag (real->line, real->tree,/** * gtk_text_iter_get_tags : * @ iter : a ` GtkTextIter ` * * Returns a list of tags that apply to @ iter , in ascending order of * priority . * * The highest - priority tags are last . * * The ` GtkTextTag ` s in the list don ’ t have a reference added , * but you have to free the list itself . * * Returns : ( element - type GtkTextTag ) ( transfer container ) : list of * ` GtkTextTag ` const GtkTextIter *iter)/* Get the tags at this spot */ /* No tags, use default style */ if (tags == NULL || tags->len == 0 )if (tags)return NULL;for (int i = tags->len - 1 ; i >= 0 ; i--)return retval;/** * gtk_text_iter_editable : * @ iter : an iterator * @ default_setting : % TRUE if text is editable by default * * Returns whether the character at @ iter is within an editable region * of text . * * Non - editable text is “ locked ” and can ’ t be changed by the * user via ` GtkTextView ` . If no tags applied to this text affect * editability , @ default_setting will be returned . * * You don ’ t want to use this function to decide whether text can be * inserted at @ iter , because for insertion you don ’ t want to know * whether the char at @ iter is inside an editable range , you want to * know whether a new character inserted at @ iter would be inside an * editable range . Use [ method @ Gtk . TextIter . can_insert ] to handle this * case . * * Returns : whether @ iter is inside an editable range const GtkTextIter *iter,FALSE );return retval;/** * gtk_text_iter_can_insert : * @ iter : an iterator * @ default_editability : % TRUE if text is editable by default * * Considering the default editability of the buffer , and tags that * affect editability , determines whether text inserted at @ iter would * be editable . * * If text inserted at @ iter would be editable then the * user should be allowed to insert text at @ iter . * [ method @ Gtk . TextBuffer . insert_interactive ] uses this function * to decide whether insertions are allowed at a given position . * * Returns : whether text inserted at @ iter would be editable const GtkTextIter *iter,FALSE );if (gtk_text_iter_editable (iter, default_editability))return TRUE ;/* If at start/end of buffer, default editability is used */ else if ((gtk_text_iter_is_start (iter) ||return TRUE ;else /* if iter isn't editable, and the char before iter is, * then iter is the first char in an editable region * and thus insertion at iter results in editable text . return gtk_text_iter_editable (&prev, default_editability);const GtkTextIter *iter,/* Get the tags at this spot */ /* No tags, use default style */ if (tags == NULL || tags->len == 0 )if (tags)return FALSE ;return TRUE ;/** * gtk_text_iter_get_language : * @ iter : an iterator * * Returns the language in effect at @ iter . * * If no tags affecting language apply to @ iter , the return * value is identical to that of [ func @ Gtk . get_default_language ] . * * Returns : ( transfer full ) : language in effect at @ iter const GtkTextIter *iter)return retval;/** * gtk_text_iter_starts_line : * @ iter : an iterator * * Returns % TRUE if @ iter begins a paragraph . * * This is the case if [ method @ Gtk . TextIter . get_line_offset ] * would return 0 . However this function is potentially more * efficient than [ method @ Gtk . TextIter . get_line_offset ] , because * it doesn ’ t have to compute the offset , it just has to see * whether it ’ s 0 . * * Returns : whether @ iter begins a line const GtkTextIter *iter)FALSE );if (real == NULL)return FALSE ;if (real->line_byte_offset >= 0 )return (real->line_byte_offset == 0 );else 0 );return (real->line_char_offset == 0 );/** * gtk_text_iter_ends_line : * @ iter : an iterator * * Returns % TRUE if @ iter points to the start of the paragraph * delimiter characters for a line . * * Delimiters will be either a newline , a carriage return , a carriage * return followed by a newline , or a Unicode paragraph separator * character . * * Note that an iterator pointing to the \ n of a \ r \ n pair will not be * counted as the end of a line , the line ends before the \ r . The end * iterator is considered to be at the end of a line , even though there * are no paragraph delimiter chars there . * * Returns : whether @ iter is at the end of a line const GtkTextIter *iter)FALSE );/* Only one character has type G_UNICODE_PARAGRAPH_SEPARATOR in * Unicode 3 . 0 ; update this if that changes . #define PARAGRAPH_SEPARATOR 0 x2029if (wc == '\r' || wc == PARAGRAPH_SEPARATOR || wc == 0 ) /* wc == 0 is end iterator */ return TRUE ;else if (wc == '\n' )/* need to determine if a \r precedes the \n, in which case * we aren ' t the end of the line . * Note however that if \ r and \ n are on different lines , they * both are terminators . This for instance may happen after * deleting some text : 1 some text \ r delete ' a ' 1 some text \ r 2 a \ n - - - - - - - - - > 2 \ n 3 . . . 3 . . . if (gtk_text_iter_get_line_offset (&tmp) == 0 )return TRUE ;if (!gtk_text_iter_backward_char (&tmp))return TRUE ;return gtk_text_iter_get_char (&tmp) != '\r' ;else return FALSE ;/** * gtk_text_iter_is_end : * @ iter : an iterator * * Returns % TRUE if @ iter is the end iterator . * * This means it is one past the last dereferenceable iterator * in the buffer . [ method @ Gtk . TextIter . is_end ] is the most efficient * way to check whether an iterator is the end iterator . * * Returns : whether @ iter is the end iterator const GtkTextIter *iter)FALSE );if (real == NULL)return FALSE ;if (!_gtk_text_line_contains_end_iter (real->line, real->tree))return FALSE ;/* Now we need the segments validated */ if (real == NULL)return FALSE ;return _gtk_text_btree_is_end (real->tree, real->line,/** * gtk_text_iter_is_start : * @ iter : an iterator * * Returns % TRUE if @ iter is the first iterator in the buffer . * * Returns : whether @ iter is the first in the buffer const GtkTextIter *iter)return gtk_text_iter_get_offset (iter) == 0 ;/** * gtk_text_iter_get_chars_in_line : * @ iter : an iterator * * Returns the number of characters in the line containing @ iter , * including the paragraph delimiters . * * Returns : number of characters in the line int const GtkTextIter *iter)int count;0 );if (real == NULL)return 0 ;if (real->line_char_offset >= 0 )/* We can start at the segments we've already found. */ else /* count whole line. */ 0 ;while (seg != NULL)if (_gtk_text_line_contains_end_iter (real->line, real->tree))1 ; /* Dump the newline that was in the last segment of the end iter line */ return count;/** * gtk_text_iter_get_bytes_in_line : * @ iter : an iterator * * Returns the number of bytes in the line containing @ iter , * including the paragraph delimiters . * * Returns : number of bytes in the line int const GtkTextIter *iter)int count;0 );if (real == NULL)return 0 ;if (real->line_byte_offset >= 0 )/* We can start at the segments we've already found. */ else /* count whole line. */ 0 ;while (seg != NULL)if (_gtk_text_line_contains_end_iter (real->line, real->tree))1 ; /* Dump the newline that was in the last segment of the end iter line */ return count;/* * Increments / decrements /* The return value of this indicates WHETHER WE MOVED. * The return value of public functions indicates * ( MOVEMENT OCCURRED & & NEW ITER IS DEREFERENCEABLE ) * * This function will not change the iterator if * it ’ s already on the last ( end iter ) line , i . e . it * won ’ t move to the end of the last line . static gbooleanif (!_gtk_text_line_contains_end_iter (real->line, real->tree))0 ;0 ;0 ;0 ;/* Find first segments in new line */ while (real->segment->char_count == 0 )return TRUE ;else /* There is no way to move forward a line; we were already at * the line containing the end iterator . * However we may not be at the end iterator itself . return FALSE ;#if 0 /* The return value of this indicates WHETHER WE MOVED. * The return value of public functions indicates * ( MOVEMENT OCCURRED & & NEW ITER IS DEREFERENCEABLE ) * * This function is currently unused , thus it is # if - 0 - ed . It is * left here , since it ’ s non - trivial code that might be useful in * the future . static gbooleanif (new_line != NULL)0 ;0 ;0 ;0 ;/* Find first segments in new line */ while (real->segment->char_count == 0 )return TRUE ;else /* There is no way to move backward; we were already /* We leave real->line as-is */ /* Note that we didn't clamp to the start of the first line. */ return FALSE ;#endif /* The return value indicates (MOVEMENT OCCURRED && NEW ITER IS * DEREFERENCEABLE ) static gbooleanif ( (real->segment_char_offset + 1 ) == real->segment->char_count)/* Need to move to the next segment; if no next segment, return _gtk_text_iter_forward_indexable_segment (iter);else /* Just moving within a segment. Keep byte count if (real->line_byte_offset >= 0 )int bytes;const char * start =1 ;1 ;1 );/* We moved into the middle of a segment, so the any_segment if (gtk_text_iter_is_end ((GtkTextIter*)real))return FALSE ;else return TRUE ;/* Need to move to the next segment; if no next segment, int chars_skipped;int bytes_skipped;FALSE );if (real == NULL)return FALSE ;if (real->line_char_offset >= 0 )0 );else 0 ;if (real->line_byte_offset >= 0 )0 );else 0 ;/* Get first segment of any kind */ /* skip non-indexable segments, if any */ while (seg != NULL && seg->char_count == 0 )if (seg != NULL)if (real->line_byte_offset >= 0 )0 );0 ;if (real->line_char_offset >= 0 )0 );0 ;return !gtk_text_iter_is_end (iter);else /* End of the line */ if (forward_line_leaving_caches_unmodified (real))1 );if (real->line_char_offset >= 0 )0 );0 );0 );0 );return !gtk_text_iter_is_end (iter);else /* End of buffer, but iter is still at start of last segment, * not at the end iterator . We put it on the end iterator . return FALSE ;static gboolean/* Return TRUE if there are no indexable segments after * this iterator . while (seg)if (seg->char_count > 0 )return FALSE ;return TRUE ;/* Goes back to the start of the next segment, even if * we ’ re not at the start of the current segment ( always * ends up on a different segment if it returns TRUE ) /* Move to the start of the previous segment; if no previous * segment , to the last segment in the previous line . This is * inherently a bit inefficient due to the singly - linked list and * tree nodes , but we can ' t afford the RAM for doubly - linked . int bytes_skipped;int chars_skipped;FALSE );if (real == NULL)return FALSE ;/* Find first segments in line */ while (seg->char_count == 0 )if (seg == real->segment)/* Could probably do this case faster by hand-coding the * iteration . /* We were already at the start of a line; * go back to the previous line . if (gtk_text_iter_backward_line (iter))/* Go forward to last indexable segment in line. */ while (!at_last_indexable_segment (real))return TRUE ;else return FALSE ; /* We were at the start of the first line. */ /* We must be in the middle of a line; so find the indexable * segment just before our current segment . do while (seg->char_count == 0 )while (seg != real->segment);0 );/* We skipped the entire previous segment, plus any * chars we were into the current segment . if (real->segment_byte_offset >= 0 )else 1 ;if (real->segment_char_offset >= 0 )else 1 ;0 ;0 ;if (bytes_skipped >= 0 )if (real->line_byte_offset >= 0 )0 );else 1 ;if (chars_skipped >= 0 )if (real->line_char_offset >= 0 )0 );if (real->cached_char_index >= 0 )0 );else 1 ;1 ;/* line number is unchanged. */ return TRUE ;/** * gtk_text_iter_forward_char : * @ iter : an iterator * * Moves @ iter forward by one character offset . * * Note that images embedded in the buffer occupy 1 character slot , so * this function may actually move onto an image instead of a character , * if you have images in your buffer . If @ iter is the end iterator or * one character before it , @ iter will now point at the end iterator , * and this function returns % FALSE for convenience when writing loops . * * Returns : whether @ iter moved and is dereferenceable FALSE );if (real == NULL)return FALSE ;else return forward_char (real);/** * gtk_text_iter_backward_char : * @ iter : an iterator * * Moves backward by one character offset . * * Returns % TRUE if movement was possible ; if @ iter was the first * in the buffer ( character offset 0 ) , this function returns % FALSE * for convenience when writing loops . * * Returns : whether movement was possible FALSE );return gtk_text_iter_backward_chars (iter, 1 );/* Definitely we should try to linear scan as often as possible for movement within a single line , because we can ' t use the BTree to speed within - line searches up ; for movement between lines , we would like to avoid the linear scan probably . Instead of using this constant , it might be nice to cache the line length in the iterator and linear scan if motion is within a single line . I guess you ' d have to profile the various approaches . #define MAX_LINEAR_SCAN 150 /** * gtk_text_iter_forward_chars : * @ iter : an iterator * @ count : number of characters to move , may be negative * * Moves @ count characters if possible . * * If @ count would move past the start or end of the buffer , * moves to the start or end of the buffer . * * The return value indicates whether the new position of * @ iter is different from its original position , and dereferenceable * ( the last iterator in the buffer is not dereferenceable ) . If @ count * is 0 , the function does nothing and returns % FALSE . * * Returns : whether @ iter moved and is dereferenceable int count)FALSE );if (real == NULL)return FALSE ;else if (count == 0 )return FALSE ;else if (count < 0 )return gtk_text_iter_backward_chars (iter, 0 - count);else if (count < MAX_LINEAR_SCAN)while (count > 1 )if (!forward_char (real))return FALSE ;return forward_char (real);else int current_char_index;int new_char_index;if (current_char_index == _gtk_text_btree_char_count (real->tree))return FALSE ; /* can't move forward */ /* Return FALSE if we're on the non-dereferenceable end * iterator . if (gtk_text_iter_is_end (iter))return FALSE ;else return TRUE ;/** * gtk_text_iter_backward_chars : * @ iter : an iterator * @ count : number of characters to move * * Moves @ count characters backward , if possible . * * If @ count would move past the start or end of the buffer , moves * to the start or end of the buffer . * * The return value indicates whether the iterator moved * onto a dereferenceable position ; if the iterator didn ’ t move , or * moved onto the end iterator , then % FALSE is returned . If @ count is 0 , * the function does nothing and returns % FALSE . * * Returns : whether @ iter moved and is dereferenceable int count)FALSE );if (real == NULL)return FALSE ;else if (count == 0 )return FALSE ;else if (count < 0 )return gtk_text_iter_forward_chars (iter, 0 - count);/* <, not <=, because if count == segment_char_offset * we ' re going to the front of the segment and the any_segment * might change if (count < real->segment_char_offset)/* Optimize the within-segment case */ 0 );if (real->line_byte_offset >= 0 )const char *p;int new_byte_offset;/* if in the last fourth of the segment walk backwards */ if (count < real->segment_char_offset / 4 )else 0 - count);return TRUE ;else /* We need to go back into previous segments. For now, * just keep this really simple . FIXME * use backward_indexable_segment . if (TRUE || count > MAX_LINEAR_SCAN)int current_char_index;int new_char_index;if (current_char_index == 0 )return FALSE ; /* can't move backward */ if (new_char_index < 0 )0 ;return TRUE ;else /* FIXME backward_indexable_segment here */ return FALSE ;#if 0 /* These two can't be implemented efficiently (always have to use * a linear scan , since that ’ s the only way to find all the non - text * segments ) /** * gtk_text_iter_forward_text_chars : * @ iter : a ` GtkTextIter ` * @ count : number of chars to move * * Moves forward by @ count text characters . * * Paintables , widgets , etc . do not count as characters for this . * * Equivalent to moving through the results of gtk_text_iter_get_text ( ) , * rather than gtk_text_iter_get_slice ( ) . * * Returns : whether @ iter moved and is dereferenceable int count)/** * gtk_text_iter_backward_text_chars : * @ iter : a ` GtkTextIter ` * @ count : number of chars to move * * Moves backward by @ count text characters ( paintables , widgets , * etc . do not count as characters for this ) . Equivalent to moving * through the results of gtk_text_iter_get_text ( ) , rather than * gtk_text_iter_get_slice ( ) . * * Returns : whether @ iter moved and is dereferenceable int count)#endif /** * gtk_text_iter_forward_line : * @ iter : an iterator * * Moves @ iter to the start of the next line . * * If the iter is already on the last line of the buffer , * moves the iter to the end of the current line . If after * the operation , the iter is at the end of the buffer and not * dereferenceable , returns % FALSE . Otherwise , returns % TRUE . * * Returns : whether @ iter can be dereferenced FALSE );if (real == NULL)return FALSE ;if (forward_line_leaving_caches_unmodified (real))1 );if (gtk_text_iter_is_end (iter))return FALSE ;else return TRUE ;else /* On the last line, move to end of it */ if (!gtk_text_iter_is_end (iter))return FALSE ;/** * gtk_text_iter_backward_line : * @ iter : an iterator * * Moves @ iter to the start of the previous line . * * Returns % TRUE if @ iter could be moved ; i . e . if @ iter was at * character offset 0 , this function returns % FALSE . Therefore , * if @ iter was already on line 0 , but not at the start of the line , * @ iter is snapped to the start of the line and the function returns * % TRUE . ( Note that this implies that * in a loop calling this function , the line number may not change on * every iteration , if your first iteration is on line 0 . ) * * Returns : whether @ iter moved int offset;FALSE );if (real == NULL)return FALSE ;FALSE ;if (real->line_char_offset > 0 )TRUE ;if (new_line != NULL)1 );else if (!offset_will_change)return FALSE ;0 ;0 ;0 ;0 ;/* Find first segment in line */ 0 , &offset);0 );/* Note that if we are on the first line, we snap to the start of * the first line and return TRUE , so TRUE means the iterator * changed , not that the line changed ; this is maybe a bit * weird . I ' m not sure there ' s an obvious right thing to do though . return TRUE ;/** * gtk_text_iter_forward_lines : * @ iter : a ` GtkTextIter ` * @ count : number of lines to move forward * * Moves @ count lines forward , if possible . * * If @ count would move past the start or end of the buffer , moves to * the start or end of the buffer . * * The return value indicates whether the iterator moved * onto a dereferenceable position ; if the iterator didn ’ t move , or * moved onto the end iterator , then % FALSE is returned . If @ count is 0 , * the function does nothing and returns % FALSE . If @ count is negative , * moves backward by 0 - @ count lines . * * Returns : whether @ iter moved and is dereferenceable int count)if (count < 0 )return gtk_text_iter_backward_lines (iter, 0 - count);else if (count == 0 )return FALSE ;else if (count == 1 )return gtk_text_iter_forward_line (iter);else int old_line;if (gtk_text_iter_is_end (iter))return FALSE ;if ((gtk_text_iter_get_line (iter) - old_line) < count)/* count went past the last line, so move to end of last line */ if (!gtk_text_iter_is_end (iter))return !gtk_text_iter_is_end (iter);/** * gtk_text_iter_backward_lines : * @ iter : a ` GtkTextIter ` * @ count : number of lines to move backward * * Moves @ count lines backward , if possible . * * If @ count would move past the start or end of the buffer , moves to * the start or end of the buffer . * * The return value indicates whether the iterator moved * onto a dereferenceable position ; if the iterator didn ’ t move , or * moved onto the end iterator , then % FALSE is returned . If @ count is 0 , * the function does nothing and returns % FALSE . If @ count is negative , * moves forward by 0 - @ count lines . * * Returns : whether @ iter moved and is dereferenceable int count)if (count < 0 )return gtk_text_iter_forward_lines (iter, 0 - count);else if (count == 0 )return FALSE ;else if (count == 1 )return gtk_text_iter_backward_line (iter);else int old_line;0 ));return (gtk_text_iter_get_line (iter) != old_line);/** * gtk_text_iter_forward_visible_line : * @ iter : an iterator * * Moves @ iter to the start of the next visible line . * * Returns % TRUE if there * was a next line to move to , and % FALSE if @ iter was simply moved to * the end of the buffer and is now not dereferenceable , or if @ iter was * already at the end of the buffer . * * Returns : whether @ iter can be dereferenced while (gtk_text_iter_forward_line (iter))if (!_gtk_text_btree_char_is_invisible (iter))return TRUE ;else do if (!gtk_text_iter_forward_char (iter))return FALSE ;if (!_gtk_text_btree_char_is_invisible (iter))return TRUE ;while (!gtk_text_iter_ends_line (iter));return FALSE ;/** * gtk_text_iter_backward_visible_line : * @ iter : an iterator * * Moves @ iter to the start of the previous visible line . * * Returns % TRUE if * @ iter could be moved ; i . e . if @ iter was at character offset 0 , this * function returns % FALSE . Therefore if @ iter was already on line 0 , * but not at the start of the line , @ iter is snapped to the start of * the line and the function returns % TRUE . ( Note that this implies that * in a loop calling this function , the line number may not change on * every iteration , if your first iteration is on line 0 . ) * * Returns : whether @ iter moved while (gtk_text_iter_backward_line (iter))if (!_gtk_text_btree_char_is_invisible (iter))return TRUE ;else do if (!gtk_text_iter_backward_char (iter))return FALSE ;if (!_gtk_text_btree_char_is_invisible (iter))return TRUE ;while (!gtk_text_iter_starts_line (iter));return FALSE ;/** * gtk_text_iter_forward_visible_lines : * @ iter : a ` GtkTextIter ` * @ count : number of lines to move forward * * Moves @ count visible lines forward , if possible . * * If @ count would move past the start or end of the buffer , moves to * the start or end of the buffer . * * The return value indicates whether the iterator moved * onto a dereferenceable position ; if the iterator didn ’ t move , or * moved onto the end iterator , then % FALSE is returned . If @ count is 0 , * the function does nothing and returns % FALSE . If @ count is negative , * moves backward by 0 - @ count lines . * * Returns : whether @ iter moved and is dereferenceable int count)if (count < 0 )return gtk_text_iter_backward_visible_lines (iter, 0 - count);else if (count == 0 )return FALSE ;else if (count == 1 )return gtk_text_iter_forward_visible_line (iter);else while (gtk_text_iter_forward_visible_line (iter) && count > 0 )return count == 0 ;/** * gtk_text_iter_backward_visible_lines : * @ iter : a ` GtkTextIter ` * @ count : number of lines to move backward * * Moves @ count visible lines backward , if possible . * * If @ count would move past the start or end of the buffer , moves to * the start or end of the buffer . * * The return value indicates whether the iterator moved * onto a dereferenceable position ; if the iterator didn ’ t move , or * moved onto the end iterator , then % FALSE is returned . If @ count is 0 , * the function does nothing and returns % FALSE . If @ count is negative , * moves forward by 0 - @ count lines . * * Returns : whether @ iter moved and is dereferenceable int count)if (count < 0 )return gtk_text_iter_forward_visible_lines (iter, 0 - count);else if (count == 0 )return FALSE ;else if (count == 1 )return gtk_text_iter_backward_visible_line (iter);else while (gtk_text_iter_backward_visible_line (iter) && count > 0 )return count == 0 ;typedef gboolean (* FindLogAttrFunc) (const PangoLogAttr *attrs,int offset,int len,int *found_offset,typedef gboolean (* TestLogAttrFunc) (const PangoLogAttr *attrs,int offset,int min_offset,int len);/* Word funcs */ static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)/* Find end of next word */ while (offset <= len)if (attrs[offset].is_word_end)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)return attrs[offset].is_word_end;static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)/* Find start of prev word */ while (offset >= 0 )if (attrs[offset].is_word_start)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)return attrs[offset].is_word_start;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)/* Find next word start or end */ while (offset >= min_offset &&if (offset >= 0 )return attrs[offset].is_word_start;else return FALSE ;/* Sentence funcs */ static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)/* Find end of next sentence */ while (offset <= len)if (attrs[offset].is_sentence_end)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)return attrs[offset].is_sentence_end;static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)/* Find start of prev sentence */ while (offset >= 0 )if (attrs[offset].is_sentence_start)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)return attrs[offset].is_sentence_start;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)/* Find next sentence start or end */ while (!(attrs[offset].is_sentence_start || attrs[offset].is_sentence_end))if (offset < min_offset)return FALSE ;return attrs[offset].is_sentence_start;static gbooleanconst GtkTextIter *iter,int char_len;const PangoLogAttr *attrs;int offset;FALSE );return (* func) (attrs, offset, 0 , char_len);static gbooleanconst GtkTextIter *iter,int *found_offset,int char_len;const PangoLogAttr *attrs;int offset;FALSE );return (* func) (attrs,static gbooleanFALSE ;FALSE );while (TRUE )int offset = 0 ;if (found)return moved && !gtk_text_iter_is_end (arg_iter);if (forward)if (!gtk_text_iter_forward_line (&iter))return FALSE ;TRUE ;else /* Go to end of previous line. First go to the current line offset 0, * because backward_line ( ) snaps to start of line 0 if iter is already * on line 0 . 0 );if (gtk_text_iter_backward_line (&iter))if (!gtk_text_iter_ends_line (&iter))TRUE ;else return FALSE ;static gbooleanFALSE );while (TRUE )if (gtk_text_iter_equal (&pos_before, &pos))break ;if (!_gtk_text_btree_char_is_invisible (&pos))return !gtk_text_iter_is_end (iter);return FALSE ;typedef gboolean (* OneStepFunc) (GtkTextIter *iter);typedef gboolean (* MultipleStepFunc) (GtkTextIter *iter, int count);static gbooleanint count,FALSE );if (count == 0 )return FALSE ;if (count < 0 )return n_steps_backward (iter, -count);if (!step_forward (iter))return FALSE ;while (count > 0 )if (!step_forward (iter))break ;return !gtk_text_iter_is_end (iter);/** * gtk_text_iter_forward_word_end : * @ iter : a ` GtkTextIter ` * * Moves forward to the next word end . * * If @ iter is currently on a word end , moves forward to the * next one after that . * * Word breaks are determined by Pango and should be correct * for nearly any language . * * Returns : % TRUE if @ iter moved and is not the end iterator return find_by_log_attrs (iter, find_word_end_func, TRUE );/** * gtk_text_iter_backward_word_start : * @ iter : a ` GtkTextIter ` * * Moves backward to the previous word start . * * If @ iter is currently on a word start , moves backward to the * next one after that . * * Word breaks are determined by Pango and should be correct * for nearly any language * * Returns : % TRUE if @ iter moved and is not the end iterator return find_by_log_attrs (iter, find_word_start_func, FALSE );/* FIXME a loop around a truly slow function means * a truly spectacularly slow function . /** * gtk_text_iter_forward_word_ends : * @ iter : a ` GtkTextIter ` * @ count : number of times to move * * Calls [ method @ Gtk . TextIter . forward_word_end ] up to @ count times . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_backward_word_starts : * @ iter : a ` GtkTextIter ` * @ count : number of times to move * * Calls [ method @ Gtk . TextIter . backward_word_start ] up to @ count times . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_forward_visible_word_end : * @ iter : a ` GtkTextIter ` * * Moves forward to the next visible word end . * * If @ iter is currently on a word end , moves forward to the * next one after that . * * Word breaks are determined by Pango and should be correct * for nearly any language * * Returns : % TRUE if @ iter moved and is not the end iterator return find_visible_by_log_attrs (iter, find_word_end_func, TRUE );/** * gtk_text_iter_backward_visible_word_start : * @ iter : a ` GtkTextIter ` * * Moves backward to the previous visible word start . * * If @ iter is currently on a word start , moves backward to the * next one after that . * * Word breaks are determined by Pango and should be correct * for nearly any language . * * Returns : % TRUE if @ iter moved and is not the end iterator return find_visible_by_log_attrs (iter, find_word_start_func, FALSE );/** * gtk_text_iter_forward_visible_word_ends : * @ iter : a ` GtkTextIter ` * @ count : number of times to move * * Calls [ method @ Gtk . TextIter . forward_visible_word_end ] up to @ count times . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_backward_visible_word_starts : * @ iter : a ` GtkTextIter ` * @ count : number of times to move * * Calls [ method @ Gtk . TextIter . backward_visible_word_start ] up to @ count times . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_starts_word : * @ iter : a ` GtkTextIter ` * * Determines whether @ iter begins a natural - language word . * * Word breaks are determined by Pango and should be correct * for nearly any language . * * Returns : % TRUE if @ iter is at the start of a word const GtkTextIter *iter)return test_log_attrs (iter, is_word_start_func);/** * gtk_text_iter_ends_word : * @ iter : a ` GtkTextIter ` * * Determines whether @ iter ends a natural - language word . * * Word breaks are determined by Pango and should be correct * for nearly any language . * * Returns : % TRUE if @ iter is at the end of a word const GtkTextIter *iter)return test_log_attrs (iter, is_word_end_func);/** * gtk_text_iter_inside_word : * @ iter : a ` GtkTextIter ` * * Determines whether the character pointed by @ iter is part of a * natural - language word ( as opposed to say inside some whitespace ) . * * Word breaks are determined by Pango and should be correct * for nearly any language . * * Note that if [ method @ Gtk . TextIter . starts_word ] returns % TRUE , * then this function returns % TRUE too , since @ iter points to * the first character of the word . * * Returns : % TRUE if @ iter is inside a word const GtkTextIter *iter)return test_log_attrs (iter, inside_word_func);/** * gtk_text_iter_starts_sentence : * @ iter : a ` GtkTextIter ` * * Determines whether @ iter begins a sentence . * * Sentence boundaries are determined by Pango and * should be correct for nearly any language . * * Returns : % TRUE if @ iter is at the start of a sentence . const GtkTextIter *iter)return test_log_attrs (iter, is_sentence_start_func);/** * gtk_text_iter_ends_sentence : * @ iter : a ` GtkTextIter ` * * Determines whether @ iter ends a sentence . * * Sentence boundaries are determined by Pango and should * be correct for nearly any language . * * Returns : % TRUE if @ iter is at the end of a sentence . const GtkTextIter *iter)return test_log_attrs (iter, is_sentence_end_func);/** * gtk_text_iter_inside_sentence : * @ iter : a ` GtkTextIter ` * * Determines whether @ iter is inside a sentence ( as opposed to in * between two sentences , e . g . after a period and before the first * letter of the next sentence ) . * * Sentence boundaries are determined by Pango and should be correct * for nearly any language . * * Returns : % TRUE if @ iter is inside a sentence . const GtkTextIter *iter)return test_log_attrs (iter, inside_sentence_func);/** * gtk_text_iter_forward_sentence_end : * @ iter : a ` GtkTextIter ` * * Moves forward to the next sentence end . * * If @ iter is at the end of a sentence , moves to the next * end of sentence . * * Sentence boundaries are determined by Pango and should * be correct for nearly any language . * * Returns : % TRUE if @ iter moved and is not the end iterator return find_by_log_attrs (iter, find_sentence_end_func, TRUE );/** * gtk_text_iter_backward_sentence_start : * @ iter : a ` GtkTextIter ` * * Moves backward to the previous sentence start . * * If @ iter is already at the start of a sentence , moves backward * to the next one . * * Sentence boundaries are determined by Pango and should * be correct for nearly any language . * * Returns : % TRUE if @ iter moved and is not the end iterator return find_by_log_attrs (iter, find_sentence_start_func, FALSE );/* FIXME a loop around a truly slow function means * a truly spectacularly slow function . /** * gtk_text_iter_forward_sentence_ends : * @ iter : a ` GtkTextIter ` * @ count : number of sentences to move * * Calls [ method @ Gtk . TextIter . forward_sentence_end ] @ count times . * * If @ count is negative , moves backward instead of forward . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_backward_sentence_starts : * @ iter : a ` GtkTextIter ` * @ count : number of sentences to move * * Calls [ method @ Gtk . TextIter . backward_sentence_start ] up to @ count times . * * If @ count is negative , moves forward instead of backward . * * Returns : % TRUE if @ iter moved and is not the end iterator int count)return move_multiple_steps (iter, count,static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)while (offset <= len)if (attrs[offset].is_cursor_position)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int len,int *found_offset,if (!already_moved_initially)while (offset >= 0 )if (attrs[offset].is_cursor_position)return TRUE ;return FALSE ;static gbooleanconst PangoLogAttr *attrs,int offset,int min_offset,int len)return attrs[offset].is_cursor_position;/** * gtk_text_iter_forward_cursor_position : * @ iter : a ` GtkTextIter ` * * Moves @ iter forward by a single cursor position . * * Cursor positions are ( unsurprisingly ) positions where the * cursor can appear . Perhaps surprisingly , there may not be * a cursor position between all characters . The most common * example for European languages would be a carriage return / newline * sequence . * * For some Unicode characters , the equivalent of say the letter “ a ” * with an accent mark will be represented as two characters , first * the letter then a " combining mark " that causes the accent to be * rendered ; so the cursor can ’ t go between those two characters . * * See also the [ struct @ Pango . LogAttr ] struct and the [ func @ Pango . break ] * function . * * Returns : % TRUE if we moved and the new position is dereferenceable return find_by_log_attrs (iter, find_forward_cursor_pos_func, TRUE );/** * gtk_text_iter_backward_cursor_position : * @ iter : a ` GtkTextIter ` * * Like [ method @ Gtk . TextIter . forward_cursor_position ] , but moves backward . * * Returns : % TRUE if we moved return find_by_log_attrs (iter, find_backward_cursor_pos_func, FALSE );/** * gtk_text_iter_forward_cursor_positions : * @ iter : a ` GtkTextIter ` * @ count : number of positions to move * * Moves up to @ count cursor positions . * * See [ method @ Gtk . TextIter . forward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_backward_cursor_positions : * @ iter : a ` GtkTextIter ` * @ count : number of positions to move * * Moves up to @ count cursor positions . * * See [ method @ Gtk . TextIter . forward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_forward_visible_cursor_position : * @ iter : a ` GtkTextIter ` * * Moves @ iter forward to the next visible cursor position . * * See [ method @ Gtk . TextIter . forward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable return find_visible_by_log_attrs (iter, find_forward_cursor_pos_func, TRUE );/** * gtk_text_iter_backward_visible_cursor_position : * @ iter : a ` GtkTextIter ` * * Moves @ iter backward to the previous visible cursor position . * * See [ method @ Gtk . TextIter . backward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable return find_visible_by_log_attrs (iter, find_backward_cursor_pos_func, FALSE );/** * gtk_text_iter_forward_visible_cursor_positions : * @ iter : a ` GtkTextIter ` * @ count : number of positions to move * * Moves up to @ count visible cursor positions . * * See [ method @ Gtk . TextIter . forward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_backward_visible_cursor_positions : * @ iter : a ` GtkTextIter ` * @ count : number of positions to move * * Moves up to @ count visible cursor positions . * * See [ method @ Gtk . TextIter . backward_cursor_position ] for details . * * Returns : % TRUE if we moved and the new position is dereferenceable int count)return move_multiple_steps (iter, count,/** * gtk_text_iter_is_cursor_position : * @ iter : a ` GtkTextIter ` * * Determine if @ iter is at a cursor position . * * See [ method @ Gtk . TextIter . forward_cursor_position ] or * [ struct @ Pango . LogAttr ] or [ func @ Pango . break ] for details * on what a cursor position is . * * Returns : % TRUE if the cursor can be placed at @ iter const GtkTextIter *iter)return test_log_attrs (iter, is_cursor_pos_func);/** * gtk_text_iter_set_line_offset : * @ iter : a ` GtkTextIter ` * @ char_on_line : a character offset relative to the start of @ iter ’ s current line * * Moves @ iter within a line , to a new character ( not byte ) offset . * * The given character offset must be less than or equal to the number * of characters in the line ; if equal , @ iter moves to the start of the * next line . See [ method @ Gtk . TextIter . set_line_index ] if you have a byte * index rather than a character offset . void int char_on_line)int chars_in_line;if (real == NULL)return ;if (char_on_line < chars_in_line)else /* set to start of next line */ /** * gtk_text_iter_set_line_index : * @ iter : a ` GtkTextIter ` * @ byte_on_line : a byte index relative to the start of @ iter ’ s current line * * Same as [ method @ Gtk . TextIter . set_line_offset ] , but works with a * byte index . The given byte index must be at * the start of a character , it can ’ t be in the middle of a UTF - 8 * encoded character . void int byte_on_line)int bytes_in_line;if (real == NULL)return ;if (byte_on_line < bytes_in_line)else if (real->segment->type == >k_text_char_type &&0 xc0) == 0 x80)"%s: Incorrect byte offset %d falls in the middle of a UTF-8 " "character; this will crash the text buffer. " "Byte indexes must refer to the start of a character." ,/** * gtk_text_iter_set_visible_line_offset : * @ iter : a ` GtkTextIter ` * @ char_on_line : a character offset * * Like [ method @ Gtk . TextIter . set_line_offset ] , but the offset is in visible * characters , i . e . text with a tag making it invisible is not * counted in the offset . void int char_on_line)int chars_seen = 0 ;0 );/* For now we use a ludicrously slow implementation */ while (chars_seen < char_on_line)if (!_gtk_text_btree_char_is_invisible (&pos))if (!gtk_text_iter_forward_char (&pos))break ;if (chars_seen == char_on_line)break ;if (_gtk_text_iter_get_text_line (&pos) == _gtk_text_iter_get_text_line (iter))else /** * gtk_text_iter_set_visible_line_index : * @ iter : a ` GtkTextIter ` * @ byte_on_line : a byte index * * Like [ method @ Gtk . TextIter . set_line_index ] , but the index is in visible * bytes , i . e . text with a tag making it invisible is not counted * in the index . void int byte_on_line)int offset = 0 ;0 );if (real == NULL)return ;while (seg != NULL && byte_on_line > 0 )if (!_gtk_text_btree_char_is_invisible (&pos))if (byte_on_line < seg->byte_count)0 ;break ;else if (byte_on_line == 0 )else /** * gtk_text_iter_set_line : * @ iter : a ` GtkTextIter ` * @ line_number : line number ( counted from 0 ) * * Moves iterator @ iter to the start of the line @ line_number . * * If @ line_number is negative or larger than or equal to the number of lines * in the buffer , moves @ iter to the start of the last line in the buffer . void int line_number)int real_line;if (real == NULL)return ;0 );/* We might as well cache this, since we know it. */ /** * gtk_text_iter_set_offset : * @ iter : a ` GtkTextIter ` * @ char_offset : a character number * * Sets @ iter to point to @ char_offset . * * @ char_offset counts from the start * of the entire text buffer , starting with 0 . void int char_offset)int line_start;int real_char_index;if (real == NULL)return ;if (real->cached_char_index >= 0 &&return ;/* Go ahead and cache this since we have it. */ /** * gtk_text_iter_forward_to_end : * @ iter : a ` GtkTextIter ` * * Moves @ iter forward to the “ end iterator ” , which points * one past the last valid character in the buffer . * * [ method @ Gtk . TextIter . get_char ] called on the end iterator * returns 0 , which is convenient for writing loops . void if (real == NULL)return ;/* FIXME this and gtk_text_iter_forward_to_line_end() could be cleaned up * and made faster . Look at iter_ends_line ( ) for inspiration , perhaps . * If all else fails we could cache the para delimiter pos in the iter . * I think forward_to_line_end ( ) actually gets called fairly often . static int if (_gtk_text_line_contains_end_iter (_gtk_text_iter_get_text_line (&end),else /* if we aren't on the last line, go forward to start of next line, then scan * back for the delimiters on the previous line while (!gtk_text_iter_ends_line (&end))return gtk_text_iter_get_line_offset (&end);/** * gtk_text_iter_forward_to_line_end : * @ iter : a ` GtkTextIter ` * * Moves the iterator to point to the paragraph delimiter characters . * * The possible characters are either a newline , a carriage return , * a carriage return / newline in sequence , or the Unicode paragraph * separator character . * * If the iterator is already at the paragraph delimiter * characters , moves to the paragraph delimiter characters for the * next line . If @ iter is on the last line in the buffer , which does * not end in paragraph delimiters , moves to the end iterator ( end of * the last line ) , and returns % FALSE . * * Returns : % TRUE if we moved and the new location is not the end iterator int current_offset;int new_offset;FALSE );if (current_offset < new_offset)/* Move to end of this line. */ return !gtk_text_iter_is_end (iter);else /* Move to end of next line. */ if (gtk_text_iter_forward_line (iter))/* We don't want to move past all * empty lines . if (!gtk_text_iter_ends_line (iter))return !gtk_text_iter_is_end (iter);else return FALSE ;/** * gtk_text_iter_forward_to_tag_toggle : * @ iter : a ` GtkTextIter ` * @ tag : ( nullable ) : a ` GtkTextTag ` * * Moves forward to the next toggle ( on or off ) of the * @ tag , or to the next toggle of any tag if * @ tag is % NULL . * * If no matching tag toggles are found , * returns % FALSE , otherwise % TRUE . Does not return toggles * located at @ iter , only toggles after @ iter . Sets @ iter to * the location of the toggle , or to the end of the buffer * if no toggle is found . * * Returns : whether we found a tag toggle after @ iter FALSE );if (real == NULL)return FALSE ;if (gtk_text_iter_is_end (iter))return FALSE ;while (_gtk_text_iter_forward_indexable_segment (iter))/* If we went forward to a line that couldn't contain a toggle for the tag , then skip forward to a line that could contain it . This potentially skips huge hunks of the tree , so we if (real->line != current_line)if (next_line == NULL)/* End of search. Set to end of buffer. */ return FALSE ;if (real->line != next_line)0 );if (gtk_text_iter_toggles_tag (iter, tag))/* If there's a toggle here, it isn't indexable so return TRUE ;/* Check end iterator for tags */ if (gtk_text_iter_toggles_tag (iter, tag))/* If there's a toggle here, it isn't indexable so return TRUE ;/* Reached end of buffer */ return FALSE ;/** * gtk_text_iter_backward_to_tag_toggle : * @ iter : a ` GtkTextIter ` * @ tag : ( nullable ) : a ` GtkTextTag ` * * Moves backward to the next toggle ( on or off ) of the * @ tag , or to the next toggle of any tag if * @ tag is % NULL . * * If no matching tag toggles are found , * returns % FALSE , otherwise % TRUE . Does not return toggles * located at @ iter , only toggles before @ iter . Sets @ iter * to the location of the toggle , or the start of the buffer * if no toggle is found . * * Returns : whether we found a tag toggle before @ iter FALSE );if (real == NULL)return FALSE ;/* If we're at segment start, go to the previous segment; * if mid - segment , snap to start of current segment . if (is_segment_start (real))if (!_gtk_text_iter_backward_indexable_segment (iter))return FALSE ;else if (!gtk_text_iter_backward_chars (iter, real->segment_char_offset))return FALSE ;do /* If we went backward to a line that couldn't contain a toggle * for the tag , then skip backward further to a line that * could contain it . This potentially skips huge hunks of the * tree , so we aren ' t a purely linear search . if (real->line != current_line)if (prev_line == NULL)/* End of search. Set to start of buffer. */ 0 );return FALSE ;if (real->line != prev_line)/* Set to last segment in prev_line (could do this * more quickly ) 0 );while (!at_last_indexable_segment (real))if (gtk_text_iter_toggles_tag (iter, tag))/* If there's a toggle here, it isn't indexable so * any_segment can ' t be the indexable segment . return TRUE ;while (_gtk_text_iter_backward_indexable_segment (iter));/* Reached front of buffer */ return FALSE ;static gbooleanint ch;return (*pred) (ch, user_data);/** * gtk_text_iter_forward_find_char : * @ iter : a ` GtkTextIter ` * @ pred : ( scope call ) ( closure user_data ) : a function to be called on each character * @ user_data : user data for @ pred * @ limit : ( nullable ) : search limit * * Advances @ iter , calling @ pred on each character . * * If @ pred returns % TRUE , returns % TRUE and stops scanning . * If @ pred never returns % TRUE , @ iter is set to @ limit if * @ limit is non - % NULL , otherwise to the end iterator . * * Returns : whether a match was found const GtkTextIter *limit)FALSE );FALSE );if (limit &&0 )return FALSE ;while ((limit == NULL ||if (matches_pred (iter, pred, user_data))return TRUE ;return FALSE ;/** * gtk_text_iter_backward_find_char : * @ iter : a ` GtkTextIter ` * @ pred : ( scope call ) ( closure user_data ) : function to be called on each character * @ user_data : user data for @ pred * @ limit : ( nullable ) : search limit * * Same as [ method @ Gtk . TextIter . forward_find_char ] , * but goes backward from @ iter . * * Returns : whether a match was found const GtkTextIter *limit)FALSE );FALSE );if (limit &&0 )return FALSE ;while ((limit == NULL ||if (matches_pred (iter, pred, user_data))return TRUE ;return FALSE ;static void int count,int i;0 );while (i > 0 )FALSE ;/* minimal workaround to avoid the infinite loop of bug #168247. */ if (gtk_text_iter_is_end (iter))return ;if (skip_nontext &&TRUE ;if (!ignored &&TRUE ;if (!ignored && skip_decomp)/* being UTF8 correct sucks: this accounts for extra offsets coming from canonical decompositions of UTF8 characters ( e . g . accented characters ) which char *normal;char *casefold;char buffer[6 ];int buffer_len;1 , G_NORMALIZE_NFD);1 ) - 1 );if (!ignored)static const char *const char *str,int offset)char *casefold, *normal;const char *p, *q;while (offset > 0 )1 , G_NORMALIZE_NFD);1 );return p;static gbooleanconst char *string,const char *prefix,if (strncmp (string, prefix, prefix_len) != 0 )return FALSE ;if (string[prefix_len] == '\0' )return TRUE ;/* If string contains prefix, check that prefix is not followed * by a unicode mark symbol , e . g . that trailing ' a ' in prefix return type != G_UNICODE_SPACING_MARK &&static const char *const char *haystack,const char *needle)const char *ret = NULL;char *p;char *casefold;char *caseless_haystack;int i;1 );1 , G_NORMALIZE_NFD);1 );1 );if (needle_len == 0 )char *)haystack;goto finally;if (haystack_len < needle_len)goto finally;char *)caseless_haystack;0 ;while (*p)if (exact_prefix_cmp (p, needle, needle_len))goto finally;return ret;static const char *const char *haystack,const char *needle)const char *ret = NULL;char *p;char *casefold;char *caseless_haystack;int i;1 );1 , G_NORMALIZE_NFD);1 );1 );if (needle_len == 0 )char *)haystack;goto finally;if (haystack_len < needle_len)goto finally;while (TRUE )if (exact_prefix_cmp (p, needle, needle_len))break ;if (p == caseless_haystack)break ;return ret;/* normalizes caseless strings and returns true if @s2 matches static gbooleanconst char *s1,const char *s2,char *casefold;char *normalized_s1;char *normalized_s2;int len_s1;int len_s2;FALSE ;FALSE );FALSE );0 , FALSE );0 , FALSE );1 , G_NORMALIZE_NFD);1 , G_NORMALIZE_NFD);if (len_s1 >= len_s2)0 );return ret;static gbooleanconst GtkTextIter *start,const char **lines,char *line_text;const char *found;int offset;if (*lines == NULL || **lines == '\0' )if (match_start)if (match_end)return TRUE ;/* No more text in buffer, but *lines is nonempty */ if (gtk_text_iter_equal (start, &next))return FALSE ;if (slice)if (visible_only)else else if (visible_only)else if (match_start) /* if this is the first line we're matching */ if (!case_insensitive)else else /* If it's not the first line, we have to match from the * start of the line . if ((!case_insensitive &&0 )) ||else if (found == NULL)return FALSE ;/* Get offset to start of search string */ /* If match start needs to be returned, set it to the * start of the search string . FALSE );if (match_start)/* Go to end of search string */ 1 ),if (match_end)/* pass NULL for match_start, since we don't need to find the * start again . return lines_match (&next, lines, visible_only, slice, case_insensitive, NULL, match_end);/* strsplit() that retains the delimiter as part of the string. */ static char **const char *string,const char *delimiter,int max_tokens,int *num_strings,char **str_array;const char *s;char *casefold, *new_string;1 ;if (max_tokens < 1 )if (s)do char , len + 1 );0 ;if (case_insensitive)1 );1 , G_NORMALIZE_NFD);while (--max_tokens && s);if (*string)if (case_insensitive)1 );1 , G_NORMALIZE_NFD);else char *, n);1 ;for (slist = string_list; slist; slist = slist->next)if (num_strings != NULL)1 ;return str_array;/** * gtk_text_iter_forward_search : * @ iter : start of search * @ str : a search string * @ flags : flags affecting how the search is done * @ match_start : ( out caller - allocates ) ( optional ) : return location for start of match * @ match_end : ( out caller - allocates ) ( optional ) : return location for end of match * @ limit : ( nullable ) : location of last possible @ match_end , or % NULL for the end of the buffer * * Searches forward for @ str . * * Any match is returned by setting @ match_start to the first character * of the match and @ match_end to the first character after the match . * The search will not continue past @ limit . Note that a search is a * linear or O ( n ) operation , so you may wish to use @ limit to avoid * locking up your UI on large buffers . * * @ match_start will never be set to a ` GtkTextIter ` located before @ iter , * even if there is a possible @ match_end after or at @ iter . * * Returns : whether a match was found const GtkTextIter *iter,const char *str,const GtkTextIter *limit)char **lines = NULL;FALSE ;FALSE );FALSE );if (limit &&0 )return FALSE ;if (*str == '\0' )/* If we can move one char, return the empty string there */ if (gtk_text_iter_forward_char (&match))if (limit &&return FALSE ;if (match_start)if (match_end)return TRUE ;else return FALSE ;0 ;0 ;0 ;/* locate all lines */ "\n" , -1 , NULL, case_insensitive);do /* This loop has an inefficient worst-case, where * gtk_text_iter_get_text ( ) is called repeatedly on * a single line . if (limit &&0 )break ;if (lines_match (&search, (const char **)lines,if (limit == NULL ||0 ))TRUE ;if (match_start)if (match_end)break ;while (gtk_text_iter_forward_line (&search));char **)lines);return retval;static gbooleanchar **vec1,char **vec2,/* Ignores trailing chars in vec2's last line */ char **i1, **i2;while (*i1 && *i2)int len1;int len2;if (!case_insensitive)if (strcmp (*i1, *i2) != 0 )if (*(i2 + 1 ) == NULL) /* if this is the last line */ if (len2 >= len1 &&0 )/* We matched ignoring the trailing stuff in vec2 */ return TRUE ;else return FALSE ;else return FALSE ;else if (!utf8_caselessnmatch (*i1, *i2, len1, len2))if (*(i2 + 1 ) == NULL) /* if this is the last line */ if (utf8_caselessnmatch (*i2, *i1, len2, len1))/* We matched ignoring the trailing stuff in vec2 */ return TRUE ;else return FALSE ;else return FALSE ;if (*i1 || *i2)return FALSE ;else return TRUE ;typedef struct _LinesWindow LinesWindow;struct _LinesWindowint n_lines;char **lines;1 ;1 ;static void const GtkTextIter *start)int i;/* If we start on line 1, there are 2 lines to search (0 and 1), so * n_lines can be 2 . if (gtk_text_iter_is_start (start) ||1 < win->n_lines)/* Already at the end, or not enough lines to match */ char *, 1 );return ;/* Move to start iter to start of line */ 0 );if (gtk_text_iter_equal (&line_start, &line_end))/* we were already at the start; so go back one line */ char *, win->n_lines + 1 );1 ;while (i >= 0 )char *line_text;if (win->slice)if (win->visible_only)else else if (win->visible_only)else static gbooleanchar *line_text;if (!gtk_text_iter_backward_line (&new_start))return FALSE ;else if (win->slice)if (win->visible_only)else else if (win->visible_only)else /* Move lines to make room for first line. */ 1 , win->lines, win->n_lines * sizeof (char *));/* Free old last line and NULL-terminate */ return TRUE ;static void /** * gtk_text_iter_backward_search : * @ iter : a ` GtkTextIter ` where the search begins * @ str : search string * @ flags : bitmask of flags affecting the search * @ match_start : ( out caller - allocates ) ( optional ) : return location for start of match * @ match_end : ( out caller - allocates ) ( optional ) : return location for end of match * @ limit : ( nullable ) : location of last possible @ match_start , or % NULL for start of buffer * * Same as [ method @ Gtk . TextIter . forward_search ] , but moves backward . * * @ match_end will never be set to a ` GtkTextIter ` located after @ iter , * even if there is a possible @ match_start before or at @ iter . * * Returns : whether a match was found const GtkTextIter *iter,const char *str,const GtkTextIter *limit)char **lines = NULL;char **l;int n_lines;FALSE ;FALSE );FALSE );if (limit &&0 )return FALSE ;if (*str == '\0' )/* If we can move one char, return the empty string there */ if (limit && gtk_text_iter_equal (limit, &match))return FALSE ;if (gtk_text_iter_backward_char (&match))if (match_start)if (match_end)return TRUE ;else return FALSE ;0 ;0 ;0 ;/* locate all lines */ "\n" , -1 , &n_lines, case_insensitive);if (*win.lines == NULL)goto out;do const char *first_line_match;if (limit &&0 )/* We're now before the search limit, abort. */ goto out;/* If there are multiple lines, the first line will * end in ' \ n ' , so this will only match at the * end of the first line , which is correct . if (!case_insensitive)else if (first_line_match &&1 , win.lines + 1 ,/* Match! */ int offset;/* Offset to start of search string */ FALSE );if (limit &&0 )goto out; /* match was bogus */ if (match_start)/* Go to end of search string */ 0 ;for (l = lines; *l != NULL; l++)1 );if (match_end)TRUE ;goto out;while (lines_window_back (&win));return retval;/* * Comparisons /** * gtk_text_iter_equal : * @ lhs : a ` GtkTextIter ` * @ rhs : another ` GtkTextIter ` * * Tests whether two iterators are equal , using the fastest possible * mechanism . * * This function is very fast ; you can expect it to perform * better than e . g . getting the character offset for each * iterator and comparing the offsets yourself . Also , it ’ s a * bit faster than [ method @ Gtk . TextIter . compare ] . * * Returns : % TRUE if the iterators point to the same place in the buffer const GtkTextIter *lhs,const GtkTextIter *rhs)if (real_lhs->line != real_rhs->line)return FALSE ;else if (real_lhs->line_byte_offset >= 0 &&0 )return real_lhs->line_byte_offset == real_rhs->line_byte_offset;else /* the ensure_char_offsets() calls do nothing if the char offsets return real_lhs->line_char_offset == real_rhs->line_char_offset;const GtkTextIter *lhs,const GtkTextIter *rhs)if (real_lhs == NULL || real_rhs == NULL)return FALSE ;return real_lhs->line == real_rhs->line;/** * gtk_text_iter_compare : * @ lhs : a ` GtkTextIter ` * @ rhs : another ` GtkTextIter ` * * A qsort ( ) - style function that returns negative if @ lhs is less than * @ rhs , positive if @ lhs is greater than @ rhs , and 0 if they ’ re equal . * * Ordering is in character offset order , i . e . the first character * in the buffer is less than the second character in the buffer . * * Returns : - 1 if @ lhs is less than @ rhs , 1 if @ lhs is greater , 0 if they are equal int const GtkTextIter *lhs,const GtkTextIter *rhs)if (real_lhs == NULL ||return -1 ; /* why not */ if (real_lhs->line == real_rhs->line)int left_index, right_index;if (real_lhs->line_byte_offset >= 0 &&0 )else /* the ensure_char_offsets() calls do nothing if if (left_index < right_index)return -1 ;else if (left_index > right_index)return 1 ;else return 0 ;else int line1, line2;if (line1 < line2)return -1 ;else if (line1 > line2)return 1 ;else return 0 ;/** * gtk_text_iter_in_range : * @ iter : a ` GtkTextIter ` * @ start : start of range * @ end : end of range * * Checks whether @ iter falls in the range [ @ start , @ end ) . * * @ start and @ end must be in ascending order . * * Returns : % TRUE if @ iter is in the range const GtkTextIter *iter,const GtkTextIter *start,const GtkTextIter *end)FALSE );FALSE );FALSE );0 , FALSE );return gtk_text_iter_compare (iter, start) >= 0 &&0 ;/** * gtk_text_iter_order : * @ first : a ` GtkTextIter ` * @ second : another ` GtkTextIter ` * * Swaps the value of @ first and @ second if @ second comes before * @ first in the buffer . * * That is , ensures that @ first and @ second are in sequence . * Most text buffer functions that take a range call this * automatically on your behalf , so there ’ s no real reason to * call it yourself in those cases . There are some exceptions , * such as [ method @ Gtk . TextIter . in_range ] , that expect a * pre - sorted range . void if (gtk_text_iter_compare (first, second) > 0 )/* * Init iterators from the BTree void int char_index)int real_char_index;int line_start;void int line_number,int char_on_line)int real_line;/* We might as well cache this, since we know it. */ void int line_number,int byte_index)int real_line;/* We might as well cache this, since we know it. */ void int byte_offset)void int char_offset)FALSE );FALSE );if (line == NULL)/* Set iter to last in tree */ return FALSE ;else 0 );if (!gtk_text_iter_toggles_tag (iter, tag))return TRUE ;FALSE );FALSE );if (gtk_text_iter_toggles_tag (iter, tag))TRUE ;else return found;const char *mark_name)FALSE );FALSE );if (mark == NULL)return FALSE ;else return TRUE ;void void void void void const GtkTextIter *iter)const GtkTextRealIter *real = (const GtkTextRealIter*)iter;int line_char_offset, line_byte_offset, seg_char_offset, seg_byte_offset;/* This function checks our class invariants for the Iter class. */ sizeof (GtkTextIter) == sizeof (GtkTextRealIter));if (real->chars_changed_stamp !="iterator check failed: invalid iterator" );if (real->line_char_offset < 0 && real->line_byte_offset < 0 )"iterator check failed: both char and byte offsets are invalid" );#if 0 "checking iter, segments %s updated, byte %d char %d\n" ,"are" : "aren't" ,#endif if (segments_updated)if (real->segment_char_offset < 0 && real->segment_byte_offset < 0 )"iterator check failed: both char and byte segment offsets are invalid" );if (real->segment->char_count == 0 )"iterator check failed: segment is not indexable." );if (real->line_char_offset >= 0 && real->segment_char_offset < 0 )"segment char offset is not properly up-to-date" );if (real->line_byte_offset >= 0 && real->segment_byte_offset < 0 )"segment byte offset is not properly up-to-date" );if (real->segment_byte_offset >= 0 &&"segment byte offset is too large." );if (real->segment_char_offset >= 0 &&"segment char offset is too large." );if (real->line_byte_offset >= 0 )if (line_byte_offset != real->line_byte_offset)"wrong byte offset was stored in iterator" );if (segments_updated)if (real->segment != byte_segment)"wrong segment was stored in iterator" );if (real->any_segment != byte_any_segment)"wrong any_segment was stored in iterator" );if (seg_byte_offset != real->segment_byte_offset)"wrong segment byte offset was stored in iterator" );if (byte_segment->type == >k_text_char_type)const char *p;if (!gtk_text_byte_begins_utf8_char (p))"broken iterator byte index pointed into the middle of a character" );#ifdef _MSC_VERelse 0 ;#endif if (real->line_char_offset >= 0 )if (line_char_offset != real->line_char_offset)"wrong char offset was stored in iterator" );if (segments_updated)if (real->segment != char_segment)"wrong segment was stored in iterator" );if (real->any_segment != char_any_segment)"wrong any_segment was stored in iterator" );if (seg_char_offset != real->segment_char_offset)"wrong segment char offset was stored in iterator" );if (char_segment->type == >k_text_char_type)const char *p;/* hmm, not likely to happen eh */ if (!gtk_text_byte_begins_utf8_char (p))"broken iterator char offset pointed into the middle of a character" );#ifdef _MSC_VERelse 0 ;#endif if (real->line_char_offset >= 0 && real->line_byte_offset >= 0 )if (byte_segment != char_segment)"char and byte offsets did not point to the same segment" );if (byte_any_segment != char_any_segment)"char and byte offsets did not point to the same any segment" );/* Make sure the segment offsets are equivalent, if it's a char if (char_segment->type == >k_text_char_type)int byte_offset = 0 ;int char_offset = 0 ;while (char_offset < seg_char_offset)const char * start = char_segment->body.chars + byte_offset;1 ;if (byte_offset != seg_byte_offset)"byte offset did not correspond to char offset" );if (char_offset != seg_char_offset)"char offset did not correspond to byte offset" );if (!gtk_text_byte_begins_utf8_char (char_segment->body.chars + seg_byte_offset))"byte index for iterator does not index the start of a character" );if (real->cached_line_number >= 0 )int should_be;if (real->cached_line_number != should_be)"wrong line number was cached" );if (real->cached_char_index >= 0 )if (real->line_char_offset >= 0 ) /* only way we can check it efficiently , not a real int char_index;if (real->cached_char_index != char_index)"wrong char index was cached" );if (_gtk_text_line_is_last (real->line, real->tree))"Iterator was on last line (past the end iterator)" );
Messung V0.5 in Prozent C=98 H=95 G=96
¤ Die Informationen auf dieser Webseite wurden
nach bestem Wissen sorgfältig zusammengestellt. Es wird jedoch weder Vollständigkeit, noch Richtigkeit,
noch Qualität der bereit gestellten Informationen zugesichert.0.224Bemerkung:
(vorverarbeitet am 2026-07-03)
¤ *Bot Zugriff
2026-07-09
