gtk.TextBuffer.get_line_count

    def get_line_count()

The get_line_count() method returns the number of lines in the buffer. This value is cached, so the function is very fast.

gtk.TextBuffer.get_char_count

    def get_char_count()

The get_char_count() method returns 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.

gtk.TextBuffer.get_tag_table

    def get_tag_table()

The get_tag_table() method returns the gtk.TextTagTable object associated with the textbuffer.

gtk.TextBuffer.set_text

    def set_text(text)

The set_text() method replaces the current contents of the textbuffer with the contents of text. text must be valid UTF-8.

gtk.TextBuffer.insert

    def insert(iter, text)

The insert() method inserts the contents of text into the textbuffer at the position specified by iter. The "insert_text" signal is emitted and the text insertion actually occurs in the default handler for the signal. iter is invalidated when insertion occurs (because the buffer contents change), but the default signal handler revalidates it to point to the end of the inserted text.

gtk.TextBuffer.insert_at_cursor

    def insert_at_cursor(text)

The insert_at_cursor() method is a convenience method that calls the insert() method, using the current cursor position as the insertion point.

gtk.TextBuffer.insert_interactive

    def insert_interactive(iter, text, default_editable)

The insert_interactive() method is similar to the insert() method, except the insertion of text at iter will not occur if iter is at a non-editable location in the buffer. A location is non-editable if a gtk.TextTag applied at that location has its "editable" attribute set to FALSE or the gtk.TextView used by the user is set non-editable. Usually you want to prevent insertions at 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 the gtk.TextView.get_editable() method is appropriate here.

gtk.TextBuffer.insert_interactive_at_cursor

    def insert_interactive_at_cursor(text, default_editable)

The insert_interactive_at_cursor() method calls the insert_interactive() method to insert text at the cursor (insert) position. default_editable indicates the editability of text that doesn't have a tag affecting editability applied to it. Typically the result of the gtk.TextView.get_editable() method is appropriate here.

gtk.TextBuffer.insert_range

    def insert_range(iter, start, end)

