gtkmm: Gtk::TextBuffer Class Reference

Multi-line attributed text that can be displayed by one or more Gtk::TextView widgets. More...

#include <gtkmm/textbuffer.h>

Inheritance diagram for Gtk::TextBuffer:

Public Types

typedef TextIter iterator
 
typedef TextConstIter const_iterator
 
typedef TextTag Tag
 
typedef TextTagTable TagTable
 
typedef TextMark Mark
 
typedef TextChildAnchor ChildAnchor
 
- Public Types inherited from Glib::Object
typedef void(*)(gpointer data DestroyNotify)
 
- Public Types inherited from sigc::trackable
typedef internal::func_destroy_notify func_destroy_notify
 
- Public Types inherited from sigc::notifiable
typedef internal::func_destroy_notify func_destroy_notify
 

Public Member Functions

 TextBuffer (TextBuffer&& src) noexcept
 
TextBufferoperator= (TextBuffer&& src) noexcept
 
 ~TextBuffer () noexcept override
 
GtkTextBuffer* gobj ()
 Provides access to the underlying C GObject. More...

 
const GtkTextBuffer* gobj () const
 Provides access to the underlying C GObject. More...

 
GtkTextBuffer* gobj_copy ()
 Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs. More...

 
int get_line_count () const
 Obtains the number of lines in the buffer. More...

 
int get_char_count () const
 Gets the number of characters in the buffer; note that characters and bytes are not the same, you can’t e.g. expect the contents of the buffer in string form to be this many bytes long. More...

 
int size () const
 See get_char_count(). More...

 
Glib::RefPtr< TextBuffer::TagTableget_tag_table ()
 Get the Gtk::TextTagTable associated with this buffer. More...

 
Glib::RefPtr< const TextBuffer::TagTableget_tag_table () const
 Get the Gtk::TextTagTable associated with this buffer. More...

 
void set_text (const Glib::ustring& text)
 Removes the current contents of the buffer, and inserts text instead. More...

 
void set_text (const char* text_begin, const char* text_end)
 Removes the current contents of the buffer, and inserts text instead. More...

 
iterator insert (const iterator& pos, const Glib::ustring& text)
 Inserts text at position pos. More...

 
iterator insert (const iterator& pos, const char* text_begin, const char* text_end)
 Inserts text at position pos. More...

 
void insert_at_cursor (const Glib::ustring& text)
 Inserts text, using the current cursor position as the insertion point. More...

 
void insert_at_cursor (const char* text_begin, const char* text_end)
 Inserts text, using the current cursor position as the insertion point. More...

 
std::pair< iterator, bool > insert_interactive (const iterator& pos, const Glib::ustring& text, bool default_editable=true)
 Like insert(), but the insertion will not occur if iter is at a non-editable location in the buffer. More...

 
std::pair< iterator, bool > insert_interactive (const iterator& pos, const char* text_begin, const char* text_end, bool default_editable=true)
 Like insert(), but the insertion will not occur if pos is at a non-editable location in the buffer. More...

 
bool insert_interactive_at_cursor (const Glib::ustring& text, bool default_editable=true)
 Calls insert_interactive() at the cursor position. More...

 
bool insert_interactive_at_cursor (const char* text_begin, const char* text_end, bool default_editable=true)
 Calls insert_interactive() at the cursor position. More...

 
iterator insert (const iterator& pos, const const_iterator& range_begin, const const_iterator& range_end)
 Copies text, tags, and paintable between range_begin and range_end (the order of range_begin and range_begin doesn't matter) and inserts the copy at pos. More...

 
std::pair< iterator, bool > insert_interactive (const iterator& pos, const const_iterator& range_begin, const const_iterator& range_end, bool default_editable=true)
 Same as insert_range(), but does nothing if the insertion point isn't editable. More...

 
iterator insert_with_tag (const iterator& pos, const Glib::ustring& text, const Glib::RefPtr< Tag >& tag)
 
iterator insert_with_tag (const iterator& pos, const char* text_begin, const char* text_end, const Glib::RefPtr< Tag >& tag)
 
iterator insert_with_tag (const iterator& pos, const Glib::ustring& text, const Glib::ustring& tag_name)
 
iterator insert_with_tag (const iterator& pos, const char* text_begin, const char* text_end, const Glib::ustring& tag_name)
 
iterator insert_with_tags (const iterator& pos, const Glib::ustring& text, const std::vector< Glib::RefPtr< Tag > >& tags)
 Inserts text into buffer at pos, applying the list of tags to the newly-inserted text. More...

 
iterator insert_with_tags (const iterator& pos, const char* text_begin, const char* text_end, const std::vector< Glib::RefPtr< Tag > >& tags)
 Inserts text into buffer at pos, applying the list of tags to the newly-inserted text. More...

 
iterator insert_with_tags_by_name (const iterator& pos, const Glib::ustring& text, const std::vector< Glib::ustring >& tag_names)
 Inserts text into buffer at pos, applying the list of tags to the newly-inserted text. More...

 
iterator insert_with_tags_by_name (const iterator& pos, const char* text_begin, const char* text_end, const std::vector< Glib::ustring >& tag_names)
 Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function. More...

 
iterator insert_markup (const iterator& pos, const Glib::ustring& markup)
 Inserts text in markup at position pos. More...

 
iterator insert_markup (const iterator& pos, const char* markup_begin, const char* markup_end)
 Inserts markup text at position pos. More...

 
iterator erase (const iterator& range_begin, const iterator& range_end)
 
std::pair< iterator, bool > erase_interactive (const iterator& range_begin, const iterator& range_end, bool default_editable=true)
 
iterator backspace (const iterator& iter, bool interactive=true, bool default_editable=true)
 Performs the appropriate action as if the user hit the delete key with the cursor at the position specified by iter. More...

 
Glib::ustring get_text (const const_iterator& range_start, const const_iterator& range_end, bool include_hidden_chars=true) const
 Returns the text in the range [ range_start, range_end). More...

 
Glib::ustring get_text (bool include_hidden_chars=true) const
 Returns all the text in the buffer. More...

 
Glib::ustring get_slice (const const_iterator& range_start, const const_iterator& range_end, bool include_hidden_chars=true) const
 Returns the text in the range [ range_start, range_end). More...

 
iterator insert_paintable (const iterator& pos, const Glib::RefPtr< Gdk::Paintable >& paintable)
 
iterator insert_child_anchor (const iterator& pos, const Glib::RefPtr< ChildAnchor >& anchor)
 
Glib::RefPtr< ChildAnchorcreate_child_anchor (const iterator& pos)
 
void add_mark (const Glib::RefPtr< TextBuffer::Mark >& mark, const iterator& where)
 Adds the mark at position where. More...

 
Glib::RefPtr< TextBuffer::Markcreate_mark (const Glib::ustring& mark_name, const iterator& where, bool left_gravity=true)
 Creates a mark at position where. More...

 
Glib::RefPtr< Markcreate_mark (const iterator& where, bool left_gravity=true)
 Create an anonymous mark. More...

 
void move_mark (const Glib::RefPtr< Mark >& mark, const iterator& where)
 Moves mark to the new location where. More...

 
void delete_mark (const Glib::RefPtr< Mark >& mark)
 Deletes mark, so that it's no longer located anywhere in the buffer. More...

 
Glib::RefPtr< TextBuffer::Markget_mark (const Glib::ustring& name)
 Returns the mark named name in buffer buffer, or nullptr if no such mark exists in the buffer. More...

 
Glib::RefPtr< const TextBuffer::Markget_mark (const Glib::ustring& name) const
 Returns the mark named name in buffer buffer, or nullptr if no such mark exists in the buffer. More...

 
void move_mark_by_name (const Glib::ustring& name, const iterator& where)
 Moves the mark named name (which must exist) to location where. More...

 
void delete_mark_by_name (const Glib::ustring& name)
 Deletes the mark named name; the mark must exist. More...

 
Glib::RefPtr< TextBuffer::Markget_insert ()
 Returns the mark that represents the cursor (insertion point). More...

 
Glib::RefPtr< TextBuffer::Markget_selection_bound ()
 Returns the mark that represents the selection bound. More...

 
void place_cursor (const iterator& where)
 This function moves the “insert” and “selection_bound” marks simultaneously. More...

 
void apply_tag (const Glib::RefPtr< Tag >& tag, const iterator& range_start, const iterator& range_end)
 Emits the “apply-tag” signal on buffer. More...

 
void remove_tag (const Glib::RefPtr< Tag >& tag, const iterator& range_start, const iterator& range_end)
 Emits the “remove-tag” signal. More...

 
void apply_tag_by_name (const Glib::ustring& name, const iterator& range_start, const iterator& range_end)
 Calls Gtk::TextTagTable::lookup() on the buffer’s tag table to get a Gtk::TextTag, then calls apply_tag(). More...

 
void remove_tag_by_name (const Glib::ustring& name, const iterator& range_start, const iterator& range_end)
 Calls Gtk::TextTagTable::lookup() on the buffer’s tag table to get a Gtk::TextTag, then calls remove_tag(). More...

 
void remove_all_tags (const iterator& range_start, const iterator& range_end)
 Removes all tags in the range between range_start and range_end. More...

 
Glib::RefPtr< Tagcreate_tag (const Glib::ustring& tag_name)
 Creates a tag and adds it to the tag table for buffer. More...

 
Glib::RefPtr< Tagcreate_tag ()
 Creates an anoymous tag and adds it to the tag table for buffer. More...

 
iterator get_iter_at_line_offset (int line_number, int char_offset)
 
const_iterator get_iter_at_line_offset (int line_number, int char_offset) const
 
iterator get_iter_at_line_index (int line_number, int byte_index)
 
const_iterator get_iter_at_line_index (int line_number, int byte_index) const
 
iterator get_iter_at_offset (int char_offset)
 
const_iterator get_iter_at_offset (int char_offset) const
 
iterator get_iter_at_line (int line_number)
 
const_iterator get_iter_at_line (int line_number) const
 
iterator begin ()
 
const_iterator begin () const
 
iterator end ()
 
const_iterator end () const
 
void get_bounds (iterator& range_begin, iterator& range_end)
 
void get_bounds (const_iterator& range_begin, const_iterator& range_end) const
 
iterator get_iter_at_mark (const Glib::RefPtr< Mark >& mark)
 Get the current position of a mark. More...

 
const_iterator get_iter_at_mark (const Glib::RefPtr< Mark >& mark) const
 Get the current position of a mark. More...

 
iterator get_iter_at_child_anchor (const Glib::RefPtr< ChildAnchor >& anchor)
 Get the current position of an anchor. More...

 
const_iterator get_iter_at_child_anchor (const Glib::RefPtr< ChildAnchor >& anchor) const
 Get the current position of an anchor. More...

 
bool get_modified () const
 Indicates whether the buffer has been modified since the last call to set_modified() set the modification flag to false. More...

 
void set_modified (bool setting=true)
 Used to keep track of whether the buffer has been modified since the last time it was saved. More...

 
bool get_has_selection () const
 Indicates whether the buffer has some text currently selected. More...

 
void add_selection_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard)
 Adds clipboard to the list of clipboards in which the selection contents of buffer are available. More...

 
