gtk-sharp2.10.0.0Gtk# is thread aware, but not thread safe; See the Gtk# Thread Programming for details.
This is a store for formatted text for display in a .
GLib.ObjectMethodSystem.VoidClears the contents of the bufferMethodSystem.VoidDeletes the mark named ; the mark must exist.
the name of a mark in buffer
See for more details.
MethodSystem.Void
Retrieves the first and last iterators in the buffer, i.e. the entire buffer.
A object to store the location
of the beginning of the buffer.
A object to store the location
of the end of the buffer.
MethodSystem.Void
Fires the events
and removes all occurrences of from
the given range
the to remove
the beginning of the range
the end of the range
Fires the
event. The default handler for the signal removes all
occurrences of tag from the given range. and .
MethodSystem.Void
Removes all tags in the range between and .
The beginning of the range
The end of the range
Removes all tags in the range between start and end. Be
careful with this function; it could remove tags added in
code unrelated to the code you are currently writing. That
is, calling this method is probably a bad idea if you have
two or more unrelated code sections that add tags.
MethodGtk.TextMark
Returns the mark named name in buffer buffer, or if no such mark exists in the buffer.
the name of a mark
Returns the mark named name in buffer buffer, or if no such mark exists in the buffer.
MethodSystem.VoidShould be paired with a call to .See for an explanation.MethodSystem.VoidInserts a child widget anchor into the text buffer.
location to insert the anchor
a .
Inserts a child widget anchor into the text buffer at . 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 pixbufs, but the
"text" variants do not. e.g. see and ). Consider as a
more convenient alternative to this function. The buffer
will add a reference to the anchor, so you can unref it
after insertion.
MethodSystem.BooleanReturns if some text is selected
the location of the beginning of the selection
the location of the end of the selection
Returns if the selection has nonzero length
Returns if some text is selected;
and sets the bounds of the selection in and (if
the selection has length 0, then start and end are filled
in with the same value). and will be in
ascending order. If and are , then they are
not filled in, but the return value still indicates
whether text is selected.
MethodSystem.VoidCalled to indicate that the buffer operations between here and a call to are part of a single user-visible operation.The operations between and can then be grouped when creating an undo stack. maintains a count of calls to that have not been closed with a call to , and emits and 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 , automatically call begin/end user action around the buffer operations they perform, so there is no need to add extra calls if you user action consists solely of a single call to one of those functions.
MethodSystem.Void
Pastes the contents of a clipboard at the insertion point,
or at .
the to paste from
the location to insert pasted text, or for at the cursor
whether the buffer is editable by default
Pastes the contents of a clipboard at the insertion point,
or at . (Note: pasting
is asynchronous, that is, we will ask for the paste data and
return, and at some point later after the main loop runs,
the paste data will be inserted.)
MethodSystem.VoidMoves mark to the new location .
a .
the new location for mark in buffer
Moves mark to the new location where. Fires the event as notification of the move.
MethodSystem.String
Returns the text from to .
the start of a range
the end of the range
whether to include invisible text
a string containing the text from
to
Returns the text in the range from to . Excludes undisplayed text
(text marked with tags that set the invisibility
attribute) if is
. 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 . 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.
MethodGtk.TextChildAnchor
This is a convenience function which simply creates a child
anchor with and inserts it into
the buffer with .
the location in the buffer
the created child anchor
This is a convenience function which simply creates a child
anchor with and inserts it into
the buffer with . The new anchor is owned by the buffer; no reference
count is returned to the caller of .
MethodSystem.VoidFires the events on buffer.
a
the beginning of the range to be tagged
the end of the range to be tagged
The default handler for the signal applies tag to the
given range. and do not have to be in order.
MethodSystem.Void
Copies text, tags, and pixbufs between
and and inserts the copy at .
a position in buffer
a position in the source
a position in the source
Copies text, tags, and pixbufs between and (the
order does not matter) and inserts the
copy at . Used instead of simply getting/inserting
text because it preserves images and tags. If and
are in a different buffer from buffer, the two buffers
must share the same tag table.
This method is implemented with the and events.
MethodSystem.Void
Calls on the buffer's tag table to get a , then calls
the name of the tag
the beginning of the buffer to be untagged
the end of the buffer to be untagged
MethodSystem.BooleanDeletes the currently-selected text
whether the deletion is caused by user interaction
whether the buffer is editable by default
whether there was a non-empty selection to delete
Deletes the range between the "insert" and
"selection_bound" marks, that is, the currently-selected
text. If is , the editability of the selection will
be considered (users can't delete uneditable text).
MethodSystem.BooleanDeletes all editable text in the given range.
the beginning of range to delete
the end of the range to delete
whether the buffer is editable by default
whether some text was actually deleted
Deletes all editable text in the given range. Calls for each editable sub-range of
and . and
are revalidated to point to the
location of the last deleted range, or left untouched if
no text was deleted.
MethodSystem.VoidRemoves a added with .
an object of type MethodSystem.Void
Deletes text between and .
a position in the buffer
a position in the buffer
Deletes text between and . The order of the two is not actually
relevant, as they will be reordered. This function
actually fires off the event, and the default
handler of that signal deletes the text. Because the
buffer is modified, all outstanding iterators become
invalid after calling this function; however,
and will be re-initialized to point to the location
where text was deleted.
MethodSystem.VoidMoves the "insert" and "selection_bound" marks simultaneously.
where to put the cursor
This function moves the "insert" and "selection_bound"
marks simultaneously. If you move them to the same place
in two steps with ,
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.
MethodSystem.VoidAdds to the list of clipboards in which the selection contents of buffer are available.
an object of type In most cases, clipboard will be the of type for a view of buffer.MethodSystem.VoidDeletes mark, so that it is no longer located anywhere in the buffer.
a in the buffer to be deleted.
Deletes mark, so that it is no longer located anywhere in
the buffer. There is no way to undelete a
mark. will return
after
this function has been called on a mark;
indicates that a mark no
longer belongs to a buffer. The event will
be raised as notification after the mark is deleted.
MethodGtk.TextMarkCreates a mark at position .
name for mark, or .
location to place mark
whether the mark has left gravity
a new object
Creates a mark at position . If is ,
the mark is anonymous; otherwise, the mark can be
retrieved by name using . If a
mark has left gravity, and text is inserted at the
current location of the mark, the mark will be moved to the left of
the newly-inserted text. If the mark has right gravity
(ie. = ), 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 are typing).
Fires the event as
notification of the initial placement of the mark.
MethodSystem.VoidCopies the buffer's selected text to the given .
The to copy the text to.
Copying a 's selected text: void Copy (Gtk.TextView view) {
Gtk.TextBuffer buffer = view.Buffer;
Gtk.Clipboard board = Clipboard.Get (Gdk.Selection.Clipboard);
buffer.CopyClipboard (board);
} MethodSystem.Void
Moves the mark named (which must
exist) to location .
the name of the mark
the new location for mark
It is possible to use built-in marks to implement a "Select All" method on a buffer (e.g. ).
private void SelectAll (TextBuffer buffer)
{
buffer.MoveMark ("insert", buffer.StartIter);
buffer.MoveMark ("selection_bound", buffer.EndIter);
}
See for more details.MethodSystem.Boolean
Same as , but does nothing if the insertion point is not editable.
a position in buffer
a position in the source
a position in the source
whether the text is editable at if no tags enclosing
iter affect editability
if an insertion was possible at
Same as , but does nothing if the insertion point is not
editable.
The parameter
indicates whether the text is editable at if no tags
enclosing iter affect editability. Typically the result of
is appropriate here.
MethodSystem.StringReturns the text from a specified range
the beginning of the specified range
the end of the specified range
whether to include invisible text
a string containing the text from the specified range
Returns the text in the range specified by and . Excludes
undisplayed text (text marked with tags that set the
invisibility attribute) if is . 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 this with .
MethodSystem.Void
Fires the event on buffer. The default handler
for the signal applies tag to the given range.
the name of the tag
the location of the beginning of the range
the location of the end of the range
The order for and is not important.
MethodSystem.Void
Inserts an image into the text buffer at .
The location to insert the image
The image to be inserted
Inserts an image into the text buffer at . 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
and .
MethodSystem.VoidCopies the currently-selected text to a clipboard, then deletes said text if it is editable.
an object of type
an object of type ConstructorInternal constructor
Pointer to the C object.
This is an internal constructor, and should not be used by user code.ConstructorCreates a new text buffer.
a tag table, or to create a new one
PropertySystem.StringThe complete contents of the bufferThe contents of the current bufferGLib.Property("text")PropertySystem.Int32Obtains the number of lines in the buffer.The number of lines in the buffer
The results of this method is cached, so this is very fast.
PropertyGtk.TextIterThe end of the bufferThe location of the end of the bufferPropertySystem.BooleanWhether or not the buffer has been modified if the buffer has
been modified, otherwise.
Whenever the buffer is saved to disk, set this property to
. When the buffer is modified, it
will automatically toggled to .
Whenever this property is changed, the event is raised.
PropertyGtk.TextTagTableThe tag table of the current bufferThe current of the bufferGLib.Property("tag-table")PropertyGtk.TextMarkReturns the mark that represents the selection bound.a
Returns the mark that represents the selection
bound. Equivalent to calling 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. is another convenient function for handling the
selection, if you just want to know whether there is a
selection and what its bounds are.
PropertyGtk.TextMarkReturns the mark that represents the cursor (insertion point).The mark of the insert point.
This is equivelant to calling for the
mark named "insert".
PropertySystem.Int32The number of characters in the bufferThe number of characters in the bufferThe result of this method is cached, so it is very fast.PropertyGtk.TextIterThe location of the beginning of the bufferThe location of the beginning of the buffer
This is the equivelant to calling to get the iter at character offset 0.
EventSystem.EventHandlerEmitted when a UserAction ends on the buffer.GLib.Signal("end_user_action")EventGtk.TagRemovedHandlerEmitted when a tag is removed from the buffer.GLib.Signal("remove_tag")EventSystem.EventHandlerEmitted when a UserAction is begun on the buffer.GLib.Signal("begin_user_action")EventGtk.MarkSetHandlerEmitted when a mark is set in the buffer.GLib.Signal("mark_set")EventGtk.TagAppliedHandlerEmitted when a tag is applied to the buffer.GLib.Signal("apply_tag")EventGtk.ChildAnchorInsertedHandlerEmitted when a ChildAnchor has been inserted in the buffer.GLib.Signal("insert_child_anchor")EventGtk.MarkDeletedHandlerEmitted when a mark has been deleted from the buffer.GLib.Signal("mark_deleted")EventGtk.DeleteRangeHandlerEmitted when a range of text has been deleted from the buffer.GLib.Signal("delete_range")EventGtk.PixbufInsertedHandlerEmitted when a Pixbuf is inserted into the buffer.GLib.Signal("insert_pixbuf")EventSystem.EventHandlerEmitted when the text in the buffer has been changed.GLib.Signal("changed")EventGtk.InsertTextHandlerEmitted when text is inserted into the buffer.GLib.Signal("insert_text")EventSystem.EventHandlerEmitted when the Modified status of the buffer is changed.GLib.Signal("modified_changed")MethodGtk.TextIterReturns the location at a particular character offset
The requested character offset
The location at MethodSystem.VoidInsert text into the current cursor position
The text to be inserted
The event is
raised when a call to this method is made.
MethodSystem.VoidInsert text at a specific point
The location for to be
inserted
The text to be inserted
MethodSystem.BooleanInsert text at cursor position if the location is editable
The text to be inserted
The default editability of the buffer
Whether or not was inserted
See for more details.
MethodSystem.Boolean
Insert text if the cursor is at an editable point in
the buffer
a location in the buffer
the text to be inserted
the default editability of buffer
whether text was actually inserted
Similar to , but the insertion will not occur if 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).
indicates the editability of text that
does not have a tag affecting editability applied to
it. Typically the result of
is appropriate here.
MethodSystem.VoidSet the contents of the buffer
The new contents of the buffer
This is equivelant to using the setter of the
property.
MethodSystem.VoidPastes the contents of a clipboard at the insertion point.
a PropertyGLib.GTypeGType Property.a Returns the native value for .MethodSystem.VoidDefault handler for the event.Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.
a
a
a Override this method in a subclass to provide a default handler for the event.MethodSystem.VoidDefault handler for the event.Override this method in a subclass to provide a default handler for the event.ConstructorProtected Constructor.
a Chain to this constructor if you have manually registered a native value for your subclass.System.ObsoleteMethodGtk.TextIterGets the location of a specific point.
a
a The location at the location specified by and .MethodGtk.TextIterGets the location of a particular line.
The specified line number.
The location at the beginning fo the line as specified by .MethodGtk.TextIterGets the location of the specified mark.
The specified mark.
The location of .MethodGtk.TextIterGets the location of the specific anchor.
A at the current buffer.
The location at .MethodGtk.TextIterObtains an iterator pointing to within the given line.
A line number for the current buffer, counting from 0.
The byte index from start of line.
The location as specified by and . must be the start of a
UTF-8 character, and must not be beyond the end of the
line. Note bytes, not characters; UTF-8 may encode one
character as multiple bytes.
MethodSystem.VoidSystem.ParamArrayInserts into buffer at , applying the list of to the newly-inserted text.
location to insert the text
text to insert
tags to apply to Equivalent to calling , then on the inserted text; It is just a convenience function.MethodSystem.VoidSystem.ParamArrayInserts into buffer at , applying the list of tags with names to the newly-inserted text.
location to insert the text
text to insert
names of the tags to apply to Equivalent to calling , then on the inserted text; It is just a convenience function.MethodSystem.Void This function moves the and
marks simultaneously.
a
a
If you move them in two steps
with , 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.
MethodSystem.BooleanTo be added
a
a
a a To be addedMethodSystem.VoidSystem.ParamArray
To be added.
To be added.
To be added.
Inserts text with tag information.The overload is obsolete, replace by the ref TextIter overload.MethodSystem.Void
To be added.
To be added.
Inserts text.The overload is obsolete, replace by the ref TextIter overload.MethodSystem.Void
To be added.
To be added.
To be added.
Inserts a range of text.This overload is obsolete, replaced by ref TextIter overloads since the iters passed in are updated by the caller.MethodSystem.Void
To be added.
To be added.
Delete text between two iterators.This overload is obsolete, replaced by ref TextIter overloads since the iters passed in are updated by the caller.MethodSystem.Void
format to unregister.
Removes a Serialization format from the registry.MethodGdk.Atom
name of tagset, or .
Registers TextBuffer's internal serialization format.The newly registered format's mime type.MethodGdk.Atom
A MIME type target.
Serialization formatter for the specified .
Registers a serialization formatter for a given MIME type.MethodGdk.Atom
name of tagset, or .
Registers TextBuffer's internal serialization format.The newly registered format's mime type.MethodGdk.Atom
a MIME type target.
Serialization formatter for the specified .
Registers a deserialization handler for a given MIME type.an atom representing the MIME type.MethodSystem.Void
format Atom for a MIME type.
Removes a registered MIME type handler from the buffer.MethodSystem.Boolean
a MIME type Atom.
Determines if tag creation is supported for a MIME type deserializer.if , tag creation is supported.MethodSystem.Void
a MIME type Atom.
a .
Enables or disables arbitrary tag creation.In most cases, you don't want to do this, as it will put arbitrary tags in the buffer.PropertyGLib.Property("cursor-position")System.Int32Position of the insert mark.a representing the offset to the cursor from the beginning of the buffer.PropertyGLib.Property("paste-target-list")Gtk.TargetListObtains the paste TargetList.a .PropertyGLib.Property("has-selection")System.BooleanIndicates presence of a selection.if , there is text selected currently.PropertyGLib.Property("copy-target-list")Gtk.TargetListObtains the copy TargetList.a .MethodSystem.Boolean
buffer to deserialize content.
MIME type format.
insertion point.
serialized data.
length of serialized data.
Deserialize content.a .MethodSystem.Byte[]
buffer containing text to serialize.
MIME type format.
beginning of desired text.
end of desired text.
Serializes a range of text.the serialized data stream.PropertyGdk.Atom[]The supported MIME type formats for deserialization.an array of MIME type Atoms.PropertyGdk.Atom[]The supported MIME type formats for Serialization.an array of MIME type Atoms.