ardour/livetrax
13
0
Fork 0
Code
6bec40d859
livetrax/libs/gtkmm2/gtk/gtkmm/textiter.h
Taybin Rutkin d09f6b3016 Initial revision 
git-svn-id: svn://localhost/trunk/ardour2@4 d708f5d6-7413-0410-9779-e7cbd77b26cf
2005-05-13 20:47:18 +00:00

1211 lines
47 KiB
C++
Raw Blame History

// -*- c++ -*-
// Generated by gtkmmproc -- DO NOT MODIFY!
#ifndef _GTKMM_TEXTITER_H
#define _GTKMM_TEXTITER_H
#include <glibmm.h>
/* $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 <glibmm/exceptionhandler.h>
#include <glibmm/slisthandle.h>
#include <gdkmm/pixbuf.h>
#include <gtkmm/texttag.h>
#include <gtkmm/textchildanchor.h>
#include <gtkmm/textattributes.h>
#include <gtk/gtktextiter.h> /* we need the definition of GtkTextIter */
namespace Gtk
{
/** @addtogroup gtkmmEnums Enums and Flags */
/**
* @ingroup gtkmmEnums
* @par Bitwise operators:
* <tt>%TextSearchFlags operator|(TextSearchFlags, TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags operator&(TextSearchFlags, TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags operator^(TextSearchFlags, TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags operator~(TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags& operator|=(TextSearchFlags&, TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags& operator&=(TextSearchFlags&, TextSearchFlags)</tt><br>
* <tt>%TextSearchFlags& operator^=(TextSearchFlags&, TextSearchFlags)</tt><br>
*/
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<TextSearchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs)); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags operator&(TextSearchFlags lhs, TextSearchFlags rhs)
{ return static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs)); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags operator^(TextSearchFlags lhs, TextSearchFlags rhs)
{ return static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs)); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags operator~(TextSearchFlags flags)
{ return static_cast<TextSearchFlags>(~static_cast<unsigned>(flags)); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags& operator|=(TextSearchFlags& lhs, TextSearchFlags rhs)
{ return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) | static_cast<unsigned>(rhs))); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags& operator&=(TextSearchFlags& lhs, TextSearchFlags rhs)
{ return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) & static_cast<unsigned>(rhs))); }
/** @ingroup gtkmmEnums */
inline TextSearchFlags& operator^=(TextSearchFlags& lhs, TextSearchFlags rhs)
{ return (lhs = static_cast<TextSearchFlags>(static_cast<unsigned>(lhs) ^ static_cast<unsigned>(rhs))); }
} // namespace Gtk
#ifndef DOXYGEN_SHOULD_SKIP_THIS
namespace Glib
{
template <>
class Value<Gtk::TextSearchFlags> : public Glib::Value_Flags<Gtk::TextSearchFlags>
{
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 <class Predicate>
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 <tt>true</tt>, returns <tt>true</tt> and stops scanning.
* If @a pred never returns <tt>true</tt>, @a iter is set to @a limit if
* @a limit is non-<tt>0</tt>, 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 <tt>0</tt> 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 <tt>0</tt> 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<TextBuffer> 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 <em>text</em> 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,
* <tt>0</tt> is returned.
* @return The pixbuf at @a iter .
*/
Glib::RefPtr<Gdk::Pixbuf> 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<TextMark> > 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<const TextMark> > get_marks() const;
/** If the location at @a iter contains a child anchor, the
* anchor is returned (with no new reference count added). Otherwise,
* <tt>0</tt> is returned.
* @return The anchor at @a iter .
*/
Glib::RefPtr<TextChildAnchor> get_child_anchor();
/** If the location at @a iter contains a child anchor, the
* anchor is returned (with no new reference count added). Otherwise,
* <tt>0</tt> is returned.
* @return The anchor at @a iter .
*/
Glib::RefPtr<const TextChildAnchor> get_child_anchor() const;
/** Returns a list of Gtk::TextTag that are toggled on or off at this
* point. (If @a toggled_on is <tt>true</tt>, 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 <em>not</em> have the tag applied to it.
* @param toggled_on <tt>true</tt> to get toggled-on tags.
* @return Tags toggled at this point.
*/
Glib::SListHandle< Glib::RefPtr<TextTag> > 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 <tt>true</tt>, 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 <em>not</em> have the tag applied to it.
* @param toggled_on <tt>true</tt> to get toggled-on tags.
* @return Tags toggled at this point.
*/
Glib::SListHandle< Glib::RefPtr<const TextTag> > get_toggled_tags(bool toggled_on = true) const;
/** Returns <tt>true</tt> if @a tag is toggled on at exactly this point. If @a tag
* is <tt>0</tt>, returns <tt>true</tt> if any tag is toggled on at this point. Note
* that the gtk_text_iter_begins_tag() returns <tt>true</tt> if @a iter is the
* <em>start</em> of the tagged range;
* gtk_text_iter_has_tag() tells you whether an iterator is
* <em>within</em> a tagged range.
* @param tag A Gtk::TextTag, or <tt>0</tt>.
* @return Whether @a iter is the start of a range tagged with @a tag .
*/
bool begins_tag(const Glib::RefPtr<const TextTag>& tag) const;
bool begins_tag() const;
/** Returns <tt>true</tt> if @a tag is toggled off at exactly this point. If @a tag
* is <tt>0</tt>, returns <tt>true</tt> if any tag is toggled off at this point. Note
* that the gtk_text_iter_ends_tag() returns <tt>true</tt> if @a iter is the
* <em>end</em> of the tagged range;
* gtk_text_iter_has_tag() tells you whether an iterator is
* <em>within</em> a tagged range.
* @param tag A Gtk::TextTag, or <tt>0</tt>.
* @return Whether @a iter is the end of a range tagged with @a tag .
*/
bool ends_tag(const Glib::RefPtr<const TextTag>& 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 <em>or</em> ends at @a iter .
* @param tag A Gtk::TextTag, or <tt>0</tt>.
* @return Whether @a tag is toggled on or off at @a iter .
*/
bool toggles_tag(const Glib::RefPtr<const TextTag>& tag) const;
bool toggles_tag() const;
/** Returns <tt>true</tt> 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<const TextTag>& 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<TextTag> > 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<const TextTag> > 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> if @a iter is inside a sentence.
*/
bool inside_sentence() const;
/** Returns <tt>true</tt> 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 <tt>true</tt> 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 <tt>\\n</tt> of a <tt>\\r</tt><tt>\\n</tt> pair will not be counted as
* the end of a line, the line ends before the <tt>\\r</tt>. 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>false</tt> for
* convenience when writing loops.
* @return Whether @a iter moved and is dereferenceable.
*/
bool forward_char();
/** Moves backward by one character offset. Returns <tt>true</tt> if movement
* was possible; if @a iter was the first in the buffer (character
* offset 0), gtk_text_iter_backward_char() returns <tt>false</tt> 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 <tt>false</tt>.
* @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 <tt>false</tt> is returned. If @a count is 0,
* the function does nothing and returns <tt>false</tt>.
* @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 <tt>true</tt> if there
* was a next line to move to, and <tt>false</tt> 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 <tt>true</tt> if
* @a iter could be moved; i.e. if @a iter was at character offset 0, this
* function returns <tt>false</tt>. 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 <tt>true</tt>. (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 <tt>false</tt> is returned. If @a count is 0,
* the function does nothing and returns <tt>false</tt>. 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 <tt>false</tt> is returned. If @a count is 0,
* the function does nothing and returns <tt>false</tt>. 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> if @a iter moved and is not the end iterator.
*/
bool backward_word_starts(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 <tt>true</tt> if @a iter moved and is not the end iterator
*
* Since: 2.4.
*/
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 <tt>true</tt> if @a iter moved and is not the end iterator
*
* Since: 2.4.
*/
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 <tt>true</tt> if @a iter moved and is not the end iterator
*
* Since: 2.4.
*/
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 <tt>true</tt> if @a iter moved and is not the end iterator
*
* Since: 2.4.
*/
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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>false</tt>). If @a count is
* negative, moves backward instead of forward.
* @param count Number of sentences to move.
* @return <tt>true</tt> 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 <tt>false</tt>. If @a count is negative, moves forward
* instead of backward.
* @param count Number of sentences to move.
* @return <tt>true</tt> 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 <tt>true</tt> if we moved and the new position is dereferenceable.
*/
bool forward_cursor_position();
/** Like gtk_text_iter_forward_cursor_position(), but moves backward.
* @return <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> 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 <tt>true</tt> if we moved and the new position is dereferenceable
*
* Since: 2.4.
*/
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 <tt>true</tt> if we moved and the new position is dereferenceable
*
* Since: 2.4.
*/
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 <tt>true</tt> if we moved and the new position is dereferenceable
*
* Since: 2.4.
*/
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 <tt>true</tt> if we moved and the new position is dereferenceable
*
* Since: 2.4.
*/
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 <em>character</em>
* (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
* <em>byte</em> 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 <tt>false</tt>.
* @return <tt>true</tt> 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 <tt>0</tt>. If no matching tag toggles are found,
* returns <tt>false</tt>, otherwise <tt>true</tt>. 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 <tt>0</tt>.
* @return Whether we found a tag toggle after @a iter .
*/
bool forward_to_tag_toggle(const Glib::RefPtr<TextTag>& 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 <tt>0</tt>. If no matching tag toggles are found,
* returns <tt>false</tt>, otherwise <tt>true</tt>. 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 <tt>0</tt>.
* @return Whether we found a tag toggle before @a iter .
*/
bool backward_to_tag_toggle(const Glib::RefPtr<TextTag>& tag);
template <class Predicate> bool forward_find_char(const Predicate& predicate, const TextIter& limit);
template <class Predicate> bool forward_find_char(const Predicate& predicate);
template <class Predicate> bool backward_find_char(const Predicate& predicate, const TextIter& limit);
template <class Predicate> 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 <tt>0</tt>.
* @param match_end Return location for end of match, or <tt>0</tt>.
* @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 <tt>0</tt>.
* @param match_end Return location for end of match, or <tt>0</tt>.
* @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 <tt>true</tt> 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 <class Predicate> inline
TextIter::PredicateAdapter<Predicate>::PredicateAdapter(const Predicate& predicate)
:
predicate_ (predicate)
{}
// static
template <class Predicate>
gboolean TextIter::PredicateAdapter<Predicate>::gtk_callback(gunichar uc, void* user_data)
{
try
{
// 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<TextIter::PredicateAdapter<Predicate>*>(user_data)->predicate_(uc)) ? 1 : 0;
}
catch(...)
{
Glib::exception_handlers_invoke();
return 0;
}
}
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 <class Predicate>
bool TextIter::forward_find_char(const Predicate& predicate, const TextIter& limit)
{
typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
PredAdapter adapter (predicate);
return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj());
}
template <class Predicate>
bool TextIter::forward_find_char(const Predicate& predicate)
{
typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
PredAdapter adapter (predicate);
return this->forward_find_char_impl(&PredAdapter::gtk_callback, &adapter, 0);
}
template <class Predicate>
bool TextIter::backward_find_char(const Predicate& predicate, const TextIter& limit)
{
typedef TextIter::PredicateAdapter<Predicate> PredAdapter;
PredAdapter adapter (predicate);
return this->backward_find_char_impl(&PredAdapter::gtk_callback, &adapter, limit.gobj());
}
template <class Predicate>
bool TextIter::backward_find_char(const Predicate& predicate)
{
typedef TextIter::PredicateAdapter<Predicate> 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<Gtk::TextIter> : public Glib::Value_Boxed<Gtk::TextIter>
{};
#endif /* DOXYGEN_SHOULD_SKIP_THIS */
} // namespace Glib
#endif /* _GTKMM_TEXTITER_H */
View Git Blame Copy Permalink