void remove_selection_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard)
 Removes a Gdk::Clipboard added with add_selection_clipboard(). More...

 
void cut_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard, bool default_editable=true)
 Copies the currently-selected text to a clipboard, then deletes said text if it’s editable. More...

 
void copy_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard)
 Copies the currently-selected text to a clipboard. More...

 
void paste_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard, const iterator& override_location, bool default_editable=true)
 Pastes the contents of a clipboard. More...

 
void paste_clipboard (const Glib::RefPtr< Gdk::Clipboard >& clipboard, bool default_editable=true)
 A paste_clipboard() convenience overload. More...

 
bool get_selection_bounds (iterator& range_start, iterator& range_end)
 Returns true if some text is selected; places the bounds of the selection in range_start and range_end (if the selection has length 0, then range_start and range_end are filled in with the same value). More...

 
bool get_selection_bounds (const_iterator& range_start, const_iterator& range_end) const
 Returns true if some text is selected; places the bounds of the selection in range_start and range_end (if the selection has length 0, then range_start and range_end are filled in with the same value). More...

 
bool erase_selection (bool interactive=true, bool default_editable=true)
 Deletes the range between the “insert” and “selection_bound” marks, that is, the currently-selected text. More...

 
Glib::RefPtr< Gdk::ContentProviderget_selection_content ()
 Get a content provider for this buffer. More...

 
void select_range (const iterator& ins, const iterator& bound)
 This function moves the “insert” and “selection_bound” marks simultaneously. More...

 
bool get_can_undo () const
 
bool get_can_redo () const
 
bool get_enable_undo () const
 Gets whether the buffer is saving modifications to the buffer to allow for undo and redo actions. More...

 
void set_enable_undo (bool enable_undo=true)
 Sets whether or not to enable undoable actions in the text buffer. More...

 
guint get_max_undo_levels () const
 Gets the maximum number of undo levels to perform. More...

 
void set_max_undo_levels (guint max_undo_levels)
 Sets the maximum number of undo levels to perform. More...

 
void undo ()
 Undoes the last undoable action on the buffer, if there is one. More...

 
void redo ()
 Redoes the next redoable action on the buffer, if there is one. More...

 
void begin_irreversible_action ()
 Denotes the beginning of an action that may not be undone. More...

 
void end_irreversible_action ()
 Denotes the end of an action that may not be undone. More...

 
void begin_user_action ()
 Called to indicate that the buffer operations between here and a call to end_user_action() are part of a single user-visible operation. More...

 
void end_user_action ()
 Should be paired with a call to begin_user_action(). More...

 
Glib::SignalProxy< void(TextBuffer::iterator&, const Glib::ustring&, int)> signal_insert ()
 
Glib::SignalProxy< void(TextBuffer::iterator&, const Glib::RefPtr< Gdk::Paintable >&)> signal_insert_paintable ()
 
Glib::SignalProxy< void(TextBuffer::iterator&, const Glib::RefPtr< ChildAnchor >&)> signal_insert_child_anchor ()
 
Glib::SignalProxy< void(TextBuffer::iterator&, TextBuffer::iterator&)> signal_erase ()
 
Glib::SignalProxy< void()> signal_changed ()
 
Glib::SignalProxy< void()> signal_modified_changed ()
 
Glib::SignalProxy< void(const TextBuffer::iterator&, const Glib::RefPtr< TextBuffer::Mark >&)> signal_mark_set ()
 
Glib::SignalProxy< void(const Glib::RefPtr< TextBuffer::Mark >&)> signal_mark_deleted ()
 
Glib::SignalProxy< void(const Glib::RefPtr< TextBuffer::Tag >&, const TextBuffer::iterator&, const TextBuffer::iterator&)> signal_apply_tag ()
 
Glib::SignalProxy< void(const Glib::RefPtr< TextBuffer::Tag >&, const TextBuffer::iterator&, const TextBuffer::iterator&)> signal_remove_tag ()
 
Glib::SignalProxy< void()> signal_begin_user_action ()
 
Glib::SignalProxy< void()> signal_end_user_action ()
 
Glib::SignalProxy< void(const Glib::RefPtr< Gdk::Clipboard >&)> signal_paste_done ()
 
Glib::SignalProxy< void()> signal_redo ()
 
Glib::SignalProxy< void()> signal_undo ()
 
Glib::PropertyProxy_ReadOnly< Glib::RefPtr< TextBuffer::TagTable > > property_tag_table () const
 Text Tag Table. More...

 
Glib::PropertyProxy< Glib::ustringproperty_text ()
 The text content of the buffer. More...

 
Glib::PropertyProxy_ReadOnly< Glib::ustringproperty_text () const
 The text content of the buffer. More...

 
Glib::PropertyProxy_ReadOnly< bool > property_has_selection () const
 Whether the buffer has some text currently selected. More...

 
Glib::PropertyProxy_ReadOnly< int > property_cursor_position () const
 The position of the insert mark (as offset from the beginning of the buffer). More...

 
Glib::PropertyProxy_ReadOnly< Glib::RefPtr< Gdk::ContentFormats > > property_copy_target_list () const
 The list of targets this buffer supports for clipboard copying and as DND source. More...

 
Glib::PropertyProxy_ReadOnly< Glib::RefPtr< Gdk::ContentFormats > > property_paste_target_list () const
 The list of targets this buffer supports for clipboard pasting and as DND destination. More...

 
Glib::PropertyProxy_ReadOnly< bool > property_can_undo () const
 The :can-undo property denotes that the buffer can undo the last applied action. More...

 
Glib::PropertyProxy_ReadOnly< bool > property_can_redo () const
 The :can-redo property denotes that the buffer can reapply the last undone action. More...

 
Glib::PropertyProxy< bool > property_enable_undo ()
 The :enable-undo property denotes if support for undoing and redoing changes to the buffer is allowed. More...

 
Glib::PropertyProxy_ReadOnly< bool > property_enable_undo () const
 The :enable-undo property denotes if support for undoing and redoing changes to the buffer is allowed. More...

 
- Public Member Functions inherited from Glib::Object
 Object (const Object &)=delete
 
Objectoperator= (const Object &)=delete
 
 Object (Object &&src) noexcept
 