The insert_range() method copies text, tags, and pixbufs (but not child anchors) between start and end (the order of start and end doesn't matter) form a gtk.TextBuffer and inserts the copy at iter. Used instead of simply getting/inserting text because it preserves images and tags. If start and end are in a different buffer from buffer, the two buffers must share the same tag table. This method is implemented via emissions of the "insert_text" and "apply_tag" signals.

gtk.TextBuffer.insert_range_interactive

    def insert_range_interactive(iter, start, end, default_editable)

The insert_range_interactive() method is similar to the insert_range() method, except the insertion of text at iter will not occur if the insertion position is non-editable. A location is non-editable if a gtk.TextTag applied at that location has its "editable" attribute set to FALSE or the gtk.TextView used by the user is set non-editable. The default_editable parameter indicates whether the text is editable at iter if no tags enclosing iter affect editability. Typically the result of the gtk.TextView.get_editable() method is appropriate here.

gtk.TextBuffer.insert_with_tags

    def insert_with_tags(iter, text, ...)

The insert_with_tags() method inserts the specified text into the textbuffer at the location specified by iter, applying any optional tags following the first two parameters to the newly-inserted text. This method is a convenience method that is equivalent to calling the insert() method, then the apply_tag() method on the inserted text.

gtk.TextBuffer.insert_with_tags_by_name

    def insert_with_tags_by_name(iter, text, ...)

The insert_with_tags_by_name() method is similar to the insert_with_tags() method, but uses tag names instead of tag objects.

gtk.TextBuffer.delete

    def delete(start, end)

The delete() method deletes the text between start and end. The order of start and end is not actually relevant as the delete() method will reorder them. This method emits the "delete_range" signal, and the default handler of that signal deletes the text. Because the textbuffer is modified, all outstanding iterators become invalid after calling this function; however, start and end will be re-initialized to point to the location where text was deleted.

gtk.TextBuffer.delete_interactive

    def delete_interactive(start_iter, end_iter, default_editable)

The delete_interactive() method deletes all editable text in the given range. This method calls the delete() method for each editable sub-range of [start,end). start and end are revalidated to point to the location of the last deleted range, or left untouched if no text was deleted. A range of text is non-editable if a gtk.TextTag applied to that range has its "editable" attribute set to FALSE or the gtk.TextView used by the user is set non-editable. The default_editable parameter indicates whether text is editable if no tags enclosing any part of text affect editability. Typically the result of the gtk.TextView.get_editable() method is appropriate here.

gtk.TextBuffer.get_text

    def get_text(start, end, include_hidden_chars=TRUE)

The get_text() method returns the text in the specified range [start,end). Undisplayed text (text marked with tags that set the invisibility attribute) are excluded if include_hidden_chars is FALSE. get_text() does not return 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 this behavior with the get_slice() method.

gtk.TextBuffer.get_slice

    def get_slice(start, end, include_hidden_chars)

The get_slice() method returns the text in the range [start,end). Undisplayed text (text marked with tags that set the invisibility attribute) is excluded if include_hidden_chars is FALSE. The returned string includes a 0xFFFC character whenever the textbuffer contains embedded images or child anchors, so byte and character indexes into the returned string do correspond to byte and character indexes into the buffer. Contrast this behavior with the get_text() method. 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.

gtk.TextBuffer.insert_pixbuf

    def insert_pixbuf(iter, pixbuf)

The insert_pixbuf() method inserts an image specified by pixbuf into the text buffer at the location specified by iter. The image will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode "object replacement character" 0xFFFC. Note that the "slice" variants for obtaining portions of the buffer as a string include this character for pixbufs, but the "text" variants do not. e.g. see the get_slice() and get_text() methods.

gtk.TextBuffer.insert_child_anchor

    def insert_child_anchor(iter, anchor)

The insert_child_anchor() method inserts a child widget anchor specified by anchor into the textbuffer at the location specified by iter. The anchor will be counted as one character in character counts, and when obtaining the buffer contents as a string, will be represented by the Unicode "object replacement character" 0xFFFC. Note that the "slice" variants for obtaining portions of the buffer as a string include this character for child anchors, but the "text" variants do not. e.g. see the get_slice() and get_text() methods. The create_child_anchor() is a more convenient alternative to this function.

gtk.TextBuffer.create_child_anchor

    def create_child_anchor(iter)

The create_child_anchor() method is a convenience function that creates a child anchor with the gtk.TextChildAnchor() constructor and inserts it into the textbuffer at the location specified by iter with the insert_child_anchor() method.

gtk.TextBuffer.create_mark

    def create_mark(mark_name, where, left_gravity)

The create_mark() method creates a mark with the name specified by mark_name at the position specified by where and left gravity specified by left_gravity. If mark_name is None, the mark is anonymous; otherwise, the mark can be retrieved by name using the get_mark() method. 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). Marks are owned by the buffer and go away when the buffer does. This method emits the "mark_set" signal as notification of the mark's initial placement.

gtk.TextBuffer.move_mark

    def move_mark(mark, where)

The move_mark() method moves the gtk.TextMark specified by mark to the new location specified by where.This method emits the "mark_set" signal as notification of the move.

gtk.TextBuffer.delete_mark

    def delete_mark(mark)

The delete_mark() method deletes the gtk.TextMark specified by mark, so that it's no longer located anywhere in the textbuffer. Most operations on mark become invalid and there is no way to undelete a mark. The get_deleted() method will return TRUE after this method has been called on a mark to indicate that a mark no longer belongs to a textbuffer. The "mark_deleted" signal will be emitted as notification after the mark is deleted.

gtk.TextBuffer.get_mark

    def get_mark(name)

The get_mark() method returns the mark named name in the textbuffer, or None if no such mark exists in the buffer.

gtk.TextBuffer.move_mark_by_name

    def move_mark_by_name(name, where)

The move_mark_by_name() method moves the mark named name (which must exist) to the textbuffer location specified by where. See the move_mark() method for details.

gtk.TextBuffer.delete_mark_by_name

    def delete_mark_by_name(name)

The delete_mark_by_name() method deletes the mark (which must exist) named name. See the delete_mark() for details.

gtk.TextBuffer.get_insert

    def get_insert()

The get_insert() method returns the mark that represents the cursor (insertion point). Equivalent to calling the get_mark() method to get the mark named "insert", but very slightly more efficient, and involving less typing.

