// -*- c++ -*- // Generated by gtkmmproc -- DO NOT MODIFY! #ifndef _GTKMM_TEXTITER_H #define _GTKMM_TEXTITER_H #include /* $Id$ */ /* Copyright(C) 1998-2002 The gtkmm Development Team * * This library is free software, ) you can redistribute it and/or * modify it under the terms of the GNU Library 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 * Library General Public License for more details. * * You should have received a copy of the GNU Library General Public * License along with this library, ) if not, write to the Free * Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA. */ #include #include #include #include #include #include #include /* we need the definition of GtkTextIter */ namespace Gtk { /** @addtogroup gtkmmEnums Enums and Flags */ /** * @ingroup gtkmmEnums * @par Bitwise operators: * %TextSearchFlags operator|(TextSearchFlags, TextSearchFlags)
* %TextSearchFlags operator&(TextSearchFlags, TextSearchFlags)
* %TextSearchFlags operator^(TextSearchFlags, TextSearchFlags)
* %TextSearchFlags operator~(TextSearchFlags)
* %TextSearchFlags& operator|=(TextSearchFlags&, TextSearchFlags)
* %TextSearchFlags& operator&=(TextSearchFlags&, TextSearchFlags)
* %TextSearchFlags& operator^=(TextSearchFlags&, TextSearchFlags)
*/ enum TextSearchFlags { TEXT_SEARCH_VISIBLE_ONLY = 1 << 0, TEXT_SEARCH_TEXT_ONLY = 1 << 1 }; /** @ingroup gtkmmEnums */ inline TextSearchFlags operator|(TextSearchFlags lhs, TextSearchFlags rhs) { return static_cast(static_cast(lhs) | static_cast(rhs)); } /** @ingroup gtkmmEnums */ inline TextSearchFlags operator&(TextSearchFlags lhs, TextSearchFlags rhs) { return static_cast(static_cast(lhs) & static_cast(rhs)); } /** @ingroup gtkmmEnums */ inline TextSearchFlags operator^(TextSearchFlags lhs, TextSearchFlags rhs) { return static_cast(static_cast(lhs) ^ static_cast(rhs)); } /** @ingroup gtkmmEnums */ inline TextSearchFlags operator~(TextSearchFlags flags) { return static_cast(~static_cast(flags)); } /** @ingroup gtkmmEnums */ inline TextSearchFlags& operator|=(TextSearchFlags& lhs, TextSearchFlags rhs) { return (lhs = static_cast(static_cast(lhs) | static_cast(rhs))); } /** @ingroup gtkmmEnums */ inline TextSearchFlags& operator&=(TextSearchFlags& lhs, TextSearchFlags rhs) { return (lhs = static_cast(static_cast(lhs) & static_cast(rhs))); } /** @ingroup gtkmmEnums */ inline TextSearchFlags& operator^=(TextSearchFlags& lhs, TextSearchFlags rhs) { return (lhs = static_cast(static_cast(lhs) ^ static_cast(rhs))); } } // namespace Gtk #ifndef DOXYGEN_SHOULD_SKIP_THIS namespace Glib { template <> class Value : public Glib::Value_Flags { public: static GType value_type() G_GNUC_CONST; }; } // namespace Glib #endif /* DOXYGEN_SHOULD_SKIP_THIS */ namespace Gtk { class TextBuffer; class TextMark; /** Typefed as Gtk::TextBuffer::iterator. * An iterator represents a position between two characters in the text buffer. Iterators are not valid indefinitely; whenever the buffer is * modified in a way that affects the number of characters in the buffer, all outstanding iterators become invalid. (Note that * deleting 5 characters and then reinserting 5 still invalidates iterators, though you end up with the same number of characters * you pass through a state with a different number). * * Because of this, iterators can't be used to preserve positions across buffer modifications. To preserve a position, the * @link Gtk::TextMark Gtk::TextBuffer::Mark@endlink object is ideal. * * You can iterate over characters, words, lines, and sentences, * but operator*() and operator++() deal only in characters. * * TODO: Maybe we should have separate iterators for words, lines, and sentences. * @ingroup TextView */ class TextIter { public: #ifndef DOXYGEN_SHOULD_SKIP_THIS typedef TextIter CppObjectType; typedef GtkTextIter BaseObjectType; static GType get_type() G_GNUC_CONST; #endif /* DOXYGEN_SHOULD_SKIP_THIS */ TextIter(); explicit TextIter(const GtkTextIter* gobject); // always takes a copy ///Provides access to the underlying C instance. GtkTextIter* gobj() { return &gobject_; } ///Provides access to the underlying C instance. const GtkTextIter* gobj() const { return &gobject_; } protected: GtkTextIter gobject_; private: public: typedef std::bidirectional_iterator_tag iterator_category; typedef gunichar value_type; typedef int difference_type; typedef value_type reference; typedef void pointer; /** Alias for forward_char(). */ inline TextIter& operator++(); inline const TextIter operator++(int); /** Alias for backward_char(). */ inline TextIter& operator--(); inline const TextIter operator--(int); /** Alias for get_char(). */ inline value_type operator*() const; /** Alias for !is_end(). */ inline operator bool() const; #ifndef DOXYGEN_SHOULD_SKIP_THIS protected: template struct PredicateAdapter { Predicate predicate_; inline PredicateAdapter(const Predicate& predicate); static gboolean gtk_callback(gunichar uc, void* user_data); }; /** Advances @a iter , calling @a pred on each character. If * @a pred returns true, returns true and stops scanning. * If @a pred never returns true, @a iter is set to @a limit if * @a limit is non-0, otherwise to the end iterator. * @param pred A function to be called on each character. * @param user_data User data for @a pred . * @param limit Search limit, or 0 for none. * @return Whether a match was found. */ bool forward_find_char_impl(GtkTextCharPredicate predicate, void* user_data, const GtkTextIter* limit); /** Same as gtk_text_iter_forward_find_char(), but goes backward from @a iter . * @param pred Function to be called on each character. * @param user_data User data for @a pred . * @param limit Search limit, or 0 for none. * @return Whether a match was found. */ bool backward_find_char_impl(GtkTextCharPredicate predicate, void* user_data, const GtkTextIter* limit); #endif /* DOXYGEN_SHOULD_SKIP_THIS */ public: /** Returns the Gtk::TextBuffer this iterator is associated with. * @return The buffer. */ Glib::RefPtr get_buffer() const; /** Returns the character offset of an iterator. * Each character in a Gtk::TextBuffer has an offset, * starting with 0 for the first character in the buffer. * Use Gtk::TextBuffer::get_iter_at_offset() to convert an * offset back into an iterator. * @return A character offset. */ int get_offset() const; /** Returns the line number containing the iterator. Lines in * a Gtk::TextBuffer are numbered beginning with 0 for the first * line in the buffer. * @return A line number. */ int get_line() const; /** 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. * @return Offset from start of line. */ int get_line_offset() const; /** Returns the byte index of the iterator, counting * from the start of a newline-terminated line. * Remember that Gtk::TextBuffer encodes text in * UTF-8, and that characters can require a variable * number of bytes to represent. * @return Distance from start of line, in bytes. */ int get_line_index() const; /** Returns the offset in characters from the start of the * line to the given @a iter , not counting characters that * are invisible due to tags with the "invisible" flag * toggled on. * @return Offset in visible characters from the start of the line. */ int get_visible_line_offset() const; /** Returns the number of bytes from the start of the * line to the given @a iter , not counting bytes that * are invisible due to tags with the "invisible" flag * toggled on. * @return Byte index of @a iter with respect to the start of the line. */ int get_visible_line_index() const; /** Returns the Unicode character at this iterator. (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 0xFFFC 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 gtk_text_iter_get_char() * returns 0. * @return A Unicode character, or 0 if @a iter is not dereferenceable. */ gunichar get_char() const; /** Returns the text in the given range. A "slice" is an array of * characters encoded in UTF-8 format, including the Unicode "unknown" * character 0xFFFC 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 0xFFFC can occur in normal * text as well, so it is not a reliable indicator that a pixbuf or * widget is in the buffer. * @param end Iterator at end of a range. * @return Slice of text from the buffer. */ Glib::ustring get_slice(const TextIter& end) const; /** 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 * gtk_text_iter_get_slice(). * @param end Iterator at end of a range. * @return Array of characters from the buffer. */ Glib::ustring get_text(const TextIter& end) const; /** Like gtk_text_iter_get_slice(), but invisible text is not included. * Invisible text is usually invisible because a Gtk::TextTag with the * "invisible" attribute turned on has been applied to it. * @param end Iterator at end of range. * @return Slice of text from the buffer. */ Glib::ustring get_visible_slice(const TextIter& end) const; /** Like gtk_text_iter_get_text(), but invisible text is not included. * Invisible text is usually invisible because a Gtk::TextTag with the * "invisible" attribute turned on has been applied to it. * @param end Iterator at end of range. * @return String containing visible text in the range. */ Glib::ustring get_visible_text(const TextIter& end) const; /** If the element at @a iter is a pixbuf, the pixbuf is returned * (with no new reference count added). Otherwise, * 0 is returned. * @return The pixbuf at @a iter . */ Glib::RefPtr get_pixbuf() const; /** Returns a list of all Gtk::TextMark 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. * @return List of Gtk::TextMark. */ Glib::SListHandle< Glib::RefPtr > get_marks(); /** Returns a list of all Gtk::TextMark 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. * @return List of Gtk::TextMark. */ Glib::SListHandle< Glib::RefPtr > get_marks() const; /** If the location at @a iter contains a child anchor, the * anchor is returned (with no new reference count added). Otherwise, * 0 is returned. * @return The anchor at @a iter . */ Glib::RefPtr get_child_anchor(); /** If the location at @a iter contains a child anchor, the * anchor is returned (with no new reference count added). Otherwise, * 0 is returned. * @return The anchor at @a iter . */ Glib::RefPtr get_child_anchor() const; /** Returns a list of Gtk::TextTag that are toggled on or off at this * point. (If @a toggled_on is true, the list contains tags that are * toggled on.) If a tag is toggled on at @a iter , then some non-empty * range of characters following @a iter has that tag applied to it. If * a tag is toggled off, then some non-empty range following @a iter * does not have the tag applied to it. * @param toggled_on true to get toggled-on tags. * @return Tags toggled at this point. */ Glib::SListHandle< Glib::RefPtr > get_toggled_tags(bool toggled_on = true); /** Returns a list of Gtk::TextTag that are toggled on or off at this * point. (If @a toggled_on is true, the list contains tags that are * toggled on.) If a tag is toggled on at @a iter , then some non-empty * range of characters following @a iter has that tag applied to it. If * a tag is toggled off, then some non-empty range following @a iter * does not have the tag applied to it. * @param toggled_on true to get toggled-on tags. * @return Tags toggled at this point. */ Glib::SListHandle< Glib::RefPtr > get_toggled_tags(bool toggled_on = true) const; /** Returns true if @a tag is toggled on at exactly this point. If @a tag * is 0, returns true if any tag is toggled on at this point. Note * that the gtk_text_iter_begins_tag() returns true if @a iter is the * start of the tagged range; * gtk_text_iter_has_tag() tells you whether an iterator is * within a tagged range. * @param tag A Gtk::TextTag, or 0. * @return Whether @a iter is the start of a range tagged with @a tag . */ bool begins_tag(const Glib::RefPtr& tag) const; bool begins_tag() const; /** Returns true if @a tag is toggled off at exactly this point. If @a tag * is 0, returns true if any tag is toggled off at this point. Note * that the gtk_text_iter_ends_tag() returns true if @a iter is the * end of the tagged range; * gtk_text_iter_has_tag() tells you whether an iterator is * within a tagged range. * @param tag A Gtk::TextTag, or 0. * @return Whether @a iter is the end of a range tagged with @a tag . */ bool ends_tag(const Glib::RefPtr& tag) const; bool ends_tag() const; /** This is equivalent to (gtk_text_iter_begins_tag() || * gtk_text_iter_ends_tag()), i.e.\ it tells you whether a range with * @a tag applied to it begins or ends at @a iter . * @param tag A Gtk::TextTag, or 0. * @return Whether @a tag is toggled on or off at @a iter . */ bool toggles_tag(const Glib::RefPtr& tag) const; bool toggles_tag() const; /** Returns true if @a iter is within a range tagged with @a tag . * @param tag A Gtk::TextTag. * @return Whether @a iter is tagged with @a tag . */ bool has_tag(const Glib::RefPtr& tag) const; bool has_tag() const; /** Returns a list of tags that apply to @a iter , in ascending order of * priority (highest-priority tags are last). * @return List of Gtk::TextTag. */ Glib::SListHandle< Glib::RefPtr > get_tags(); /** Returns a list of tags that apply to @a iter , in ascending order of * priority (highest-priority tags are last). * @return List of Gtk::TextTag. */ Glib::SListHandle< Glib::RefPtr > get_tags() const; /** Returns whether the character at @a iter is within an editable region * of text. Non-editable text is "locked" and can't be changed by the * user via Gtk::TextView. This function is simply a convenience * wrapper around gtk_text_iter_get_attributes(). If no tags applied * to this text affect editability, @a default_setting will be returned. * * You don't want to use this function to decide whether text can be * inserted at @a iter , because for insertion you don't want to know * whether the char at @a iter is inside an editable range, you want to * know whether a new character inserted at @a iter would be inside an * editable range. Use gtk_text_iter_can_insert() to handle this * case. * @param default_setting true if text is editable by default. * @return Whether @a iter is inside an editable range. */ bool editable(bool default_setting = true) const; /** Considering the default editability of the buffer, and tags that * affect editability, determines whether text inserted at @a iter would * be editable. If text inserted at @a iter would be editable then the * user should be allowed to insert text at @a iter . * Gtk::TextBuffer::insert_interactive() uses this function to decide * whether insertions are allowed at a given position. * @param default_editability true if text is editable by default. * @return Whether text inserted at @a iter would be editable. */ bool can_insert(bool default_editability = true) const; /** Determines whether @a iter begins a natural-language word. Word * breaks are determined by Pango and should be correct for nearly any * language (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter is at the start of a word. */ bool starts_word() const; /** Determines whether @a iter ends a natural-language word. Word breaks * are determined by Pango and should be correct for nearly any * language (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter is at the end of a word. */ bool ends_word() const; /** Determines whether @a iter is inside 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 (if not, the * correct fix would be to the Pango word break algorithms). * @return true if @a iter is inside a word. */ bool inside_word() const; /** Determines whether @a iter begins a sentence. Sentence boundaries are * determined by Pango and should be correct for nearly any language * (if not, the correct fix would be to the Pango text boundary * algorithms). * @return true if @a iter is at the start of a sentence. */ bool starts_sentence() const; /** Determines whether @a iter ends a sentence. Sentence boundaries are * determined by Pango and should be correct for nearly any language * (if not, the correct fix would be to the Pango text boundary * algorithms). * @return true if @a iter is at the end of a sentence. */ bool ends_sentence() const; /** Determines whether @a 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 (if not, the * correct fix would be to the Pango text boundary algorithms). * @return true if @a iter is inside a sentence. */ bool inside_sentence() const; /** Returns true if @a iter begins a paragraph, * i.e.\ if gtk_text_iter_get_line_offset() would return 0. * However this function is potentially more efficient than * gtk_text_iter_get_line_offset() because it doesn't have to compute * the offset, it just has to see whether it's 0. * @return Whether @a iter begins a line. */ bool starts_line() const; /** Returns true if @a 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. * @return Whether @a iter is at the end of a line. */ bool ends_line() const; /** See gtk_text_iter_forward_cursor_position() or Pango::LogAttr or * pango_break() for details on what a cursor position is. * @return true if the cursor can be placed at @a iter . */ bool is_cursor_position() const; /** Returns the number of characters in the line containing @a iter , * including the paragraph delimiters. * @return Number of characters in the line. */ int get_chars_in_line() const; /** Returns the number of bytes in the line containing @a iter , * including the paragraph delimiters. * @return Number of bytes in the line. */ int get_bytes_in_line() const; bool get_attributes(TextAttributes& values) const; /** A convenience wrapper around gtk_text_iter_get_attributes(), * which returns the language in effect at @a iter . If no tags affecting * language apply to @a iter , the return value is identical to that of * gtk_get_default_language(). * @return Language in effect at @a iter . */ Pango::Language get_language() const; /** Returns true if @a iter is the end iterator, i.e.\ one past the last * dereferenceable iterator in the buffer. gtk_text_iter_is_end() is * the most efficient way to check whether an iterator is the end * iterator. * @return Whether @a iter is the end iterator. */ bool is_end() const; /** Returns true if @a iter is the first iterator in the buffer, that is * if @a iter has a character offset of 0. * @return Whether @a iter is the first in the buffer. */ bool is_start() const; /** Moves @a iter forward by one character offset. Note that images * embedded in the buffer occupy 1 character slot, so * gtk_text_iter_forward_char() may actually move onto an image instead * of a character, if you have images in your buffer. If @a iter is the * end iterator or one character before it, @a iter will now point at * the end iterator, and gtk_text_iter_forward_char() returns false for * convenience when writing loops. * @return Whether @a iter moved and is dereferenceable. */ bool forward_char(); /** Moves backward by one character offset. Returns true if movement * was possible; if @a iter was the first in the buffer (character * offset 0), gtk_text_iter_backward_char() returns false for convenience when * writing loops. * @return Whether movement was possible. */ bool backward_char(); /** Moves @a count characters if possible (if @a 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 * @a iter is different from its original position, and dereferenceable * (the last iterator in the buffer is not dereferenceable). If @a count * is 0, the function does nothing and returns false. * @param count Number of characters to move, may be negative. * @return Whether @a iter moved and is dereferenceable. */ bool forward_chars(int count); /** Moves @a count characters backward, if possible (if @a 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 @a count is 0, * the function does nothing and returns false. * @param count Number of characters to move. * @return Whether @a iter moved and is dereferenceable. */ bool backward_chars(int count); /** Moves @a iter to the start of the next line. Returns true if there * was a next line to move to, and false if @a iter was simply moved to * the end of the buffer and is now not dereferenceable, or if @a iter was * already at the end of the buffer. * @return Whether @a iter can be dereferenced. */ bool forward_line(); /** Moves @a iter to the start of the previous line. Returns true if * @a iter could be moved; i.e. if @a iter was at character offset 0, this * function returns false. Therefore if @a iter was already on line 0, * but not at the start of the line, @a 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.) * @return Whether @a iter moved. */ bool backward_line(); /** Moves @a count lines forward, if possible (if @a 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 @a count is 0, * the function does nothing and returns false. If @a count is negative, * moves backward by 0 - @a count lines. * @param count Number of lines to move forward. * @return Whether @a iter moved and is dereferenceable. */ bool forward_lines(int count); /** Moves @a count lines backward, if possible (if @a 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 @a count is 0, * the function does nothing and returns false. If @a count is negative, * moves forward by 0 - @a count lines. * @param count Number of lines to move backward. * @return Whether @a iter moved and is dereferenceable. */ bool backward_lines(int count); /** Moves forward to the next word end. (If @a 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 (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter moved and is not the end iterator. */ bool forward_word_end(); /** Moves backward to the previous word start. (If @a 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 (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter moved and is not the end iterator. */ bool backward_word_start(); /** Calls gtk_text_iter_forward_word_end() up to @a count times. * @param count Number of times to move. * @return true if @a iter moved and is not the end iterator. */ bool forward_word_ends(int count); /** Calls gtk_text_iter_backward_word_start() up to @a count times. * @param count Number of times to move. * @return true if @a iter moved and is not the end iterator. */ bool backward_word_starts(int count); /** Moves @a iter to the start of the next visible line. Returns true if there * was a next line to move to, and false if @a iter was simply moved to * the end of the buffer and is now not dereferenceable, or if @a iter was * already at the end of the buffer. * @return Whether @a iter can be dereferenced * * @newin2p8. */ bool forward_visible_line(); /** Moves @a iter to the start of the previous visible line. Returns true if * @a iter could be moved; i.e. if @a iter was at character offset 0, this * function returns false. Therefore if @a iter was already on line 0, * but not at the start of the line, @a 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.) * @return Whether @a iter moved * * @newin2p8. */ bool backward_visible_line(); /** Moves @a count visible lines forward, if possible (if @a 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 @a count is 0, * the function does nothing and returns false. If @a count is negative, * moves backward by 0 - @a count lines. * @param count Number of lines to move forward. * @return Whether @a iter moved and is dereferenceable * * @newin2p8. */ bool forward_visible_line(int count); /** Moves @a count visible lines backward, if possible (if @a 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 @a count is 0, * the function does nothing and returns false. If @a count is negative, * moves forward by 0 - @a count lines. * @param count Number of lines to move backward. * @return Whether @a iter moved and is dereferenceable * * @newin2p8. */ bool backward_visible_lines(int count); //TODO: Now that there are so many *_visible_ versions of the methods, maybe we should //just add a visible=false parameter and therefore halve the number of methods. murrayc /** Moves forward to the next visible word end. (If @a 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 (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter moved and is not the end iterator * * @newin2p4. */ bool forward_visible_word_end(); /** Moves backward to the previous visible word start. (If @a 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 (if not, the correct fix would be to the Pango word break * algorithms). * @return true if @a iter moved and is not the end iterator * * @newin2p4. */ bool backward_visible_word_start(); /** Calls gtk_text_iter_forward_visible_word_end() up to @a count times. * @param count Number of times to move. * @return true if @a iter moved and is not the end iterator * * @newin2p4. */ bool forward_visible_word_ends(int count); /** Calls gtk_text_iter_backward_visible_word_start() up to @a count times. * @param count Number of times to move. * @return true if @a iter moved and is not the end iterator * * @newin2p4. */ bool backward_visible_word_starts(int count); /** Moves forward to the next sentence end. (If @a 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 (if not, the correct fix would be to the Pango text * boundary algorithms). * @return true if @a iter moved and is not the end iterator. */ bool forward_sentence_end(); /** Moves backward to the previous sentence start; if @a 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 (if not, the correct fix would be to the Pango text * boundary algorithms). * @return true if @a iter moved and is not the end iterator. */ bool backward_sentence_start(); /** Calls gtk_text_iter_forward_sentence_end() @a count times (or until * gtk_text_iter_forward_sentence_end() returns false). If @a count is * negative, moves backward instead of forward. * @param count Number of sentences to move. * @return true if @a iter moved and is not the end iterator. */ bool forward_sentence_ends(int count); /** Calls gtk_text_iter_backward_sentence_start() up to @a count times, * or until it returns false. If @a count is negative, moves forward * instead of backward. * @param count Number of sentences to move. * @return true if @a iter moved and is not the end iterator. */ bool backward_sentence_starts(int count); /** Moves @a 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 Pango::LogAttr structure and * pango_break() function. * @return true if we moved and the new position is dereferenceable. */ bool forward_cursor_position(); /** Like gtk_text_iter_forward_cursor_position(), but moves backward. * @return true if we moved. */ bool backward_cursor_position(); /** Moves up to @a count cursor positions. See * gtk_text_iter_forward_cursor_position() for details. * @param count Number of positions to move. * @return true if we moved and the new position is dereferenceable. */ bool forward_cursor_positions(int count); /** Moves up to @a count cursor positions. See * gtk_text_iter_forward_cursor_position() for details. * @param count Number of positions to move. * @return true if we moved and the new position is dereferenceable. */ bool backward_cursor_positions(int count); /** Moves @a iter forward to the next visible cursor position. See * gtk_text_iter_forward_cursor_position() for details. * @return true if we moved and the new position is dereferenceable * * @newin2p4. */ bool forward_visible_cursor_position(); /** Moves @a iter forward to the previous visible cursor position. See * gtk_text_iter_backward_cursor_position() for details. * @return true if we moved and the new position is dereferenceable * * @newin2p4. */ bool backward_visible_cursor_position(); /** Moves up to @a count visible cursor positions. See * gtk_text_iter_forward_cursor_position() for details. * @param count Number of positions to move. * @return true if we moved and the new position is dereferenceable * * @newin2p4. */ bool forward_visible_cursor_positions(int count); /** Moves up to @a count visible cursor positions. See * gtk_text_iter_forward_cursor_position() for details. * @param count Number of positions to move. * @return true if we moved and the new position is dereferenceable * * @newin2p4. */ bool backward_visible_cursor_positions(int count); /** Sets @a iter to point to @a char_offset . @a char_offset counts from the start * of the entire text buffer, starting with 0. * @param char_offset A character number. */ void set_offset(int char_offset); /** Moves iterator @a iter to the start of the line @a line_number . If * @a line_number is negative or larger than the number of lines in the * buffer, moves @a iter to the start of the last line in the buffer. * @param line_number Line number (counted from 0). */ void set_line(int line_number); /** Moves @a 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, @a iter * moves to the start of the next line. See * gtk_text_iter_set_line_index() if you have a byte index rather than * a character offset. * @param char_on_line A character offset relative to the start of @a iter 's current line. */ void set_line_offset(int char_on_line); /** Same as gtk_text_iter_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. * @param byte_on_line A byte index relative to the start of @a iter 's current line. */ void set_line_index(int byte_on_line); /** Moves @a iter forward to the "end iterator," which points one past the last * valid character in the buffer. gtk_text_iter_get_char() called on the * end iterator returns 0, which is convenient for writing loops. */ void forward_to_end(); /** Moves the iterator to point to the paragraph delimiter characters, * which will be 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 @a 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. * @return true if we moved and the new location is not the end iterator. */ bool forward_to_line_end(); /** Like gtk_text_iter_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. * @param char_on_line A character offset. */ void set_visible_line_offset(int char_on_line); /** Like gtk_text_iter_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. * @param byte_on_line A byte index. */ void set_visible_line_index(int byte_on_line); /** Moves forward to the next toggle (on or off) of the * Gtk::TextTag @a tag , or to the next toggle of any tag if * @a tag is 0. If no matching tag toggles are found, * returns false, otherwise true. Does not return toggles * located at @a iter , only toggles after @a iter . Sets @a iter to * the location of the toggle, or to the end of the buffer * if no toggle is found. * @param tag A Gtk::TextTag, or 0. * @return Whether we found a tag toggle after @a iter . */ bool forward_to_tag_toggle(const Glib::RefPtr& tag); /** Moves backward to the next toggle (on or off) of the * Gtk::TextTag @a tag , or to the next toggle of any tag if * @a tag is 0. If no matching tag toggles are found, * returns false, otherwise true. Does not return toggles * located at @a iter , only toggles before @a iter . Sets @a iter * to the location of the toggle, or the start of the buffer * if no toggle is found. * @param tag A Gtk::TextTag, or 0. * @return Whether we found a tag toggle before @a iter . */ bool backward_to_tag_toggle(const Glib::RefPtr& tag); template bool forward_find_char(const Predicate& predicate, const TextIter& limit); template bool forward_find_char(const Predicate& predicate); template bool backward_find_char(const Predicate& predicate, const TextIter& limit); template bool backward_find_char(const Predicate& predicate); /** Searches forward for @a str . Any match is returned by setting * @a match_start to the first character of the match and @a match_end to the * first character after the match. The search will not continue past * @a limit . Note that a search is a linear or O(n) operation, so you * may wish to use @a limit to avoid locking up your UI on large * buffers. * * If the Gtk::TEXT_SEARCH_VISIBLE_ONLY flag is present, the match may * have invisible text interspersed in @a str . i.e. @a str will be a * possibly-noncontiguous subsequence of the matched range. similarly, * if you specify Gtk::TEXT_SEARCH_TEXT_ONLY, the match may have * pixbufs or child widgets mixed inside the matched range. If these * flags are not given, the match must be exact; the special 0xFFFC * character in @a str will match embedded pixbufs or child widgets. * @param str A search string. * @param flags Flags affecting how the search is done. * @param match_start Return location for start of match. * @param match_end Return location for end of match. * @param limit Bound for the search. * @return Whether a match was found. */ bool forward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end, const TextIter& limit) const; /** Same as forward_search(), but searchs to the end. * * @param str A search string. * @param flags Flags affecting how the search is done. * @param match_start Return location for start of match, or 0. * @param match_end Return location for end of match, or 0. * @return Whether a match was found. */ bool forward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const; /** Same as gtk_text_iter_forward_search(), but moves backward. * @param str Search string. * @param flags Bitmask of flags affecting the search. * @param match_start Return location for start of match. * @param match_end Return location for end of match. * @param limit Location of last possible @a match_start . * @return Whether a match was found. */ bool backward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end, const TextIter& limit) const; /** Same as backward_search(), but searches to the start. * @param str Search string. * @param flags Bitmask of flags affecting the search. * @param match_start Return location for start of match, or 0. * @param match_end Return location for end of match, or 0. * @return Whether a match was found. */ bool backward_search(const Glib::ustring& str, TextSearchFlags flags, TextIter& match_start, TextIter& match_end) const; /** A qsort()-style function that returns negative if @a lhs is less than * @a rhs , positive if @a lhs is greater than @a 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. * @param rhs Another Gtk::TextIter. * @return -1 if @a lhs is less than @a rhs , 1 if @a lhs is greater, 0 if they are equal. */ int compare(const TextIter& rhs) const; /** Checks whether @a iter falls in the range [ @a start , @a end ). * @a start and @a end must be in ascending order. * @param start Start of range. * @param end End of range. * @return true if @a iter is in the range. */ bool in_range(const TextIter& start, const TextIter& end) const; /** Swaps the value of @a first and @a second if @a second comes before * @a first in the buffer. That is, ensures that @a first and @a 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 gtk_text_iter_in_range(), * that expect a pre-sorted range. * @param second Another Gtk::TextIter. */ void order(TextIter& second); }; #ifndef DOXYGEN_SHOULD_SKIP_THIS template inline TextIter::PredicateAdapter::PredicateAdapter(const Predicate& predicate) : predicate_ (predicate) {} // static template gboolean TextIter::PredicateAdapter::gtk_callback(gunichar uc, void* user_data) { #ifdef GLIBMM_EXCEPTIONS_ENABLED try { #endif //GLIBMM_EXCEPTIONS_ENABLED // This will either use Predicate::operator(), or call a function pointer. // The explicit conditional expression avoids relying on an implicit // conversion of the return type to int, which might be not available. return (static_cast*>(user_data)->predicate_(uc)) ? 1 : 0; #ifdef GLIBMM_EXCEPTIONS_ENABLED } catch(...) { Glib::exception_handlers_invoke(); return 0; } #endif //GLIBMM_EXCEPTIONS_ENABLED } inline TextIter& TextIter::operator++() { forward_char(); return *this; } inline const TextIter TextIter::operator++(int) { const TextIter temp (*this); forward_char(); return temp; } inline TextIter& TextIter::operator--() { backward_char(); return *this; } inline const TextIter TextIter::operator--(int) { const TextIter temp (*this); backward_char(); return temp; } inline TextIter::value_type TextIter::operator*() const { return get_char(); } inline TextIter::operator bool() const { return !is_end(); } template bool TextIter::forward_find_char(const Predicate& predicate, const TextIter& limit) { typedef TextIter::PredicateAdapter PredAdapter; PredAdapter adapter (predicate); return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj()); } template bool TextIter::forward_find_char(const Predicate& predicate) { typedef TextIter::PredicateAdapter PredAdapter; PredAdapter adapter (predicate); return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, 0); } template bool TextIter::backward_find_char(const Predicate& predicate, const TextIter& limit) { typedef TextIter::PredicateAdapter PredAdapter; PredAdapter adapter (predicate); return this->backward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj()); } template bool TextIter::backward_find_char(const Predicate& predicate) { typedef TextIter::PredicateAdapter PredAdapter; PredAdapter adapter (predicate); return this->backward_find_char_impl(&PredAdapter::gtk_callback, &adapter, 0); } #endif /* DOXYGEN_SHOULD_SKIP_THIS */ } // namespace Gtk namespace Gtk { /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator==(const TextIter& lhs, const TextIter& rhs); /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator!=(const TextIter& lhs, const TextIter& rhs); /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator<(const TextIter& lhs, const TextIter& rhs); /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator>(const TextIter& lhs, const TextIter& rhs); /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator<=(const TextIter& lhs, const TextIter& rhs); /** @relates Gtk::TextIter * @param lhs The left-hand side * @param rhs The right-hand side * @result The result */ bool operator>=(const TextIter& lhs, const TextIter& rhs); } // namespace Gtk namespace Glib { /** @relates Gtk::TextIter * @param object The C instance * @result A C++ instance that wraps this C instance. */ Gtk::TextIter& wrap(GtkTextIter* object); /** @relates Gtk::TextIter * @param object The C instance * @result A C++ instance that wraps this C instance. */ const Gtk::TextIter& wrap(const GtkTextIter* object); #ifndef DOXYGEN_SHOULD_SKIP_THIS template <> class Value : public Glib::Value_Boxed {}; #endif /* DOXYGEN_SHOULD_SKIP_THIS */ } // namespace Glib #endif /* _GTKMM_TEXTITER_H */