Objectoperator= (Object &&src) noexcept
 
void * get_data (const QueryQuark &key)
 
void set_data (const Quark &key, void *data)
 
void set_data (const Quark &key, void *data, DestroyNotify notify)
 
void remove_data (const QueryQuark &quark)
 
void * steal_data (const QueryQuark &quark)
 
Glib::RefPtr< Glib::Objectwrap (GObject *object, bool take_copy=false)
 
- Public Member Functions inherited from Glib::ObjectBase
 ObjectBase (const ObjectBase &)=delete
 
ObjectBaseoperator= (const ObjectBase &)=delete
 
void set_property_value (const Glib::ustring &property_name, const Glib::ValueBase &value)
 
void get_property_value (const Glib::ustring &property_name, Glib::ValueBase &value) const
 
void set_property (const Glib::ustring &property_name, const PropertyType &value)
 
void get_property (const Glib::ustring &property_name, PropertyType &value) const
 
PropertyType get_property (const Glib::ustring &property_name) const
 
sigc::connection connect_property_changed (const Glib::ustring &property_name, const sigc::slot< void()> &slot)
 
sigc::connection connect_property_changed (const Glib::ustring &property_name, sigc::slot< void()> &&slot)
 
void freeze_notify ()
 
void thaw_notify ()
 
virtual void reference () const
 
virtual void unreference () const
 
GObject * gobj ()
 
const GObject * gobj () const
 
GObject * gobj_copy () const
 
- Public Member Functions inherited from sigc::trackable
 trackable () noexcept
 
 trackable (const trackable &src) noexcept
 
 trackable (trackable &&src) noexcept
 
 ~trackable ()
 
void add_destroy_notify_callback (notifiable *data, func_destroy_notify func) const
 
void notify_callbacks ()
 
trackableoperator= (const trackable &src)
 
trackableoperator= (trackable &&src) noexcept
 
void remove_destroy_notify_callback (notifiable *data) const
 

Static Public Member Functions

static GType get_type ()
 Get the GType for this class, for use with the underlying GObject type system. More...

 
static Glib::RefPtr< TextBuffercreate ()
 
static Glib::RefPtr< TextBuffercreate (const Glib::RefPtr< TagTable >& tag_table)
 

Protected Member Functions

 TextBuffer ()
 
 TextBuffer (const Glib::RefPtr< TagTable >& tag_table)
 
virtual void on_insert (TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)
 This is a default handler for the signal signal_insert(). More...

 
virtual void on_insert_paintable (TextBuffer::iterator& pos, const Glib::RefPtr< Gdk::Paintable >& paintable)
 This is a default handler for the signal signal_insert_paintable(). More...

 
virtual void on_insert_child_anchor (TextBuffer::iterator& pos, const Glib::RefPtr< ChildAnchor >& anchor)
 This is a default handler for the signal signal_insert_child_anchor(). More...

 
virtual void on_erase (TextBuffer::iterator& range_start, TextBuffer::iterator& range_end)
 This is a default handler for the signal signal_erase(). More...

 
virtual void on_changed ()
 This is a default handler for the signal signal_changed(). More...

 
virtual void on_modified_changed ()
 This is a default handler for the signal signal_modified_changed(). More...

 
virtual void on_mark_set (const TextBuffer::iterator& location, const Glib::RefPtr< TextBuffer::Mark >& mark)
 This is a default handler for the signal signal_mark_set(). More...

 
virtual void on_mark_deleted (const Glib::RefPtr< TextBuffer::Mark >& mark)
 This is a default handler for the signal signal_mark_deleted(). More...

 
virtual void on_apply_tag (const Glib::RefPtr< TextBuffer::Tag >& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
 This is a default handler for the signal signal_apply_tag(). More...

 
virtual void on_remove_tag (const Glib::RefPtr< TextBuffer::Tag >& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)
 This is a default handler for the signal signal_remove_tag(). More...

 
virtual void on_begin_user_action ()
 This is a default handler for the signal signal_begin_user_action(). More...

 
virtual void on_end_user_action ()
 This is a default handler for the signal signal_end_user_action(). More...

 
virtual void on_paste_done (const Glib::RefPtr< Gdk::Clipboard >& clipboard)
 This is a default handler for the signal signal_paste_done(). More...

 
virtual void on_redo ()
 This is a default handler for the signal signal_redo(). More...

 
virtual void on_undo ()
 This is a default handler for the signal signal_undo(). More...

 
- Protected Member Functions inherited from Glib::Object
 Object ()
 
 Object (const Glib::ConstructParams &construct_params)
 
 Object (GObject *castitem)
 
 ~Object () noexcept override
 
- Protected Member Functions inherited from Glib::ObjectBase
 ObjectBase ()
 
 ObjectBase (const char *custom_type_name)
 
 ObjectBase (const std::type_info &custom_type_info)
 
 ObjectBase (ObjectBase &&src) noexcept
 
ObjectBaseoperator= (ObjectBase &&src) noexcept
 
virtual ~ObjectBase () noexcept=0
 
void initialize (GObject *castitem)
 
void initialize_move (GObject *castitem, Glib::ObjectBase *previous_wrapper)
 

Related Functions

(Note that these are not member functions.)

Glib::RefPtr< Gtk::TextBufferwrap (GtkTextBuffer* object, bool take_copy=false)
 A Glib::wrap() method for this object. More...

 

Detailed Description

Multi-line attributed text that can be displayed by one or more Gtk::TextView widgets.

Text in a buffer can be marked with tags. A Gtk::TextBuffer::Tag is an attribute that can be applied to some range of text. For example, a tag might be called "bold" and make the text inside the tag bold. However, the tag concept is more general than that; tags don't have to affect appearance. They can instead affect the behavior of mouse and key presses, "lock" a range of text so the user can't edit it, or countless other things. A tag is represented by a Gtk::TextBuffer::Tag object. One Gtk::TextBuffer::Tag can be applied to any number of text ranges in any number of Gtk::TextBuffers.

Each tag is stored in a Gtk::TextBuffer::TagTable. A tag table defines a set of tags that can be used together. Each buffer has one tag table associated with it; only tags from that tag table can be used with the buffer. A single tag table can be shared between multiple buffers, however.

Most text manipulation is accomplished with iterators, represented by an iterator or a const_iterator. The iterator can be used to navigate over characters, words, lines, and sentences.

But iterators can't be used to preserve positions across buffer modifications. To preserve a position, the Gtk::TextBuffer::Mark object is ideal. There are two marks built-in to GtkTextBuffer; these are named "insert" and "selection_bound" and refer to the insertion point and the boundary of the selection which is not the insertion point. If no text is selected, these two marks will be in the same position. You can manipulate what is selected and where the cursor appears by moving these marks around.

Text buffers always contain at least one line, but may be empty (that is, buffers can contain zero characters). The last line in the text buffer never ends in a line separator (such as newline); the other lines in the buffer always end in a line separator. Line separators count as characters when computing character counts and character offsets. Note that some Unicode line separators are represented with multiple bytes in UTF-8, and the two-character sequence "\r\n" is also considered a line separator.

Member Typedef Documentation

Constructor & Destructor Documentation

Gtk::TextBuffer::TextBuffer ( TextBuffer&&  src)
noexcept
Gtk::TextBuffer::~TextBuffer ( )
overridenoexcept
Gtk::TextBuffer::TextBuffer ( )
protected
Gtk::TextBuffer::TextBuffer ( const Glib::RefPtr< TagTable >&  tag_table)
explicitprotected

Member Function Documentation

void Gtk::TextBuffer::add_mark ( const Glib::RefPtr< TextBuffer::Mark >&  mark,
const iterator where 
)

Adds the mark at position where.

The mark must not be added to another buffer, and if its name is not nullptr then there must not be another mark in the buffer with the same name.

Emits the Gtk::TextBuffer::signal_mark_set() signal as notification of the mark's initial placement.

Parameters
markThe mark to add.
whereLocation to place mark.
void Gtk::TextBuffer::add_selection_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard)

Adds clipboard to the list of clipboards in which the selection contents of buffer are available.

In most cases, clipboard will be the Gdk::Clipboard returned by gdk_widget_get_primary_clipboard() for a view of buffer.

Parameters
clipboardA Gdk::Clipboard.
void Gtk::TextBuffer::apply_tag ( const Glib::RefPtr< Tag >&  tag,
const iterator range_start,
const iterator range_end 
)

Emits the “apply-tag” signal on buffer.

The default handler for the signal applies tag to the given range. range_start and range_end do not have to be in order.

Parameters
tagA Gtk::TextTag.
range_startOne bound of range to be tagged.
range_endOther bound of range to be tagged.
void Gtk::TextBuffer::apply_tag_by_name ( const Glib::ustring name,
const iterator range_start,
const iterator range_end 
)