gtk.TextBuffer.get_selection_bound

    def get_selection_bound()

The get_selection_bound() method returns the mark that represents the selection bound. Equivalent to calling the get_mark() method to get the mark named "selection_bound", but very slightly more efficient, and involving less typing. The currently-selected text in a textbuffer 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. The get_selection_bounds() method is a convenience method for handling the selection, if you just want to know whether there's a selection and what its bounds are.

gtk.TextBuffer.place_cursor

    def place_cursor(where)

The place_cursor() method moves the "insert" and "selection_bound" marks simultaneously to the location specified by where. If you move them to the same place in two steps with the move_mark() method, you will temporarily select a region in between their old and new locations, which is inefficient. This method moves them as a unit, which can be optimized.

gtk.TextBuffer.select_range

    def select_range(ins, bound)

The select_range() method moves the "insert" and "selection_bound" marks simultaneously to the locations specified by ins and bound respectively. If you move them to the same place in two steps with the move_mark() method, you will temporarily select a region in between their old and new locations, which is inefficient. This method moves them as a unit, which can be optimized.

gtk.TextBuffer.apply_tag

    def apply_tag(tag, start, end)

The apply_tag() method emits the "apply-tag" signal that causes the gtk.TextTag specified by tag to be applied to the range of text between start and end by the default signal handler. start and end do not have to be in order.

gtk.TextBuffer.remove_tag

    def remove_tag(tag, start, end)

The delete_tag() method emits the "remove_tag" signal that causes the default handler for the signal to remove all occurrences of the gtk.TextTag specified by tag from the text in the range between start and end. start and end don't have to be in order.

gtk.TextBuffer.apply_tag_by_name

    def apply_tag_by_name(name, start, end)

The apply_tag_by_name() method calls the gtk.TextTagTable.lookup() method on the textbuffer's tag table to find the gtk.TextTag with the specified name, then calls the apply_tag() method to apply that tag to the text in the range between start and end. start and end don't have to be in order.

gtk.TextBuffer.remove_tag_by_name

    def remove_tag_by_name(name, start, end)

The delete_tag_by_name() method calls the gtk.TextTagTable.lookup() method on the textbuffer's tag table to find the gtk.TextTag, then calls the remove_tag() method to remove that that tag from the text in the range between start and end. start and end don't have to be in order.

gtk.TextBuffer.remove_all_tags

    def remove_all_tags(start, end)

The remove_all_tags() method removes all tags in the text in the range between start and 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. start and end don't have to be in order.

gtk.TextBuffer.create_tag

    def create_tag(tag_name=None, ...)

The create_tag() method creates a tag with the name specified by tag_name and adds it to the tag table for the textbuffer. If one or more property_name=value pairs are available they are used to set the properties of the tag. Note the property_name must be specified using underscores instead of dashes e.g. use pixels_above_lines=10 instead of pixels-above-lines=10. This method is equivalent to calling the gtk.TextTag() constructor and then adding the tag to the buffer's tag table with the gtk.TextTagTable.add() method. If tag_name is None, the tag is anonymous. If tag_name is non-None, a tag called tag_name must not already exist in the tag table for this buffer.

gtk.TextBuffer.get_iter_at_line_offset

    def get_iter_at_line_offset(line_number, char_offset)

The get_iter_at_line_offset() returns an iterator pointing to the position specified by char_offset within the line specified by line_number. The char_offset must exist, offsets off the end of the line are not allowed. Note specify characters, not bytes; UTF-8 may encode one character as multiple bytes.

gtk.TextBuffer.get_iter_at_line_index

    def get_iter_at_line_index(line_number, byte_index)

The get_iter_at_line_index() method returns an iterator pointing to the position specified by byte_index within the line specified by line_number. byte_index must be the start of a UTF-8 character, and must not be beyond the end of the line. Note specify bytes, not characters; UTF-8 may encode one character as multiple bytes.

gtk.TextBuffer.get_iter_at_offset

    def get_iter_at_offset(char_offset)

The get_iter_at_offset() method returns an iterator pointing to the location specified by char_offset characters from the start of the entire buffer.

gtk.TextBuffer.get_iter_at_line

    def get_iter_at_line(line_number)