Calls Gtk::TextTagTable::lookup() on the buffer’s tag table to get a Gtk::TextTag, then calls apply_tag().

Parameters
nameName of a named Gtk::TextTag.
range_startOne bound of range to be tagged.
range_endOther bound of range to be tagged.
iterator Gtk::TextBuffer::backspace ( const iterator iter,
bool  interactive = true,
bool  default_editable = true 
)

Performs the appropriate action as if the user hit the delete key with the cursor at the position specified by iter.

In the normal case a single character will be deleted, but when combining accents are involved, more than one character can be deleted, and when precomposed character and accent combinations are involved, less than one character will be deleted.

Because the buffer is modified, all outstanding iterators become invalid after calling this method; however, this method returns a valid iterator that points to the location where text was deleted.

Parameters
iterA position in the buffer.
interactiveWhether the deletion is caused by user interaction.
default_editableWhether the buffer is editable by default.
Returns
An iterator to the location where text was deleted, if the buffer was modified.
Since gtkmm 2.6:
iterator Gtk::TextBuffer::begin ( )
const_iterator Gtk::TextBuffer::begin ( ) const
void Gtk::TextBuffer::begin_irreversible_action ( )

Denotes the beginning of an action that may not be undone.

This will cause any previous operations in the undo/redo queue to be cleared.

This should be paired with a call to end_irreversible_action() after the irreversible action has completed.

You may nest calls to begin_irreversible_action() and end_irreversible_action() pairs.

void Gtk::TextBuffer::begin_user_action ( )

Called to indicate that the buffer operations between here and a call to end_user_action() are part of a single user-visible operation.

The operations between begin_user_action() and end_user_action() can then be grouped when creating an undo stack. Gtk::TextBuffer maintains a count of calls to begin_user_action() that have not been closed with a call to end_user_action(), and emits the “begin-user-action” and “end-user-action” signals only for the outermost pair of calls. This allows you to build user actions from other user actions.

The “interactive” buffer mutation functions, such as insert_interactive(), automatically call begin/end user action around the buffer operations they perform, so there's no need to add extra calls if you user action consists solely of a single call to one of those functions.

void Gtk::TextBuffer::copy_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard)

Copies the currently-selected text to a clipboard.

Parameters
clipboardThe Gdk::Clipboard object to copy to.
static Glib::RefPtr<TextBuffer> Gtk::TextBuffer::create ( )
static
static Glib::RefPtr<TextBuffer> Gtk::TextBuffer::create ( const Glib::RefPtr< TagTable >&  tag_table)
static
Glib::RefPtr<ChildAnchor> Gtk::TextBuffer::create_child_anchor ( const iterator pos)
Glib::RefPtr<TextBuffer::Mark> Gtk::TextBuffer::create_mark ( const Glib::ustring mark_name,
const iterator where,
bool  left_gravity = true 
)

Creates a mark at position where.

The mark can be retrieved by name using get_mark(). If a mark has left gravity, and text is inserted at the mark's current location, the mark will be moved to the left of the newly-inserted text. If the mark has right gravity ( left_gravity = false), the mark will end up on the right of newly-inserted text. The standard left-to-right cursor is a mark with right gravity (when you type, the cursor stays on the right side of the text you're typing).

Emits the "mark_set" signal as notification of the mark's initial placement.

Parameters
mark_nameName for mark, or nullptr.
whereLocation to place mark.
left_gravityWhether the mark has left gravity.
Returns
The new Gtk::TextMark object.
Glib::RefPtr<Mark> Gtk::TextBuffer::create_mark ( const iterator where,
bool  left_gravity = true 
)

Create an anonymous mark.

Creates an anonymous mark at position where.

If a mark has left gravity, and text is inserted at the mark's current location, the mark will be moved to the left of the newly-inserted text. If the mark has right gravity ( left_gravity = false), the mark will end up on the right of newly-inserted text. The standard left-to-right cursor is a mark with right gravity (when you type, the cursor stays on the right side of the text you're typing).

Emits the "mark_set" signal as notification of the mark's initial placement.

Parameters
whereLocation to place mark.
left_gravityWhether the mark has left gravity.
Returns
The new Gtk::TextMark object.
Glib::RefPtr<Tag> Gtk::TextBuffer::create_tag ( const Glib::ustring tag_name)

Creates a tag and adds it to the tag table for buffer.

Equivalent to calling Gtk::TextBuffer::Tag::create() and then adding the tag to the buffer's tag table. A tag called tag_name must not already exist in the tag table for this buffer.

Parameters
tag_nameThe name for the new tag.
Returns
The new tag.
Glib::RefPtr<Tag> Gtk::TextBuffer::create_tag ( )

Creates an anoymous tag and adds it to the tag table for buffer.

Equivalent to calling Gtk::TextBuffer::Tag::create() and then adding the tag to the buffer's tag table.

Returns
The new tag.
void Gtk::TextBuffer::cut_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard,
bool  default_editable = true 
)

Copies the currently-selected text to a clipboard, then deletes said text if it’s editable.

Parameters
clipboardThe Gdk::Clipboard object to cut to.
default_editableDefault editability of the buffer.
void Gtk::TextBuffer::delete_mark ( const Glib::RefPtr< Mark >&  mark)

Deletes mark, so that it's no longer located anywhere in the buffer.

Removes the reference the buffer holds to the mark, so if you don't keep a Glib::RefPtr to the mark, it will be freed. Even if the mark isn't freed, most operations on mark become invalid. There is no way to undelete a mark. Gtk::TextMark::get_deleted() will return true after this function has been called on a mark; Gtk::TextMark::get_deleted() indicates that a mark no longer belongs to a buffer. The "mark_deleted" signal will be emitted as notification after the mark is deleted.

Parameters
markA Gtk::TextMark in buffer.
void Gtk::TextBuffer::delete_mark_by_name ( const Glib::ustring name)

Deletes the mark named name; the mark must exist.

See delete_mark() for details.

Parameters
nameName of a mark in buffer.
iterator Gtk::TextBuffer::end ( )
const_iterator Gtk::TextBuffer::end ( ) const
void Gtk::TextBuffer::end_irreversible_action ( )

Denotes the end of an action that may not be undone.

This will cause any previous operations in the undo/redo queue to be cleared.

This should be called after completing modifications to the text buffer after begin_irreversible_action() was called.

You may nest calls to begin_irreversible_action() and end_irreversible_action() pairs.

void Gtk::TextBuffer::end_user_action ( )

Should be paired with a call to begin_user_action().

See that function for a full explanation.

iterator Gtk::TextBuffer::erase ( const iterator range_begin,
const iterator range_end 
)
std::pair<iterator,bool> Gtk::TextBuffer::erase_interactive ( const iterator range_begin,
const iterator range_end,
bool  default_editable = true 
)
bool Gtk::TextBuffer::erase_selection ( bool  interactive = true,
bool  default_editable = true 
)

Deletes the range between the “insert” and “selection_bound” marks, that is, the currently-selected text.

If interactive is true, the editability of the selection will be considered (users can’t delete uneditable text).

Parameters
interactiveWhether the deletion is caused by user interaction.
default_editableWhether the buffer is editable by default.
Returns
Whether there was a non-empty selection to delete.
void Gtk::TextBuffer::get_bounds ( iterator range_begin,
iterator range_end 
)
void Gtk::TextBuffer::get_bounds ( const_iterator range_begin,
const_iterator range_end 
) const
bool Gtk::TextBuffer::get_can_redo ( ) const
bool Gtk::TextBuffer::get_can_undo ( ) const
int Gtk::TextBuffer::get_char_count ( ) const

Gets the number of characters in the buffer; note that characters and bytes are not the same, you can’t e.g. expect the contents of the buffer in string form to be this many bytes long.

The character count is cached, so this function is very fast.

Returns
Number of characters in the buffer.
bool Gtk::TextBuffer::get_enable_undo ( ) const

Gets whether the buffer is saving modifications to the buffer to allow for undo and redo actions.

See begin_irreversible_action() and end_irreversible_action() to create changes to the buffer that cannot be undone.

bool Gtk::TextBuffer::get_has_selection ( ) const

Indicates whether the buffer has some text currently selected.

Returns
true if the there is text selected.
Glib::RefPtr<TextBuffer::Mark> Gtk::TextBuffer::get_insert ( )

Returns the mark that represents the cursor (insertion point).

Equivalent to calling get_mark() to get the mark named “insert”, but very slightly more efficient, and involves less typing.

Returns
Insertion point mark.
iterator Gtk::TextBuffer::get_iter_at_child_anchor ( const Glib::RefPtr< ChildAnchor >&  anchor)