The get_iter_at_line() method returns an iterator pointing to the start of the line specified by line_number.

gtk.TextBuffer.get_start_iter

    def get_start_iter()

The get_start_iter() method returns an iterator pointing at the location of the first position in the text buffer. This is the same as using the get_iter_at_offset() with an argument of 0.

gtk.TextBuffer.get_end_iter

    def get_end_iter()

The get_end_iter() method returns an iterator pointing at the "end iterator," one past the last valid character in the text buffer. If passed to the gtk.TextIter.get_char() method, the end iterator has a character value of 0. The entire buffer lies in the range from the first position in the buffer (call the get_start_iter() method to get character position 0) to the end iterator.

gtk.TextBuffer.get_bounds

    def get_bounds()

The get_bounds() method returns a tuple containing the first and last iterators in the buffer, i.e. the entire buffer lies within the range.

gtk.TextBuffer.get_iter_at_mark

    def get_iter_at_mark(mark)

The get_iter_at_mark() method returns an iterator that points at the current position of mark.

gtk.TextBuffer.get_iter_at_child_anchor

    def get_iter_at_child_anchor(iter, anchor)

The get_iter_at_child_anchor() method returns an iterator that points at the location of anchor within the textbuffer.

gtk.TextBuffer.get_modified

    def get_modified()

The get_modified() method returns TRUE if the buffer has been modified since the last call to the set_modified() method set the modification flag to FALSE. Used for example to enable a "save" function in a text editor.

gtk.TextBuffer.set_modified

    def set_modified(setting)

The set_modified() method sets the modification flag of the textbuffer to the value specified by setting. The modification flag is 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 this method with a setting of FALSE. When the buffer is modified, it will automatically set the modification flag to TRUE and emit a "modified_changed" signal.

gtk.TextBuffer.add_selection_clipboard

    def add_selection_clipboard(clipboard)

The add_selection_clipboard() method adds the gtk.Clipboard specified by clipboard to the list of clipboards in which the selection contents of the buffer are available. In most cases, clipboard will be the gtk.gdk.SELECTION_PRIMARY clipboard

gtk.TextBuffer.remove_selection_clipboard

    def remove_selection_clipboard(clipboard)

The remove_selection_clipboard() method removes the gtk.Clipboard added with the add_selection_clipboard() method.

gtk.TextBuffer.cut_clipboard

    def cut_clipboard(clipboard, default_editable)

The cut_clipboard() method copies the currently-selected text to the gtk.Clipboard specified by clipboard, then deletes said text if it's editable as specified by default_editable. Typically the result of the gtk.TextView.get_editable() method is appropriate here.

gtk.TextBuffer.copy_clipboard

    def copy_clipboard(clipboard)

The copy_clipboard() method copies the currently-selected text to the gtk.ClipBoard specified by clipboard.

gtk.TextBuffer.paste_clipboard

    def paste_clipboard(clipboard, override_location, default_editable)

The paste_clipboard() method pastes the contents of the gtk.ClipBoard specified by clipboard at the insertion point, or at the location specified by override_location (if not None). (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.)

gtk.TextBuffer.get_selection_bounds

    def get_selection_bounds()

The get_selection_bounds() method returns a tuple containing iterators that point at the start and end of the selection, if any. If there is no selection an empty tuple is returned.

gtk.TextBuffer.delete_selection

    def delete_selection(interactive, default_editable)