Get the current position of an anchor.

Parameters
anchorA Gtk::TextBuffer::Anchor that appears in the buffer.
Returns
An iterator that points to the position of the anchor.
const_iterator Gtk::TextBuffer::get_iter_at_child_anchor ( const Glib::RefPtr< ChildAnchor >&  anchor) const

Get the current position of an anchor.

Parameters
anchorA Gtk::TextBuffer::Anchor that appears in the buffer.
Returns
An iterator that points to the position of the anchor.
iterator Gtk::TextBuffer::get_iter_at_line ( int  line_number)
const_iterator Gtk::TextBuffer::get_iter_at_line ( int  line_number) const
iterator Gtk::TextBuffer::get_iter_at_line_index ( int  line_number,
int  byte_index 
)
const_iterator Gtk::TextBuffer::get_iter_at_line_index ( int  line_number,
int  byte_index 
) const
iterator Gtk::TextBuffer::get_iter_at_line_offset ( int  line_number,
int  char_offset 
)
const_iterator Gtk::TextBuffer::get_iter_at_line_offset ( int  line_number,
int  char_offset 
) const
iterator Gtk::TextBuffer::get_iter_at_mark ( const Glib::RefPtr< Mark >&  mark)

Get the current position of a mark.

Parameters
markThe Gtk::TextBuffer::Mark
Returns
An iterator that points to the position of the mark.
const_iterator Gtk::TextBuffer::get_iter_at_mark ( const Glib::RefPtr< Mark >&  mark) const

Get the current position of a mark.

Parameters
markThe Gtk::TextBuffer::Mark
Returns
An iterator that points to the position of the mark.
iterator Gtk::TextBuffer::get_iter_at_offset ( int  char_offset)
const_iterator Gtk::TextBuffer::get_iter_at_offset ( int  char_offset) const
int Gtk::TextBuffer::get_line_count ( ) const

Obtains the number of lines in the buffer.

This value is cached, so the function is very fast.

Returns
Number of lines in the buffer.
Glib::RefPtr<TextBuffer::Mark> Gtk::TextBuffer::get_mark ( const Glib::ustring name)

Returns the mark named name in buffer buffer, or nullptr if no such mark exists in the buffer.

Parameters
nameA mark name.
Returns
A Gtk::TextMark, or nullptr.
Glib::RefPtr<const TextBuffer::Mark> Gtk::TextBuffer::get_mark ( const Glib::ustring name) const

Returns the mark named name in buffer buffer, or nullptr if no such mark exists in the buffer.

Parameters
nameA mark name.
Returns
A Gtk::TextMark, or nullptr.
guint Gtk::TextBuffer::get_max_undo_levels ( ) const

Gets the maximum number of undo levels to perform.

If 0, unlimited undo actions may be performed. Note that this may have a memory usage impact as it requires storing an additional copy of the inserted or removed text within the text buffer.

bool Gtk::TextBuffer::get_modified ( ) const

Indicates whether the buffer has been modified since the last call to set_modified() set the modification flag to false.

Used for example to enable a “save” function in a text editor.

Returns
true if the buffer has been modified.
Glib::RefPtr<TextBuffer::Mark> Gtk::TextBuffer::get_selection_bound ( )

Returns the mark that represents the selection bound.

Equivalent to calling get_mark() to get the mark named “selection_bound”, but very slightly more efficient, and involves less typing.

The currently-selected text in buffer is the region between the “selection_bound” and “insert” marks. If “selection_bound” and “insert” are in the same place, then there is no current selection. get_selection_bounds() is another convenient function for handling the selection, if you just want to know whether there’s a selection and what its bounds are.

Returns
Selection bound mark.
bool Gtk::TextBuffer::get_selection_bounds ( iterator range_start,
iterator range_end 
)

Returns true if some text is selected; places the bounds of the selection in range_start and range_end (if the selection has length 0, then range_start and range_end are filled in with the same value).

range_start and range_end will be in ascending order. If range_start and range_end are nullptr, then they are not filled in, but the return value still indicates whether text is selected.

Parameters
range_startIterator to initialize with selection start.
range_endIterator to initialize with selection end.
Returns
Whether the selection has nonzero length.
bool Gtk::TextBuffer::get_selection_bounds ( const_iterator range_start,
const_iterator range_end 
) const

Returns true if some text is selected; places the bounds of the selection in range_start and range_end (if the selection has length 0, then range_start and range_end are filled in with the same value).

range_start and range_end will be in ascending order. If range_start and range_end are nullptr, then they are not filled in, but the return value still indicates whether text is selected.

Parameters
range_startIterator to initialize with selection start.
range_endIterator to initialize with selection end.
Returns
Whether the selection has nonzero length.
Glib::RefPtr<Gdk::ContentProvider> Gtk::TextBuffer::get_selection_content ( )

Get a content provider for this buffer.

Returns
A new Gdk::ContentProvider.
Glib::ustring Gtk::TextBuffer::get_slice ( const const_iterator range_start,
const const_iterator range_end,
bool  include_hidden_chars = true 
) const

Returns the text in the range [ range_start, range_end).

Excludes undisplayed text (text marked with tags that set the invisibility attribute) if include_hidden_chars is false. The returned string includes a 0xFFFC character whenever the buffer contains embedded images, so byte and character indexes into the returned string do correspond to byte and character indexes into the buffer. Contrast with get_text(). Note that 0xFFFC can occur in normal text as well, so it is not a reliable indicator that a paintable or widget is in the buffer.

Parameters
range_startStart of a range.
range_endEnd of a range.
include_hidden_charsWhether to include invisible text.
Returns
An allocated UTF-8 string.
Glib::RefPtr<TextBuffer::TagTable> Gtk::TextBuffer::get_tag_table ( )

Get the Gtk::TextTagTable associated with this buffer.

Returns
The buffer’s tag table.
Glib::RefPtr<const TextBuffer::TagTable> Gtk::TextBuffer::get_tag_table ( ) const

Get the Gtk::TextTagTable associated with this buffer.

Returns
The buffer’s tag table.
Glib::ustring Gtk::TextBuffer::get_text ( const const_iterator range_start,
const const_iterator range_end,
bool  include_hidden_chars = true 
) const

Returns the text in the range [ range_start, range_end).

Excludes undisplayed text (text marked with tags that set the invisibility attribute) if include_hidden_chars is false. Does not include characters representing embedded images, so byte and character indexes into the returned string do not correspond to byte and character indexes into the buffer. Contrast with get_slice().

Parameters
range_startStart of a range.
range_endEnd of a range.
include_hidden_charsWhether to include invisible text.
Returns
An allocated UTF-8 string.
Glib::ustring Gtk::TextBuffer::get_text ( bool  include_hidden_chars = true) const

Returns all the text in the buffer.

Excludes undisplayed text (text marked with tags that set the invisibility attribute) if include_hidden_chars is false. Does not include characters representing embedded images, so byte and character indexes into the returned string do not correspond to byte and character indexes into the buffer. Contrast with get_slice().

Parameters
include_hidden_charsWhether to include invisible text.
Returns
An allocated UTF-8 string.
static GType Gtk::TextBuffer::get_type ( )
static

Get the GType for this class, for use with the underlying GObject type system.

GtkTextBuffer* Gtk::TextBuffer::gobj ( )
inline

Provides access to the underlying C GObject.

const GtkTextBuffer* Gtk::TextBuffer::gobj ( ) const
inline

Provides access to the underlying C GObject.

GtkTextBuffer* Gtk::TextBuffer::gobj_copy ( )

Provides access to the underlying C instance. The caller is responsible for unrefing it. Use when directly setting fields in structs.

iterator Gtk::TextBuffer::insert ( const iterator pos,
const Glib::ustring text 
)

Inserts text at position pos.

Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal. The pos iterator is invalidated when insertion occurs (because the buffer contents change).

Parameters
posAn iterator pointing to the position at which the text should be inserted.
textThe text to be inserted in the buffer.
Returns
An iterator that points to the end of the inserted text.
iterator Gtk::TextBuffer::insert ( const iterator pos,
const char *  text_begin,
const char *  text_end 
)

Inserts text at position pos.

Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal. The pos iterator is invalidated when insertion occurs (because the buffer contents change).

Parameters
posAn iterator pointing to the position at which the text should be inserted.
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
Returns
An iterator that points to the end of the inserted text.
iterator Gtk::TextBuffer::insert ( const iterator pos,
const const_iterator range_begin,
const const_iterator range_end 
)