The delete_selection() method deletes the text in the range between the "insert" and "selection_bound" marks, i.e. the currently-selected text. If interactive is TRUE, the editability of the selection will be considered (users can't delete uneditable text) and default_editable is used to determine the default editability of the textbuffer usually as a result of a call to the gtk.TextView.get_editable() method.

gtk.TextBuffer.begin_user_action

    def begin_user_action()

The begin_user_action() method is called to indicate that the textbuffer operations until a call to the end_user_action() method are part of a single user-visible operation. The operations between the begin_user_action() and end_user_action() methods can then be grouped when creating an undo stack. gtk.TextBuffer maintains a count of calls to the begin_user_action() method that have not been closed with a call to the end_user_action() method, and emits the "begin_user_action" and "end_user_action" signals only for the outermost pair of calls. This allows you to chain user actions.

The "interactive" textbuffer mutation methods, such as the insert_interactive() method, automatically call the begin and end user action methods around the textbuffer 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 methods.

gtk.TextBuffer.end_user_action

    def end_user_action()

The end_user_action() method should be paired with a call to the begin_user_action() method.

gtk.TextBuffer.backspace

    def backspace(iter, interactive, default_editable)

The backspace() method 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 function; however, iter will be re-initialized to point to the location where text was deleted.

gtk.TextBuffer.get_has_selection

    def get_has_selection()

Indicates whether the buffer has some text currently selected.

gtk.TextBuffer.get_copy_target_list

    def get_copy_target_list()

This method returns the list of targets this text buffer can provide for copying and as DND source. The targets in the list are added with info values from the GTK TextBuffer Target Info Constants, using the gtk.target_list_add_rich_text_targets() and gtk.target_list_add_text_targets() functions.

gtk.TextBuffer.get_paste_target_list

    def get_paste_target_list()

This method returns the list of targets this text buffer supports for pasting and as DND destination. The targets in the list are added with info values from the GTK TextBuffer Target Info Constants, using the gtk.target_list_add_rich_text_targets() and gtk.target_list_add_text_targets() functions.

gtk.TextBuffer.register_serialize_format

    def register_serialize_format(mime_type, function, user_data)

This method registers a rich text serialization function along with its mime_type with the passed buffer.

The signature of function is:

  def function(register_buf, content_buf, start, end, data):
      

where register_buf is the textbuffer that the format is registered with, content_buf is the textbuffer containing the text to be serialized, start and end are textiters bounding the text to be serialized and data is user_data. function should return the serialized data.

gtk.TextBuffer.register_serialize_tagset

    def register_serialize_tagset(tagset_name=NULL)

This method registers GTK+'s internal rich text serialization format with this textbuffer. The internal format does not comply to any standard rich text format and only works between gtk.TextBuffer instances. It is capable of serializing all of a text buffer's tags and embedded pixbufs.

This method is just a wrapper around gtk.TextBuffer.register_serialize_format(). The mime_type used for registering is "application/x-gtk-text-buffer-rich-text", or "application/x-gtk-text-buffer-rich-text;format=tagset_name" if a tagset_name was passed.

The tagset_name can be used to restrict the transfer of rich text to buffers with compatible sets of tags, in order to avoid unknown tags from being pasted. It is probably the common case to pass a non-None tagset here, since the None tagset requires the receiving buffer to deal with with pasting of arbitrary tags.

gtk.TextBuffer.register_deserialize_format

    def register_deserialize_format(mime_type, function, user_data)

This method registers a rich text deserialization function along with its mime_type with the passed buffer.

The signature of function is:

  def function(register_buf, content_buf, iter, data, create_tags, udata):
      

where register_buf is the textbuffer that the format is registered with, content_buf is the textbuffer that data will be deserialized into, iter is a textiter indicating the start of the deserialized data in content_buf, create_tags is a boolean indicating if tags should be created during deserializtion and udata is user_data. function should return TRUE if the data was successfully deserialized.

gtk.TextBuffer.register_deserialize_tagset

    def register_deserialize_tagset(tagset_name=NULL)

This method registers GTK+'s internal rich text serialization format with this buffer. See the gtk.TextBuffer.register_serialize_tagset() method for details.

gtk.TextBuffer.unregister_serialize_format

    def unregister_serialize_format(format)

This method unregisters a rich text format that was previously registered using the gtk.TextBuffer.register_serialize_format() or gtk.TextBuffer.register_serialize_tagset() methods.

gtk.TextBuffer.unregister_deserialize_format

    def unregister_deserialize_format(format)

This method unregisters a rich text format that was previously registered using the gtk.TextBuffer.register_deserialize_format() or gtk.TextBuffer.register_deserialize_tagset() methods.

gtk.TextBuffer.deserialize_set_can_create_tags

    def deserialize_set_can_create_tags(format, can_create_tags)

Use this method to allow a rich text deserialization function to create new tags in the receiving buffer. Note that using this method is almost always a bad idea, because the rich text functions you register should know how to map the rich text format they handle to your text buffers set of tags.

The ability of creating new (arbitrary!) tags in the receiving buffer is meant for special rich text formats like the internal one that is registered using gtk.TextBuffer.register_deserialize_tagset(), because that format is essentially a dump of the internal structure of the source buffer, including its tag names.

You should allow creation of tags only if you know what you are doing, e.g. if you defined a tagset name for your application suite's text buffers and you know that it's fine to receive new tags from these buffers, because you know that your application can handle the newly created tags.

gtk.TextBuffer.deserialize_get_can_create_tags

    def deserialize_get_can_create_tags(format)

This method returns the value set with the gtk.TextBuffer.deserialize_set_can_create_tags() method.

gtk.TextBuffer.get_serialize_formats

    def get_serialize_formats()

This method returns a list of the rich text serialize formats registered using the gtk.TextBuffer.register_serialize_format() or gtk.TextBuffer.register_serialize_tagset() methods.

gtk.TextBuffer.get_deserialize_formats

    def get_deserialize_formats()

This method returns the rich text deserialize formats registered using the gtk.TextBuffer.register_deserialize_format() or gtk.TextBuffer.register_deserialize_tagset() methods.

gtk.TextBuffer.serialize

    def serialize(content_buffer, format, start, end)

This method serializes the portion of text between start and end in the rich text format represented by format.

The formats to be used must be registered using the gtk.TextBuffer.register_serialize_format() or gtk.TextBuffer.register_serialize_tagset() methods beforehand.

gtk.TextBuffer.deserialize

    def deserialize(content_buffer, format, iter, data)

This method deserializes rich text in format format and inserts it at iter in content_buffer.

The formats to be used must be registered using the gtk.TextBuffer.register_deserialize_format() or gtk.TextBuffer.register_deserialize_tagset() methods beforehand.

The "apply-tag" gtk.TextBuffer Signal

    def callback(textbuffer, texttag, start, end, user_param1, ...)

The "apply-tag" signal is emitted when texttag is applied to the text in textbuffer in the range specified by start and end.

The "begin-user-action" gtk.TextBuffer Signal

    def callback(textbuffer, user_param1, ...)

The "begin-user-action" signal is emitted on the first call to the begin_user_action() method.

The "changed" gtk.TextBuffer Signal

    def callback(textbuffer, user_param1, ...)

The "changed" signal is emitted when text is inserted in textbuffer.

The "delete-range" gtk.TextBuffer Signal

    def callback(textbuffer, start, end, user_param1, ...)

The "delete-range" signal is emitted when the text in the range specified by start and end is to be deleted.

The "end-user-action" gtk.TextBuffer Signal

    def callback(textbuffer, user_param1, ...)

The "end-user-action" signal is emitted when the call to the end_user_action() method reduces the user action count to zero i.e. undoes the first call to the begin_user_action() method.

The "insert-child-anchor" gtk.TextBuffer Signal

    def callback(textbuffer, iter, anchor, user_param1, ...)

The "insert-child-anchor" signal is emitted when anchor is inserted into textbuffer at the location specified by iter.

The "insert-pixbuf" gtk.TextBuffer Signal

    def callback(textbuffer, iter, pixbuf, user_param1, ...)

The "insert-pixbuf" signal is emitted when pixbuf is inserted into textbuffer at the location specified by iter.

The "insert-text" gtk.TextBuffer Signal

    def callback(textbuffer, iter, text, length, user_param1, ...)

The "insert-text" signal is emitted when text of the size specified by length is inserted into textbuffer at the location specified by iter.

The "mark-deleted" gtk.TextBuffer Signal

    def callback(textbuffer, textmark, user_param1, ...)

The "mark-deleted" signal is emitted when textmark is being deleted from textbuffer.

The "mark-set" gtk.TextBuffer Signal

    def callback(textbuffer, user_param1, ...)

The "mark-set" signal is emitted when textmark is being set at the location specified by iter in textbuffer.

The "modified-changed" gtk.TextBuffer Signal

    def callback(textbuffer, user_param1, ...)

The "modified-changed" signal is emitted when the modification flag is changed.

The "remove-tag" gtk.TextBuffer Signal

    def callback(textbuffer, texttag, start, end, user_param1, ...)

The "remove-tag" signal is emitted when texttag is being removed from the textbuffer text in the range specified by start and end.