Copies text, tags, and paintable between range_begin and range_end (the order of range_begin and range_begin doesn't matter) and inserts the copy at pos.

Used instead of simply getting/inserting text because it preserves images and tags. If range_begin and range_end are in a different buffer, the two buffers must share the same tag table.

Implemented via emissions of the insert_text and apply_tag signals, so expect those.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
range_beginA position in a buffer.
range_endAnother position in the same buffer as range_begin.
Returns
Whether text was actually inserted
void Gtk::TextBuffer::insert_at_cursor ( const Glib::ustring text)

Inserts text, using the current cursor position as the insertion point.

Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.

Parameters
textThe text to be inserted in the buffer.
void Gtk::TextBuffer::insert_at_cursor ( const char *  text_begin,
const char *  text_end 
)

Inserts text, using the current cursor position as the insertion point.

Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal.

Parameters
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
iterator Gtk::TextBuffer::insert_child_anchor ( const iterator pos,
const Glib::RefPtr< ChildAnchor >&  anchor 
)
std::pair<iterator,bool> Gtk::TextBuffer::insert_interactive ( const iterator pos,
const Glib::ustring text,
bool  default_editable = true 
)

Like insert(), but the insertion will not occur if iter is at a non-editable location in the buffer.

Usually you want to prevent insertions at ineditable locations if the insertion results from a user action (is interactive).

default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of Gtk::TextView::get_editable() is appropriate here.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
textThe text to be inserted in the buffer.
default_editableDefault editability of buffer
Returns
Whether text was actually inserted
std::pair<iterator,bool> Gtk::TextBuffer::insert_interactive ( const iterator pos,
const char *  text_begin,
const char *  text_end,
bool  default_editable = true 
)

Like insert(), but the insertion will not occur if pos is at a non-editable location in the buffer.

Usually you want to prevent insertions at ineditable locations if the insertion results from a user action (is interactive).

default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of Gtk::TextView::get_editable() is appropriate here.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
default_editableDefault editability of buffer.
Returns
Whether text was actually inserted
std::pair<iterator,bool> Gtk::TextBuffer::insert_interactive ( const iterator pos,
const const_iterator range_begin,
const const_iterator range_end,
bool  default_editable = true 
)

Same as insert_range(), but does nothing if the insertion point isn't editable.

The default_editable parameter indicates whether the text is editable at pos if no tags enclosing pos affect editability. Typically the result of Gtk::TextView::get_editable() is appropriate here.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
range_beginA position in a buffer.
range_endAnother position in the same buffer as range_begin.
default_editableDefault editability of buffer.
Returns
Whether text was actually inserted
bool Gtk::TextBuffer::insert_interactive_at_cursor ( const Glib::ustring text,
bool  default_editable = true 
)

Calls insert_interactive() at the cursor position.

default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of Gtk::TextView::get_editable() is appropriate here.

Parameters
textThe text to be inserted in the buffer.
default_editableDefault editability of buffer
Returns
Whether text was actually inserted
bool Gtk::TextBuffer::insert_interactive_at_cursor ( const char *  text_begin,
const char *  text_end,
bool  default_editable = true 
)

Calls insert_interactive() at the cursor position.

default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of Gtk::TextView::get_editable() is appropriate here.

Parameters
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
default_editableDefault editability of buffer
Returns
Whether text was actually inserted
iterator Gtk::TextBuffer::insert_markup ( const iterator pos,
const Glib::ustring markup 
)

Inserts text in markup at position pos.

Emits the "insert_text" signal, possibly multiple times; insertion actually occurs in the default handler for the signal. The pos iterator will point to the end of the inserted text on return.

Parameters
posLocation to insert the markup.
markupThe text containing pango markup to be inserted in the buffer.
Returns
An iterator that points to the end of the inserted markup text.
iterator Gtk::TextBuffer::insert_markup ( const iterator pos,
const char *  markup_begin,
const char *  markup_end 
)

Inserts markup text at position pos.

Emits the "insert_text" signal; insertion actually occurs in the default handler for the signal. The pos iterator will point to the end of the inserted text on return.

Parameters
posLocation to insert the markup.
markup_beginThe start of a UTF8 character array containing pango markup.
markup_endThe end of the UTF8 character array containing pango markup.
Returns
An iterator that points to the end of the inserted markup text.
iterator Gtk::TextBuffer::insert_paintable ( const iterator pos,
const Glib::RefPtr< Gdk::Paintable >&  paintable 
)
iterator Gtk::TextBuffer::insert_with_tag ( const iterator pos,
const Glib::ustring text,
const Glib::RefPtr< Tag >&  tag 
)
iterator Gtk::TextBuffer::insert_with_tag ( const iterator pos,
const char *  text_begin,
const char *  text_end,
const Glib::RefPtr< Tag >&  tag 
)
iterator Gtk::TextBuffer::insert_with_tag ( const iterator pos,
const Glib::ustring text,
const Glib::ustring tag_name 
)
iterator Gtk::TextBuffer::insert_with_tag ( const iterator pos,
const char *  text_begin,
const char *  text_end,
const Glib::ustring tag_name 
)
iterator Gtk::TextBuffer::insert_with_tags ( const iterator pos,
const Glib::ustring text,
const std::vector< Glib::RefPtr< Tag > >&  tags 
)

Inserts text into buffer at pos, applying the list of tags to the newly-inserted text.

Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
textThe text to be inserted in the buffer.
tagsA standard C++ container of Gtk::TextBuffer::Tags.
Returns
Whether text was actually inserted
iterator Gtk::TextBuffer::insert_with_tags ( const iterator pos,
const char *  text_begin,
const char *  text_end,
const std::vector< Glib::RefPtr< Tag > >&  tags 
)

Inserts text into buffer at pos, applying the list of tags to the newly-inserted text.

Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
tagsA standard C++ container of Gtk::TextBuffer::Tags.
Returns
Whether text was actually inserted
iterator Gtk::TextBuffer::insert_with_tags_by_name ( const iterator pos,
const Glib::ustring text,
const std::vector< Glib::ustring > &  tag_names 
)

Inserts text into buffer at pos, applying the list of tags to the newly-inserted text.

Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
textThe text to be inserted in the buffer.
tag_namesA standard C++ container of tag names.
Returns
Whether text was actually inserted
iterator Gtk::TextBuffer::insert_with_tags_by_name ( const iterator pos,
const char *  text_begin,
const char *  text_end,
const std::vector< Glib::ustring > &  tag_names 
)

Equivalent to calling insert(), then apply_tag() on the inserted text; This is just a convenience function.

Parameters
posAn iterator pointing to the position at which the text should be inserted.
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
tag_namesA standard C++ container of tag names.
Returns
Whether text was actually inserted
void Gtk::TextBuffer::move_mark ( const Glib::RefPtr< Mark >&  mark,
const iterator where 
)

Moves mark to the new location where.

Emits the Gtk::TextBuffer::signal_mark_set() signal as notification of the move.

Parameters
markA Gtk::TextMark.
whereNew location for mark in buffer.
void Gtk::TextBuffer::move_mark_by_name ( const Glib::ustring name,
const iterator where 
)

Moves the mark named name (which must exist) to location where.

See move_mark() for details.

Parameters
nameName of a mark.
whereNew location for mark.
virtual void Gtk::TextBuffer::on_apply_tag ( const Glib::RefPtr< TextBuffer::Tag >&  tag,
const TextBuffer::iterator range_begin,
const TextBuffer::iterator range_end 
)
protectedvirtual

This is a default handler for the signal signal_apply_tag().

virtual void Gtk::TextBuffer::on_begin_user_action ( )
protectedvirtual

This is a default handler for the signal signal_begin_user_action().

virtual void Gtk::TextBuffer::on_changed ( )
protectedvirtual

This is a default handler for the signal signal_changed().

virtual void Gtk::TextBuffer::on_end_user_action ( )
protectedvirtual

This is a default handler for the signal signal_end_user_action().

virtual void Gtk::TextBuffer::on_erase ( TextBuffer::iterator range_start,
TextBuffer::iterator range_end 
)
protectedvirtual

This is a default handler for the signal signal_erase().

virtual void Gtk::TextBuffer::on_insert ( TextBuffer::iterator pos,
const Glib::ustring text,
int  bytes 
)
protectedvirtual

This is a default handler for the signal signal_insert().

virtual void Gtk::TextBuffer::on_insert_child_anchor ( TextBuffer::iterator pos,
const Glib::RefPtr< ChildAnchor >&  anchor 
)
protectedvirtual

This is a default handler for the signal signal_insert_child_anchor().

virtual void Gtk::TextBuffer::on_insert_paintable ( TextBuffer::iterator pos,
const Glib::RefPtr< Gdk::Paintable >&  paintable 
)
protectedvirtual

This is a default handler for the signal signal_insert_paintable().

virtual void Gtk::TextBuffer::on_mark_deleted ( const Glib::RefPtr< TextBuffer::Mark >&  mark)
protectedvirtual

This is a default handler for the signal signal_mark_deleted().

virtual void Gtk::TextBuffer::on_mark_set ( const TextBuffer::iterator location,
const Glib::RefPtr< TextBuffer::Mark >&  mark 
)
protectedvirtual

This is a default handler for the signal signal_mark_set().

virtual void Gtk::TextBuffer::on_modified_changed ( )
protectedvirtual

This is a default handler for the signal signal_modified_changed().

virtual void Gtk::TextBuffer::on_paste_done ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard)
protectedvirtual

This is a default handler for the signal signal_paste_done().

virtual void Gtk::TextBuffer::on_redo ( )
protectedvirtual

This is a default handler for the signal signal_redo().

virtual void Gtk::TextBuffer::on_remove_tag ( const Glib::RefPtr< TextBuffer::Tag >&  tag,
const TextBuffer::iterator range_begin,
const TextBuffer::iterator range_end 
)
protectedvirtual

This is a default handler for the signal signal_remove_tag().

virtual void Gtk::TextBuffer::on_undo ( )
protectedvirtual

This is a default handler for the signal signal_undo().

TextBuffer& Gtk::TextBuffer::operator= ( TextBuffer&&  src)
noexcept
void Gtk::TextBuffer::paste_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard,
const iterator override_location,
bool  default_editable = true 
)

Pastes the contents of a clipboard.

If override_location is nullptr, the pasted text will be inserted at the cursor position, or the buffer selection will be replaced if the selection is non-empty.

Note
pasting is asynchronous, that is, we’ll ask for the paste data and return, and at some point later after the main loop runs, the paste data will be inserted.
Parameters
clipboardThe Gdk::Clipboard to paste from.
override_locationLocation to insert pasted text, or nullptr.
default_editableWhether the buffer is editable by default.
void Gtk::TextBuffer::paste_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard,
bool  default_editable = true 
)

A paste_clipboard() convenience overload.

void Gtk::TextBuffer::place_cursor ( const iterator where)

This function moves the “insert” and “selection_bound” marks simultaneously.

If you move them to the same place in two steps with move_mark(), you will temporarily select a region in between their old and new locations, which can be pretty inefficient since the temporarily-selected region will force stuff to be recalculated. This function moves them as a unit, which can be optimized.

Parameters
whereWhere to put the cursor.
Glib::PropertyProxy_ReadOnly< bool > Gtk::TextBuffer::property_can_redo ( ) const

The :can-redo property denotes that the buffer can reapply the last undone action.

Default value: false

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< bool > Gtk::TextBuffer::property_can_undo ( ) const

The :can-undo property denotes that the buffer can undo the last applied action.

Default value: false

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::ContentFormats> > Gtk::TextBuffer::property_copy_target_list ( ) const

The list of targets this buffer supports for clipboard copying and as DND source.

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< int > Gtk::TextBuffer::property_cursor_position ( ) const

The position of the insert mark (as offset from the beginning of the buffer).

It is useful for getting notified when the cursor moves.

Default value: 0

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy< bool > Gtk::TextBuffer::property_enable_undo ( )

The :enable-undo property denotes if support for undoing and redoing changes to the buffer is allowed.

Default value: true

Returns
A PropertyProxy that allows you to get or set the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< bool > Gtk::TextBuffer::property_enable_undo ( ) const

The :enable-undo property denotes if support for undoing and redoing changes to the buffer is allowed.

Default value: true

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< bool > Gtk::TextBuffer::property_has_selection ( ) const

Whether the buffer has some text currently selected.

Default value: false

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< Glib::RefPtr<Gdk::ContentFormats> > Gtk::TextBuffer::property_paste_target_list ( ) const

The list of targets this buffer supports for clipboard pasting and as DND destination.

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< Glib::RefPtr<TextBuffer::TagTable> > Gtk::TextBuffer::property_tag_table ( ) const

Text Tag Table.

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy< Glib::ustring > Gtk::TextBuffer::property_text ( )

The text content of the buffer.

Without child widgets and images, see Gtk::TextBuffer::get_text() for more information.

Default value: ""

Returns
A PropertyProxy that allows you to get or set the value of the property, or receive notification when the value of the property changes.
Glib::PropertyProxy_ReadOnly< Glib::ustring > Gtk::TextBuffer::property_text ( ) const

The text content of the buffer.

Without child widgets and images, see Gtk::TextBuffer::get_text() for more information.

Default value: ""

Returns
A PropertyProxy_ReadOnly that allows you to get the value of the property, or receive notification when the value of the property changes.
void Gtk::TextBuffer::redo ( )

Redoes the next redoable action on the buffer, if there is one.

void Gtk::TextBuffer::remove_all_tags ( const iterator range_start,
const iterator range_end 
)

Removes all tags in the range between range_start and range_end.

Be careful with this function; it could remove tags added in code unrelated to the code you’re currently writing. That is, using this function is probably a bad idea if you have two or more unrelated code sections that add tags.

Parameters
range_startOne bound of range to be untagged.
range_endOther bound of range to be untagged.
void Gtk::TextBuffer::remove_selection_clipboard ( const Glib::RefPtr< Gdk::Clipboard >&  clipboard)

Removes a Gdk::Clipboard added with add_selection_clipboard().

Parameters
clipboardA Gdk::Clipboard added to buffer by add_selection_clipboard().
void Gtk::TextBuffer::remove_tag ( const Glib::RefPtr< Tag >&  tag,
const iterator range_start,
const iterator range_end 
)

Emits the “remove-tag” signal.

The default handler for the signal removes all occurrences of tag from the given range. range_start and range_end don’t have to be in order.

Parameters
tagA Gtk::TextTag.
range_startOne bound of range to be untagged.
range_endOther bound of range to be untagged.
void Gtk::TextBuffer::remove_tag_by_name ( const Glib::ustring name,
const iterator range_start,
const iterator range_end 
)

Calls Gtk::TextTagTable::lookup() on the buffer’s tag table to get a Gtk::TextTag, then calls remove_tag().

Parameters
nameName of a Gtk::TextTag.
range_startOne bound of range to be untagged.
range_endOther bound of range to be untagged.
void Gtk::TextBuffer::select_range ( const iterator ins,
const iterator bound 
)

This function moves the “insert” and “selection_bound” marks simultaneously.

If you move them in two steps with move_mark(), you will temporarily select a region in between their old and new locations, which can be pretty inefficient since the temporarily-selected region will force stuff to be recalculated. This function moves them as a unit, which can be optimized.

Parameters
insWhere to put the “insert” mark.
boundWhere to put the “selection_bound” mark.
void Gtk::TextBuffer::set_enable_undo ( bool  enable_undo = true)

Sets whether or not to enable undoable actions in the text buffer.

If enabled, the user will be able to undo the last number of actions up to get_max_undo_levels().

See begin_irreversible_action() and end_irreversible_action() to create changes to the buffer that cannot be undone.

Parameters
enable_undotrue to enable undoable actions.
void Gtk::TextBuffer::set_max_undo_levels ( guint  max_undo_levels)

Sets the maximum number of undo levels to perform.

If 0, unlimited undo actions may be performed. Note that this may have a memory usage impact as it requires storing an additional copy of the inserted or removed text within the text buffer.

Parameters
max_undo_levelsThe maximum number of undo actions to perform.
void Gtk::TextBuffer::set_modified ( bool  setting = true)

Used to keep track of whether the buffer has been modified since the last time it was saved.

Whenever the buffer is saved to disk, call gtk_text_buffer_set_modified ( buffer, false). When the buffer is modified, it will automatically toggled on the modified bit again. When the modified bit flips, the buffer emits the Gtk::TextBuffer::signal_modified_changed() signal.

Parameters
settingModification flag setting.
void Gtk::TextBuffer::set_text ( const Glib::ustring text)

Removes the current contents of the buffer, and inserts text instead.

Parameters
textThe text to put in the buffer.
void Gtk::TextBuffer::set_text ( const char *  text_begin,
const char *  text_end 
)

Removes the current contents of the buffer, and inserts text instead.

Parameters
text_beginThe start of a UTF8 character array.
text_endThe end of the UTF8 character array.
Glib::SignalProxy<void(const Glib::RefPtr<TextBuffer::Tag>&, const TextBuffer::iterator&, const TextBuffer::iterator&)> Gtk::TextBuffer::signal_apply_tag ( )
Slot Prototype:
void on_my_apply_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)

Flags: Run Last

The signal_apply_tag() signal is emitted to apply a tag to a range of text in a Gtk::TextBuffer. Applying actually occurs in the default handler.

Note that if your handler runs before the default handler it must not invalidate the range_begin and range_end iters (or has to revalidate them).

See also: Gtk::TextBuffer::apply_tag(), Gtk::TextBuffer::insert_with_tags(), Gtk::TextBuffer::insert_range().

Parameters
tagThe applied tag.
range_beginThe start of the range the tag is applied to.
range_endThe end of the range the tag is applied to.
Glib::SignalProxy<void()> Gtk::TextBuffer::signal_begin_user_action ( )
Slot Prototype:
void on_my_begin_user_action()

Flags: Run Last

The signal_begin_user_action() signal is emitted at the beginning of a single user-visible operation on a Gtk::TextBuffer.

See also: Gtk::TextBuffer::begin_user_action(), Gtk::TextBuffer::insert_interactive(), Gtk::TextBuffer::insert_range_interactive(), Gtk::TextBuffer::delete_interactive(), Gtk::TextBuffer::backspace(), Gtk::TextBuffer::delete_selection().

Glib::SignalProxy<void()> Gtk::TextBuffer::signal_changed ( )
Slot Prototype:
void on_my_changed()

Flags: Run Last

The signal_changed() signal is emitted when the content of a Gtk::TextBuffer has changed.

Glib::SignalProxy<void()> Gtk::TextBuffer::signal_end_user_action ( )
Slot Prototype:
void on_my_end_user_action()

Flags: Run Last

The signal_end_user_action() signal is emitted at the end of a single user-visible operation on the Gtk::TextBuffer.

See also: Gtk::TextBuffer::end_user_action(), Gtk::TextBuffer::insert_interactive(), Gtk::TextBuffer::insert_range_interactive(), Gtk::TextBuffer::delete_interactive(), Gtk::TextBuffer::backspace(), Gtk::TextBuffer::delete_selection(), Gtk::TextBuffer::backspace().

Glib::SignalProxy<void(TextBuffer::iterator&, TextBuffer::iterator&)> Gtk::TextBuffer::signal_erase ( )
Slot Prototype:
void on_my_erase(TextBuffer::iterator& range_start, TextBuffer::iterator& range_end)

Flags: Run Last

The signal_delete_range() signal is emitted to delete a range from a Gtk::TextBuffer.

Note that if your handler runs before the default handler it must not invalidate the range_start and range_end iters (or has to revalidate them). The default signal handler revalidates the range_start and range_end iters to both point to the location where text was deleted. Handlers which run after the default handler (see Glib::signal_connect_after()) do not have access to the deleted text.

See also: Gtk::TextBuffer::delete().

Parameters
range_startThe start of the range to be deleted.
range_endThe end of the range to be deleted.
Glib::SignalProxy<void(TextBuffer::iterator&, const Glib::ustring&, int)> Gtk::TextBuffer::signal_insert ( )
Slot Prototype:
void on_my_insert(TextBuffer::iterator& pos, const Glib::ustring& text, int bytes)

Flags: Run Last

The signal_insert_text() signal is emitted to insert text in a Gtk::TextBuffer. Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must not invalidate the pos iter (or has to revalidate it). The default signal handler revalidates it to point to the end of the inserted text.

See also: Gtk::TextBuffer::insert(), Gtk::TextBuffer::insert_range().

Parameters
posPosition to insert text in textbuffer.
textThe UTF-8 text to be inserted.
bytesLength of the inserted text in bytes.
Glib::SignalProxy<void(TextBuffer::iterator&, const Glib::RefPtr<ChildAnchor>&)> Gtk::TextBuffer::signal_insert_child_anchor ( )
Slot Prototype:
void on_my_insert_child_anchor(TextBuffer::iterator& pos, const Glib::RefPtr<ChildAnchor>& anchor)

Flags: Run Last

The signal_insert_child_anchor() signal is emitted to insert a Gtk::TextChildAnchor in a Gtk::TextBuffer. Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must not invalidate the pos iter (or has to revalidate it). The default signal handler revalidates it to be placed after the inserted anchor.

See also: Gtk::TextBuffer::insert_child_anchor().

Parameters
posPosition to insert anchor in textbuffer.
anchorThe Gtk::TextChildAnchor to be inserted.
Glib::SignalProxy<void(TextBuffer::iterator&, const Glib::RefPtr<Gdk::Paintable>&)> Gtk::TextBuffer::signal_insert_paintable ( )
Slot Prototype:
void on_my_insert_paintable(TextBuffer::iterator& pos, const Glib::RefPtr<Gdk::Paintable>& paintable)

Flags: Run Last

The signal_insert_paintable() signal is emitted to insert a Gdk::Paintable in a Gtk::TextBuffer. Insertion actually occurs in the default handler.

Note that if your handler runs before the default handler it must not invalidate the pos iter (or has to revalidate it). The default signal handler revalidates it to be placed after the inserted paintable.

See also: Gtk::TextBuffer::insert_paintable().

Parameters
posPosition to insert paintable in textbuffer.
paintableThe Gdk::Paintable to be inserted.
Glib::SignalProxy<void(const Glib::RefPtr<TextBuffer::Mark>&)> Gtk::TextBuffer::signal_mark_deleted ( )
Slot Prototype:
void on_my_mark_deleted(const Glib::RefPtr<TextBuffer::Mark>& mark)

Flags: Run Last

The signal_mark_deleted() signal is emitted as notification after a Gtk::TextMark is deleted.

See also: Gtk::TextBuffer::delete_mark().

Parameters
markThe mark that was deleted.
Glib::SignalProxy<void(const TextBuffer::iterator&, const Glib::RefPtr<TextBuffer::Mark>&)> Gtk::TextBuffer::signal_mark_set ( )
Slot Prototype:
void on_my_mark_set(const TextBuffer::iterator& location, const Glib::RefPtr<TextBuffer::Mark>& mark)

Flags: Run Last

The signal_mark_set() signal is emitted as notification after a Gtk::TextMark is set.

See also: Gtk::TextBuffer::create_mark(), Gtk::TextBuffer::move_mark().

Parameters
locationThe location of mark in textbuffer.
markThe mark that is set.
Glib::SignalProxy<void()> Gtk::TextBuffer::signal_modified_changed ( )
Slot Prototype:
void on_my_modified_changed()

Flags: Run Last

The signal_modified_changed() signal is emitted when the modified bit of a Gtk::TextBuffer flips.

See also: Gtk::TextBuffer::set_modified().

Glib::SignalProxy<void(const Glib::RefPtr<Gdk::Clipboard>&)> Gtk::TextBuffer::signal_paste_done ( )
Slot Prototype:
void on_my_paste_done(const Glib::RefPtr<Gdk::Clipboard>& clipboard)

Flags: Run Last

The paste-done signal is emitted after paste operation has been completed. This is useful to properly scroll the view to the end of the pasted text. See Gtk::TextBuffer::paste_clipboard() for more details.

Parameters
clipboardThe Gdk::Clipboard pasted from.
Glib::SignalProxy<void()> Gtk::TextBuffer::signal_redo ( )
Slot Prototype:
void on_my_redo()

Flags: Run Last

The "redo" signal is emitted when a request has been made to redo the previously undone operation.

Glib::SignalProxy<void(const Glib::RefPtr<TextBuffer::Tag>&, const TextBuffer::iterator&, const TextBuffer::iterator&)> Gtk::TextBuffer::signal_remove_tag ( )
Slot Prototype:
void on_my_remove_tag(const Glib::RefPtr<TextBuffer::Tag>& tag, const TextBuffer::iterator& range_begin, const TextBuffer::iterator& range_end)

Flags: Run Last

The signal_remove_tag() signal is emitted to remove all occurrences of tag from a range of text in a Gtk::TextBuffer. Removal actually occurs in the default handler.

Note that if your handler runs before the default handler it must not invalidate the range_begin and range_end iters (or has to revalidate them).

See also: Gtk::TextBuffer::remove_tag().

Parameters
tagThe tag to be removed.
range_beginThe start of the range the tag is removed from.
range_endThe end of the range the tag is removed from.
Glib::SignalProxy<void()> Gtk::TextBuffer::signal_undo ( )
Slot Prototype:
void on_my_undo()

Flags: Run Last

The "undo" signal is emitted when a request has been made to undo the previous operation or set of operations that have been grouped together.

int Gtk::TextBuffer::size ( ) const
void Gtk::TextBuffer::undo ( )

Undoes the last undoable action on the buffer, if there is one.

Friends And Related Function Documentation

Glib::RefPtr< Gtk::TextBuffer > wrap ( GtkTextBuffer *  object,
bool  take_copy = false 
)
related

A Glib::wrap() method for this object.

Parameters
objectThe C instance.
take_copyFalse if the result should take ownership of the C instance. True if it should take a new copy or ref.
Returns
A C++ instance that wraps this C instance.