2003-02-12 02:00:12 +00:00
<Type Name= "TextBuffer" FullName= "Gtk.TextBuffer" >
2005-05-23 20:41:51 +00:00
<TypeSignature Language= "C#" Maintainer= "duncan" Value= "public class TextBuffer : GLib.Object" />
2003-02-12 02:00:12 +00:00
<AssemblyInfo >
<AssemblyName > gtk-sharp</AssemblyName>
2003-12-24 01:35:30 +00:00
<AssemblyPublicKey >
</AssemblyPublicKey>
2006-08-04 19:43:19 +00:00
<AssemblyVersion > 2.10.0.0</AssemblyVersion>
2003-02-12 02:00:12 +00:00
</AssemblyInfo>
2003-02-23 07:26:30 +00:00
<ThreadSafetyStatement > Gtk# is thread aware, but not thread safe; See the <link location= "node:gtk-sharp/programming/threads" > Gtk# Thread Programming</link> for details.</ThreadSafetyStatement>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-17 06:38:40 +00:00
This is a store for formatted text for display in a <see cref= "T:Gtk.TextView" /> .
2003-07-12 09:20:37 +00:00
</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
<Base >
<BaseTypeName > GLib.Object</BaseTypeName>
</Base>
<Interfaces >
</Interfaces>
<Members >
<Member MemberName= "Clear" >
<MemberSignature Language= "C#" Value= "public void Clear ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-12-03 18:00:30 +00:00
<summary > Clears the contents of the buffer</summary>
2004-12-08 02:37:02 +00:00
<remarks >
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
2003-07-16 02:07:51 +00:00
<Member MemberName= "DeleteMark" >
<MemberSignature Language= "C#" Value= "public void DeleteMark (string name);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "name" Type= "System.String" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-31 21:44:39 +00:00
<summary > Deletes the mark named <paramref name= "name" /> ; the mark must exist.</summary>
2003-07-12 09:20:37 +00:00
<param name= "name" > the name of a mark in buffer</param>
<remarks >
<para >
2003-07-17 06:38:40 +00:00
See <see cref= "M:Gtk.TextBuffer.DeleteMark(Gtk.TextMark)" /> for more details.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "GetBounds" >
2003-02-15 03:08:25 +00:00
<MemberSignature Language= "C#" Value= "public void GetBounds (out Gtk.TextIter start, out Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter&" RefType= "out" />
<Parameter Name= "end" Type= "Gtk.TextIter&" RefType= "out" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
Retrieves the first and last iterators in the buffer, i.e. the entire buffer.
</summary>
<param name= "start" >
A <see cref= "T:Gtk.TextIter" /> object to store the location
of the beginning of the buffer.
</param>
<param name= "end" >
A <see cref= "T:Gtk.TextIter" /> object to store the location
of the end of the buffer.
</param>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "RemoveTag" >
<MemberSignature Language= "C#" Value= "public void RemoveTag (Gtk.TextTag tag, Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "tag" Type= "Gtk.TextTag" />
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-14 00:48:35 +00:00
Fires the <see cref= "E:Gtk.TextBuffer.RemoveTag" /> events
2003-07-31 21:44:39 +00:00
and removes all occurrences of <paramref name= "tag" /> from
2003-07-14 00:48:35 +00:00
the given range
2003-07-12 09:20:37 +00:00
</summary>
<param name= "tag" > the <see cref= "T:Gtk.TextTag" /> to remove</param>
<param name= "start" > the beginning of the range</param>
2003-07-17 06:38:40 +00:00
<param name= "end" > the end of the range</param>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
Fires the <see cref= "E:Gtk.TextBuffer.RemoveTag" />
event. The default handler for the signal removes all
2003-07-31 21:44:39 +00:00
occurrences of tag from the given range. <paramref name= "start" /> and <paramref name= "end" /> .
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "RemoveAllTags" >
<MemberSignature Language= "C#" Value= "public void RemoveAllTags (Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Removes all tags in the range between <paramref name= "start" /> and <paramref name= "end" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "start" > The beginning of the range</param>
<param name= "end" > The end of the range</param>
<remarks >
<para >
Removes all tags in the range between start and end. Be
careful with this function; it could remove tags added in
2003-09-05 02:29:59 +00:00
code unrelated to the code you are currently writing. That
2003-07-12 09:20:37 +00:00
is, calling this method is probably a bad idea if you have
two or more unrelated code sections that add tags.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "GetMark" >
<MemberSignature Language= "C#" Value= "public Gtk.TextMark GetMark (string name);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextMark</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "name" Type= "System.String" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-17 06:38:40 +00:00
Returns the mark named name in buffer buffer, or <see langword= "null" /> if no such mark exists in the buffer.
2003-07-12 09:20:37 +00:00
</summary>
<param name= "name" > the name of a mark</param>
<returns >
2003-07-17 06:38:40 +00:00
Returns the mark named name in buffer buffer, or <see langword= "null" /> if no such mark exists in the buffer.
2003-07-12 09:20:37 +00:00
</returns>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "EndUserAction" >
<MemberSignature Language= "C#" Value= "public void EndUserAction ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Should be paired with a call to <see cref= "M:Gtk.TextBuffer.BeginUserAction()" /> .</summary>
<remarks > See <see cref= "M:Gtk.TextBuffer.BeginUserAction()" /> for an explanation.</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "InsertChildAnchor" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void InsertChildAnchor (ref Gtk.TextIter iter, Gtk.TextChildAnchor anchor);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "anchor" Type= "Gtk.TextChildAnchor" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Inserts a child widget anchor into the text buffer.</summary>
<param name= "iter" > location to insert the anchor</param>
<param name= "anchor" > a <see cref= "T:Gtk.TextChildAnchor" /> .</param>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Inserts a child widget anchor into the text buffer at <paramref name= "iter" /> . The anchor will be counted as one
2003-07-12 09:20:37 +00:00
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
2003-07-17 06:38:40 +00:00
"text" variants do not. e.g. see <see cref= "M:Gtk.TextBuffer.GetSlice(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> and <see cref= "M:Gtk.TextBuffer.GetText(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> ). Consider <see cref= "M:Gtk.TextBuffer.CreateChildAnchor(Gtk.TextIter)" /> as a
2003-07-12 09:20:37 +00:00
more convenient alternative to this function. The buffer
will add a reference to the anchor, so you can unref it
after insertion.
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "GetSelectionBounds" >
2003-02-15 03:08:25 +00:00
<MemberSignature Language= "C#" Value= "public bool GetSelectionBounds (out Gtk.TextIter start, out Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter&" RefType= "out" />
<Parameter Name= "end" Type= "Gtk.TextIter&" RefType= "out" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Returns <see langword= "true" /> if some text is selected</summary>
<param name= "start" > the location of the beginning of the selection</param>
<param name= "end" > the location of the end of the selection</param>
<returns > Returns <see langword= "true" /> if the selection has nonzero length</returns>
<remarks >
<para >
Returns <see langword= "true" /> if some text is selected;
2003-07-31 21:44:39 +00:00
and sets the bounds of the selection in <paramref name= "start" /> and <paramref name= "end" /> (if
2003-07-12 09:20:37 +00:00
the selection has length 0, then start and end are filled
2003-07-31 21:44:39 +00:00
in with the same value). <paramref name= "start" /> and <paramref name= "end" /> will be in
ascending order. If <paramref name= "start" /> and <paramref name= "end" /> are <see langword= "null" /> , then they are
2003-07-12 09:20:37 +00:00
not filled in, but the return value still indicates
whether text is selected.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "BeginUserAction" >
<MemberSignature Language= "C#" Value= "public void BeginUserAction ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Called to indicate that the buffer operations between here and a call to <see cref= "M:Gtk.TextBuffer.EndUserAction()" /> are part of a single user-visible operation.</summary>
<remarks >
<para > The operations between <see cref= "M:Gtk.TextBuffer.BeginUserAction()" /> and <see cref= "M:Gtk.TextBuffer.EndUserAction()" /> can then be grouped when creating an undo stack. <see cref= "T:Gtk.TextBuffer" /> maintains a count of calls to <see cref= "M:Gtk.TextBuffer.BeginUserAction()" /> that have not been closed with a call to <see cref= "M:Gtk.TextBuffer.EndUserAction()" /> , and emits <see cref= "E:Gtk.TextBuffer.UserActionBegun" /> and <see cref= "E:Gtk.TextBuffer.UserActionEnded" /> signals only for the outermost pair of calls. This allows you to build user actions from other user actions.
</para>
<para > The "interactive" buffer mutation functions, such as <see cref= "M:Gtk.TextBuffer.InsertInteractive()" /> , 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.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "PasteClipboard" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void PasteClipboard (Gtk.Clipboard clipboard, ref Gtk.TextIter override_location, bool default_editable);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
2004-12-03 18:00:30 +00:00
<Parameter Name= "override_location" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
Pastes the contents of a clipboard at the insertion point,
2003-07-31 21:44:39 +00:00
or at <paramref name= "override_location" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "clipboard" > the <see cref= "T:Gtk.Clipboard" /> to paste from</param>
<param name= "override_location" >
2003-07-17 06:38:40 +00:00
the location to insert pasted text, or <see langword= "null" /> for at the cursor
2003-07-12 09:20:37 +00:00
</param>
<param name= "default_editable" >
whether the buffer is editable by default
</param>
<remarks >
Pastes the contents of a clipboard at the insertion point,
2003-07-31 21:44:39 +00:00
or at <paramref name= "override_location" /> . (Note: pasting
2003-09-05 02:29:59 +00:00
is asynchronous, that is, we will ask for the paste data and
2003-07-12 09:20:37 +00:00
return, and at some point later after the main loop runs,
the paste data will be inserted.)
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "MoveMark" >
<MemberSignature Language= "C#" Value= "public void MoveMark (Gtk.TextMark mark, Gtk.TextIter where);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "mark" Type= "Gtk.TextMark" />
<Parameter Name= "where" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2004-08-24 17:01:00 +00:00
<summary > Moves mark to the new location <paramref name= "where" /> .</summary>
2003-07-12 09:20:37 +00:00
<param name= "mark" > a <see cref= "T:Gtk.TextMark" /> .</param>
<param name= "where" > the new location for mark in buffer</param>
<remarks >
<para >
2003-07-17 06:38:40 +00:00
Moves mark to the new location where. Fires the <see cref= "E:Gtk.TextBuffer.MarkSet" /> event as notification of the move.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "GetSlice" >
<MemberSignature Language= "C#" Value= "public string GetSlice (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.String</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
<Parameter Name= "include_hidden_chars" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Returns the text from <paramref name= "start" /> to <paramref name= ",end" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "start" > the start of a range</param>
<param name= "end" > the end of the range</param>
<param name= "include_hidden_chars" > whether to include invisible text</param>
<returns >
2003-07-31 21:44:39 +00:00
a string containing the text from <paramref name= "start" />
to <paramref name= "end" /> </returns>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Returns the text in the range from <paramref name= "start" /> to <paramref name= "end" /> . Excludes undisplayed text
2003-07-12 09:20:37 +00:00
(text marked with tags that set the invisibility
2003-07-31 21:44:39 +00:00
attribute) if <paramref name= "include_hidden_chars" /> is
2003-07-12 09:20:37 +00:00
<see langword= "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
2003-07-17 06:38:40 +00:00
the buffer. Contrast with <see cref= "M:Gtk.TextBuffer.GetText(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> . Note that 0xFFFC can occur in normal text as well, so
2003-07-12 09:20:37 +00:00
it is not a reliable indicator that a pixbuf or widget is
in the buffer.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "CreateChildAnchor" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public Gtk.TextChildAnchor CreateChildAnchor (ref Gtk.TextIter iter);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextChildAnchor</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
This is a convenience function which simply creates a child
anchor with <see cref= "C:Gtk.TextChildAnchor" /> and inserts it into
2003-07-17 06:38:40 +00:00
the buffer with <see cref= "M:Gtk.TextBuffer.InsertChildAnchor(Gtk.TextIter,Gtk.TextChildAnchor)" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "iter" > the location in the buffer</param>
<returns > the created child anchor</returns>
<remarks >
<para >
This is a convenience function which simply creates a child
anchor with <see cref= "C:Gtk.TextChildAnchor" /> and inserts it into
2003-07-17 06:38:40 +00:00
the buffer with <see cref= "M:Gtk.TextBuffer.InsertChildAnchor(Gtk.TextIter,Gtk.TextChildAnchor)" /> . The new anchor is owned by the buffer; no reference
2003-09-05 02:29:59 +00:00
count is returned to the caller of <see cref= "M:Gtk.TextBuffer.CreateChildAnchor(Gtk.TextIter)" /> .
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "ApplyTag" >
<MemberSignature Language= "C#" Value= "public void ApplyTag (Gtk.TextTag tag, Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "tag" Type= "Gtk.TextTag" />
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Fires the <see cref= "E:Gtk.TextBuffer.ApplyTag" /> events on buffer.</summary>
<param name= "tag" > a <see cref= "Gtk.TextTag" /> </param>
<param name= "start" > the beginning of the range to be tagged</param>
<param name= "end" > the end of the range to be tagged</param>
<remarks >
<para >
The default handler for the signal applies tag to the
2003-09-05 02:29:59 +00:00
given range. <paramref name= "start" /> and <paramref name= "end" /> do not have to be in order.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "InsertRange" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void InsertRange (ref Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Copies text, tags, and pixbufs between <paramref name= "start" />
and <paramref name= "end" /> and inserts the copy at <paramref name= "iter" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "iter" > a position in buffer</param>
<param name= "start" >
2003-09-05 02:29:59 +00:00
a position in the source <see cref= "T:Gtk.TextBuffer" /> </param>
2003-07-12 09:20:37 +00:00
<param name= "end" >
2003-09-05 02:29:59 +00:00
a position in the source <see cref= "T:Gtk.TextBuffer" /> </param>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Copies text, tags, and pixbufs between <paramref name= "start" /> and <paramref name= "end" /> (the
2003-07-12 09:20:37 +00:00
order does not matter) and inserts the
2003-07-31 21:44:39 +00:00
copy at <paramref name= "iter" /> . Used instead of simply getting/inserting
2004-08-24 17:01:00 +00:00
text because it preserves images and tags. If <paramref name= "start" /> and
2003-07-31 21:44:39 +00:00
<paramref name= "end" /> are in a different buffer from buffer, the two buffers
2003-07-12 09:20:37 +00:00
must share the same tag table.
</para>
<para >
2003-07-17 06:38:40 +00:00
This method is implemented with the <see cref= "E:Gtk.TextBuffer.InsertText" /> and <see cref= "E:Gtk.TextBuffer.ApplyTag" /> events.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
2003-07-16 02:07:51 +00:00
<Member MemberName= "RemoveTag" >
<MemberSignature Language= "C#" Value= "public void RemoveTag (string name, Gtk.TextIter start, Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "name" Type= "System.String" />
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-17 06:38:40 +00:00
Calls <see cref= "M:Gtk.TextTagTable.Lookup(System.String)" /> on the buffer's tag table to get a <see cref= "T:Gtk.TextTag" /> , then calls
2004-11-04 19:34:16 +00:00
<see cref= "M:Gtk.TextBuffer.RemoveTag(Gtk.TextTag,Gtk.TextIter,Gtk.TextIter)" /> </summary>
2003-07-12 09:20:37 +00:00
<param name= "name" > the name of the tag</param>
<param name= "start" > the beginning of the buffer to be untagged</param>
<param name= "end" > the end of the buffer to be untagged</param>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "DeleteSelection" >
<MemberSignature Language= "C#" Value= "public bool DeleteSelection (bool interactive, bool default_editable);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "interactive" Type= "System.Boolean" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Deletes the currently-selected text</summary>
<param name= "interactive" > whether the deletion is caused by user interaction</param>
<param name= "default_editable" > whether the buffer is editable by default</param>
<returns >
whether there was a non-empty selection to delete
</returns>
<remarks >
<para >
Deletes the range between the "insert" and
"selection_bound" marks, that is, the currently-selected
2003-07-31 21:44:39 +00:00
text. If <paramref name= "interactive" /> is <see langword= "true" /> , the editability of the selection will
2003-07-12 09:20:37 +00:00
be considered (users can't delete uneditable text).
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "DeleteInteractive" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public bool DeleteInteractive (ref Gtk.TextIter start_iter, ref Gtk.TextIter end_iter, bool default_editable);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "start_iter" Type= "Gtk.TextIter&" RefType= "ref" />
<Parameter Name= "end_iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Deletes all editable text in the given range.</summary>
<param name= "start_iter" > the beginning of range to delete</param>
<param name= "end_iter" > the end of the range to delete</param>
<param name= "default_editable" > whether the buffer is editable by default</param>
<returns > whether some text was actually deleted</returns>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Deletes all editable text in the given range. Calls <see cref= "M:Gtk.TextBuffer.Delete(Gtk.TextIter,Gtk.TextIter)" /> for each editable sub-range of <paramref name= "start" />
and <paramref name= "end" /> . <paramref name= "start" /> and
<paramref name= "end" /> are revalidated to point to the
2003-07-12 09:20:37 +00:00
location of the last deleted range, or left untouched if
no text was deleted.
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "RemoveSelectionClipboard" >
<MemberSignature Language= "C#" Value= "public void RemoveSelectionClipboard (Gtk.Clipboard clipboard);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Removes a <see cref= "T:Gtk.Clipboard" /> added with <see cref= "M:Gtk.TextBuffer.AddSelectionClipboard()" /> .</summary>
2003-09-05 02:29:59 +00:00
<param name= "clipboard" > an object of type <see cref= "T:Gtk.Clipboard" /> </param>
2004-07-22 21:52:21 +00:00
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "Delete" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void Delete (ref Gtk.TextIter start, ref Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter&" RefType= "ref" />
<Parameter Name= "end" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Deletes text between <paramref name= "start" /> and <paramref name= "end" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "start" > a position in the buffer</param>
<param name= "end" > a position in the buffer</param>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Deletes text between <paramref name= "start" /> and <paramref name= "end" /> . The order of the two is not actually
2003-09-05 02:29:59 +00:00
relevant, as they will be reordered. This function
2003-07-17 06:38:40 +00:00
actually fires off the <see cref= "E:Gtk.TextBuffer.DeleteRange" /> event, and the default
2003-07-12 09:20:37 +00:00
handler of that signal deletes the text. Because the
buffer is modified, all outstanding iterators become
2004-12-03 18:00:30 +00:00
invalid after calling this function; however, <paramref name= "start" />
and <paramref name= "end" /> will be re-initialized to point to the location
2003-07-12 09:20:37 +00:00
where text was deleted.
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "PlaceCursor" >
<MemberSignature Language= "C#" Value= "public void PlaceCursor (Gtk.TextIter where);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "where" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Moves the "insert" and "selection_bound" marks simultaneously.</summary>
<param name= "where" > where to put the cursor</param>
<remarks >
<para >
This function moves the "insert" and "selection_bound"
marks simultaneously. If you move them to the same place
2003-07-17 06:38:40 +00:00
in two steps with <see cref= "M:Gtk.TextBuffer.MoveMarkGtk.TextMark,Gtk.TextIter)" /> ,
2003-07-12 09:20:37 +00:00
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.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "AddSelectionClipboard" >
<MemberSignature Language= "C#" Value= "public void AddSelectionClipboard (Gtk.Clipboard clipboard);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2004-08-24 17:01:00 +00:00
<summary > Adds <paramref name= "clipboard" /> to the list of clipboards in which the selection contents of buffer are available.</summary>
2003-09-05 02:29:59 +00:00
<param name= "clipboard" > an object of type <see cref= "T:Gtk.Clipboard" /> </param>
2004-07-22 21:52:21 +00:00
<remarks > In most cases, clipboard will be the <see cref= "T:Gtk.Clipboard" /> of type <see cref= "F:Gdk.Selection.Primary" /> for a view of buffer.</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "DeleteMark" >
<MemberSignature Language= "C#" Value= "public void DeleteMark (Gtk.TextMark mark);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "mark" Type= "Gtk.TextMark" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-09-05 02:29:59 +00:00
<summary > Deletes mark, so that it is no longer located anywhere in the buffer.</summary>
2003-07-12 09:20:37 +00:00
<param name= "mark" >
a <see cref= "T:Gtk.TextMark" /> in the buffer to be deleted.
</param>
<remarks >
<para >
2003-09-05 02:29:59 +00:00
Deletes mark, so that it is no longer located anywhere in
2003-07-12 09:20:37 +00:00
the buffer. There is no way to undelete a
mark. <see cref= "P:Gtk.TextMark.Deleted" /> will return
<see langword= "true" /> after
this function has been called on a mark;
<see cref= "P:Gtk.TextMark.Deleted" /> indicates that a mark no
2003-07-17 06:38:40 +00:00
longer belongs to a buffer. The <see cref= "E:Gtk.TextBuffer.MarkDeleted" /> event will
2005-09-19 00:36:43 +00:00
be raised as notification after the mark is deleted.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "CreateMark" >
<MemberSignature Language= "C#" Value= "public Gtk.TextMark CreateMark (string mark_name, Gtk.TextIter where, bool left_gravity);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextMark</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "mark_name" Type= "System.String" />
<Parameter Name= "where" Type= "Gtk.TextIter" />
<Parameter Name= "left_gravity" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-31 21:44:39 +00:00
<summary > Creates a mark at position <paramref name= "where" /> .</summary>
2003-07-12 09:20:37 +00:00
<param name= "mark_name" > name for mark, or <see langword= "null" /> .</param>
<param name= "where" > location to place mark</param>
<param name= "left_gravity" > whether the mark has left gravity</param>
<returns > a new <see cref= "T:Gtk.TextMark" /> object</returns>
<remarks >
<para >
2003-09-05 02:29:59 +00:00
Creates a mark at position <paramref name= "where" /> . If <paramref name= "mark_name" /> is <see langword= "null" /> ,
2003-07-12 09:20:37 +00:00
the mark is anonymous; otherwise, the mark can be
2003-07-17 06:38:40 +00:00
retrieved by name using <see cref= "Gtk.TextBuffer.GetMark(System.String)" /> . If a
2003-09-05 02:29:59 +00:00
mark has left gravity, and text is inserted at the
current location of the mark, the mark will be moved to the left of
2003-07-12 09:20:37 +00:00
the newly-inserted text. If the mark has right gravity
2003-07-31 21:44:39 +00:00
(ie. <paramref name= "left_gravity" /> = <see langword= "false" /> ), the mark will end up on the right
2003-07-12 09:20:37 +00:00
of newly-inserted text. The standard left-to-right cursor
is a mark with right gravity (when you type, the cursor
2003-09-05 02:29:59 +00:00
stays on the right side of the text you are typing).
2003-07-12 09:20:37 +00:00
</para>
<para >
Fires the <see cref= "E:Gtk.TextBuffer.MarkSet" /> event as
2003-09-05 02:29:59 +00:00
notification of the initial placement of the mark.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "CopyClipboard" >
<MemberSignature Language= "C#" Value= "public void CopyClipboard (Gtk.Clipboard clipboard);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2004-06-23 23:23:24 +00:00
<summary > Copies the buffer's selected text to the given <see cref= "T:Gtk.Clipboard" /> .</summary>
<param name= "clipboard" > The <see cref= "T:Gtk.Clipboard" /> to copy the text to.</param>
<remarks >
<para > Copying a <see cref= "T:Gtk.TextView" /> 's selected text:</para>
<example >
<code lang= "C#" > void Copy (Gtk.TextView view) {
Gtk.TextBuffer buffer = view.Buffer;
Gtk.Clipboard board = Clipboard.Get (Gdk.Selection.Clipboard);
buffer.CopyClipboard (board);
} </code>
</example>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
2003-07-16 02:07:51 +00:00
<Member MemberName= "MoveMark" >
<MemberSignature Language= "C#" Value= "public void MoveMark (string name, Gtk.TextIter where);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "name" Type= "System.String" />
<Parameter Name= "where" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Moves the mark named <paramref name= "name" /> (which must
exist) to location <paramref name= "where" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "name" > the name of the mark</param>
<param name= "where" > the new location for mark</param>
<remarks >
2005-01-12 19:31:30 +00:00
<para > It is possible to use built-in marks to implement a "Select All" method on a buffer (e.g. <see cref= "M:Gtk.TextView.Buffer" /> ).</para>
2003-07-12 09:20:37 +00:00
<para >
2005-01-12 19:31:30 +00:00
<example >
<code lang= "C#" >
private void SelectAll (TextBuffer buffer)
{
buffer.MoveMark ("insert", buffer.StartIter);
buffer.MoveMark ("selection_bound", buffer.EndIter);
}
</code>
</example>
2003-07-12 09:20:37 +00:00
</para>
2005-01-12 19:31:30 +00:00
<para > See <see cref= "M:Gtk.TextBuffer.MoveMark(Gtk.TextMark,Gtk.TextIter)" /> for more details.</para>
2003-07-12 09:20:37 +00:00
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "InsertRangeInteractive" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public bool InsertRangeInteractive (ref Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end, bool default_editable);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-09-05 02:29:59 +00:00
Same as <see cref= "M:Gtk.TextBuffer.InsertRange(Gtk.TextIter,Gtk.TextIter,Gtk.TextIter)" /> , but does nothing if the insertion point is not editable.
2003-07-12 09:20:37 +00:00
</summary>
<param name= "iter" > a position in buffer</param>
<param name= "start" >
2003-07-17 06:38:40 +00:00
a position in the source <see cref= "Gtk.TextBuffer" /> </param>
2003-07-12 09:20:37 +00:00
<param name= "end" >
2003-07-17 06:38:40 +00:00
a position in the source <see cref= "Gtk.TextBuffer" /> </param>
2003-07-12 09:20:37 +00:00
<param name= "default_editable" >
2003-07-31 21:44:39 +00:00
whether the text is editable at <paramref name= "iter" /> if no tags enclosing
2003-07-12 09:20:37 +00:00
iter affect editability
</param>
<returns >
2003-07-31 21:44:39 +00:00
<see langword= "true" /> if an insertion was possible at <paramref name= "iter" /> </returns>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-09-05 02:29:59 +00:00
Same as <see cref= "M:Gtk.TextBuffer.InsertRange(Gtk.TextIter,Gtk.TextIter,Gtk.TextIter)" /> , but does nothing if the insertion point is not
2003-07-12 09:20:37 +00:00
editable.
</para>
<para >
2003-07-31 21:44:39 +00:00
The <paramref name= "default_editable" /> parameter
indicates whether the text is editable at <paramref name= "iter" /> if no tags
2003-07-12 09:20:37 +00:00
enclosing iter affect editability. Typically the result of
<see cref= "P:Gtk.TextView.Editable" /> is appropriate here.
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "GetText" >
<MemberSignature Language= "C#" Value= "public string GetText (Gtk.TextIter start, Gtk.TextIter end, bool include_hidden_chars);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.String</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
<Parameter Name= "include_hidden_chars" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Returns the text from a specified range</summary>
<param name= "start" > the beginning of the specified range</param>
<param name= "end" > the end of the specified range</param>
<param name= "include_hidden_chars" > whether to include invisible text</param>
<returns > a string containing the text from the specified range</returns>
<remarks >
<para >
2005-12-27 14:12:35 +00:00
Returns the text in the range specified by <paramref name= "start" /> and <paramref name= "end" /> . Excludes
2003-07-12 09:20:37 +00:00
undisplayed text (text marked with tags that set the
2003-07-31 21:44:39 +00:00
invisibility attribute) if <paramref name= "include_hidden_chars" /> is <see langword= "false" /> . Does not include characters
2003-07-12 09:20:37 +00:00
representing embedded images, so byte and character
indexes into the returned string do not correspond to byte
and character indexes into the buffer.
</para>
<para >
2004-11-04 19:34:16 +00:00
Contrast this with <see cref= "M:Gtk.TextBuffer.GetSlice(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> .
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
2003-07-16 02:07:51 +00:00
<Member MemberName= "ApplyTag" >
<MemberSignature Language= "C#" Value= "public void ApplyTag (string name, Gtk.TextIter start, Gtk.TextIter end);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "name" Type= "System.String" />
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
Fires the <see cref= "E:Gtk.TextBuffer.TagApplied" /> event on buffer. The default handler
for the signal applies tag to the given range.
</summary>
<param name= "name" > the name of the tag</param>
<param name= "start" > the location of the beginning of the range</param>
<param name= "end" > the location of the end of the range</param>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
The order for <paramref name= "start" /> and <paramref name= "end" /> is not important.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "InsertPixbuf" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void InsertPixbuf (ref Gtk.TextIter iter, Gdk.Pixbuf pixbuf);" />
2003-02-12 02:00:12 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "pixbuf" Type= "Gdk.Pixbuf" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
2003-07-31 21:44:39 +00:00
Inserts an image into the text buffer at <paramref name= "iter" /> .
2003-07-12 09:20:37 +00:00
</summary>
<param name= "iter" > The location to insert the image</param>
<param name= "pixbuf" > The image to be inserted</param>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Inserts an image into the text buffer at <paramref name= "iter" /> . The image will be counted as one character in character counts, and
2003-07-12 09:20:37 +00:00
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
2003-07-17 06:38:40 +00:00
<see cref= "M:Gtk.TextBuffer.GetSlice(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> and <see cref= "M:Gtk.TextBuffer.GetText(Gtk.TextIter,Gtk.TextIter,System.Boolean)" /> .
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "CutClipboard" >
<MemberSignature Language= "C#" Value= "public void CutClipboard (Gtk.Clipboard clipboard, bool default_editable);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Copies the currently-selected text to a clipboard, then deletes said text if it is editable.</summary>
2003-09-05 02:29:59 +00:00
<param name= "clipboard" > an object of type <see cref= "T:Gtk.Clipboard" /> </param>
<param name= "default_editable" > an object of type <see cref= "T:System.Boolean" /> </param>
2004-07-22 21:52:21 +00:00
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public TextBuffer (IntPtr raw);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "raw" Type= "System.IntPtr" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-02-23 07:26:30 +00:00
<summary > Internal constructor</summary>
<param name= "raw" > Pointer to the C object.</param>
<remarks >
<para > This is an internal constructor, and should not be used by user code.</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "public TextBuffer (Gtk.TextTagTable table);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "table" Type= "Gtk.TextTagTable" />
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Creates a new text buffer.</summary>
<param name= "table" > a tag table, or <see langword= "null" /> to create a new one</param>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "Text" >
<MemberSignature Language= "C#" Value= "public string Text { set; get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.String</ReturnType>
</ReturnValue>
2003-12-24 01:35:30 +00:00
<Parameters >
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > The complete contents of the buffer</summary>
2005-05-23 20:41:51 +00:00
<value > The contents of the current buffer</value>
2003-07-12 09:20:37 +00:00
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-12-09 23:12:49 +00:00
<Attributes >
<Attribute >
<AttributeName > GLib.Property(Name="text")</AttributeName>
</Attribute>
</Attributes>
2003-02-12 02:00:12 +00:00
</Member>
<Member MemberName= "LineCount" >
<MemberSignature Language= "C#" Value= "public int LineCount { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Obtains the number of lines in the buffer.</summary>
2005-05-23 20:41:51 +00:00
<value > The number of lines in the buffer</value>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-09-05 02:29:59 +00:00
The results of this method is cached, so this is very fast.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "EndIter" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter EndIter { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > The end of the buffer</summary>
2005-05-23 20:41:51 +00:00
<value > The location of the end of the buffer</value>
2003-07-12 09:20:37 +00:00
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "Modified" >
<MemberSignature Language= "C#" Value= "public bool Modified { set; get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
2003-12-24 01:35:30 +00:00
<Parameters >
</Parameters>
2003-02-12 02:00:12 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Whether or not the buffer has been modified</summary>
2005-05-23 20:41:51 +00:00
<value >
2003-07-12 09:20:37 +00:00
<see langword= "true" /> if the buffer has
been modified, <see langword= "false" /> otherwise.
2005-05-23 20:41:51 +00:00
</value>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
Whenever the buffer is saved to disk, set this property to
<see langword= "false" /> . When the buffer is modified, it
will automatically toggled to <see langword= "true" /> .
</para>
<para >
2005-09-19 00:36:43 +00:00
Whenever this property is changed, the <see cref= "E:Gtk.TextBuffer.ModifiedChanged" /> event is raised.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "TagTable" >
<MemberSignature Language= "C#" Value= "public Gtk.TextTagTable TagTable { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextTagTable</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > The tag table of the current buffer</summary>
2005-05-23 20:41:51 +00:00
<value > The current <see cref= "T:Gtk.TextTagTable" /> of the buffer</value>
2003-07-12 09:20:37 +00:00
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
2005-12-09 23:12:49 +00:00
<AttributeName > GLib.Property(Name="tag-table")</AttributeName>
2005-05-23 20:41:51 +00:00
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "SelectionBound" >
<MemberSignature Language= "C#" Value= "public Gtk.TextMark SelectionBound { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextMark</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Returns the mark that represents the selection bound.</summary>
2005-05-23 20:41:51 +00:00
<value > a <see cref= "T:Gtk.TextMark" /> </value>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
Returns the mark that represents the selection
2003-07-17 06:38:40 +00:00
bound. Equivalent to calling <see cref= "Gtk.TextBuffer.GetMark(System.String)" /> to
2003-07-12 09:20:37 +00:00
get the mark named "selection_bound", but very slightly
more efficient, and involves less typing.
</para>
<para >
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
2003-07-17 06:38:40 +00:00
there is no current selection. <see cref= "M:Gtk.TextBuffer.GetSelectionBounds(Gtk.TextIter,Gtk.TextIter)" /> is another convenient function for handling the
2003-09-05 02:29:59 +00:00
selection, if you just want to know whether there is a
2003-07-12 09:20:37 +00:00
selection and what its bounds are.
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "InsertMark" >
<MemberSignature Language= "C#" Value= "public Gtk.TextMark InsertMark { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextMark</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Returns the mark that represents the cursor (insertion point).</summary>
2005-05-23 20:41:51 +00:00
<value > The mark of the insert point.</value>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-07-17 06:38:40 +00:00
This is equivelant to calling <see cref= "M:Gtk.TextBuffer.GetMark(System.String)" /> for the
2003-07-12 09:20:37 +00:00
mark named "insert".
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "CharCount" >
<MemberSignature Language= "C#" Value= "public int CharCount { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > System.Int32</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > The number of characters in the buffer</summary>
2005-05-23 20:41:51 +00:00
<value > The number of characters in the buffer</value>
2003-07-12 09:20:37 +00:00
<remarks >
<para > The result of this method is cached, so it is very fast.</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "StartIter" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter StartIter { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Docs >
2003-07-12 09:20:37 +00:00
<summary > The location of the beginning of the buffer</summary>
2005-05-23 20:41:51 +00:00
<value > The location of the beginning of the buffer</value>
2003-07-12 09:20:37 +00:00
<remarks >
<para >
2003-07-17 06:38:40 +00:00
This is the equivelant to calling <see cref= "M:Gtk.TextBuffer.GetIterAtOffset(System.Int32)" /> to get the iter at character offset 0.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-02-12 02:00:12 +00:00
</Docs>
</Member>
<Member MemberName= "UserActionEnded" >
<MemberSignature Language= "C#" Value= "public event EventHandler UserActionEnded;" />
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
<ReturnType > System.EventHandler</ReturnType>
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a UserAction ends on the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="end_user_action")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "TagRemoved" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.TagRemovedHandler TagRemoved;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.TagRemovedHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a tag is removed from the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="remove_tag")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "UserActionBegun" >
<MemberSignature Language= "C#" Value= "public event EventHandler UserActionBegun;" />
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
<ReturnType > System.EventHandler</ReturnType>
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a UserAction is begun on the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="begin_user_action")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "MarkSet" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.MarkSetHandler MarkSet;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.MarkSetHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a mark is set in the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="mark_set")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "TagApplied" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.TagAppliedHandler TagApplied;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.TagAppliedHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a tag is applied to the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="apply_tag")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "ChildAnchorInserted" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.ChildAnchorInsertedHandler ChildAnchorInserted;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.ChildAnchorInsertedHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a ChildAnchor has been inserted in the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="insert_child_anchor")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "MarkDeleted" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.MarkDeletedHandler MarkDeleted;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.MarkDeletedHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a mark has been deleted from the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="mark_deleted")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "DeleteRange" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.DeleteRangeHandler DeleteRange;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.DeleteRangeHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a range of text has been deleted from the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="delete_range")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "PixbufInserted" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.PixbufInsertedHandler PixbufInserted;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.PixbufInsertedHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when a Pixbuf is inserted into the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="insert_pixbuf")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "Changed" >
<MemberSignature Language= "C#" Value= "public event EventHandler Changed;" />
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
<ReturnType > System.EventHandler</ReturnType>
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when the text in the buffer has been changed.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="changed")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "InsertText" >
2004-02-25 23:39:06 +00:00
<MemberSignature Language= "C#" Value= "public event Gtk.InsertTextHandler InsertText;" />
2003-02-12 02:00:12 +00:00
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
2004-02-25 23:39:06 +00:00
<ReturnType > Gtk.InsertTextHandler</ReturnType>
2003-07-31 21:44:39 +00:00
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when text is inserted into the buffer.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="insert_text")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-02-12 02:00:12 +00:00
<Member MemberName= "ModifiedChanged" >
<MemberSignature Language= "C#" Value= "public event EventHandler ModifiedChanged;" />
<MemberType > Event</MemberType>
2003-07-31 21:44:39 +00:00
<ReturnValue >
<ReturnType > System.EventHandler</ReturnType>
</ReturnValue>
2003-02-12 02:00:12 +00:00
<Parameters />
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Emitted when the Modified status of the buffer is changed.</summary>
<remarks />
2003-02-12 02:00:12 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > GLib.Signal(CName="modified_changed")</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2003-03-07 01:30:00 +00:00
<Member MemberName= "GetIterAtOffset" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtOffset (int char_offset);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "char_offset" Type= "System.Int32" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Returns the location at a particular character offset</summary>
<param name= "char_offset" > The requested character offset</param>
2003-07-31 21:44:39 +00:00
<returns > The location at <paramref name= "char_offset" /> </returns>
2003-07-12 09:20:37 +00:00
<remarks />
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
<Member MemberName= "InsertAtCursor" >
<MemberSignature Language= "C#" Value= "public void InsertAtCursor (string text);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "text" Type= "System.String" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Insert text into the current cursor position</summary>
<param name= "text" > The text to be inserted</param>
<remarks >
<para >
The <see cref= "E:Gtk.TextBuffer.InsertText" /> event is
2005-09-19 00:36:43 +00:00
raised when a call to this method is made.
2003-07-12 09:20:37 +00:00
</para>
</remarks>
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
<Member MemberName= "Insert" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void Insert (ref Gtk.TextIter iter, string text);" />
2003-03-07 01:30:00 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "text" Type= "System.String" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Insert text at a specific point</summary>
<param name= "iter" >
2003-07-31 21:44:39 +00:00
The location for <paramref name= "text" /> to be
2003-07-12 09:20:37 +00:00
inserted
</param>
<param name= "text" > The text to be inserted</param>
<remarks />
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
<Member MemberName= "InsertInteractiveAtCursor" >
<MemberSignature Language= "C#" Value= "public bool InsertInteractiveAtCursor (string text, bool default_editable);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "text" Type= "System.String" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Insert text at cursor position if the location is editable</summary>
<param name= "text" > The text to be inserted</param>
<param name= "default_editable" > The default editability of the buffer</param>
2003-07-31 21:44:39 +00:00
<returns > Whether or not <paramref name= "text" /> was inserted</returns>
2003-07-12 09:20:37 +00:00
<remarks >
2003-07-17 06:38:40 +00:00
See <see cref= "M:Gtk.TextBuffer.InsertInteractive(Gtk.TextIter,System.String,System.Boolean)" /> for more details.
2003-07-12 09:20:37 +00:00
</remarks>
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
<Member MemberName= "InsertInteractive" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public bool InsertInteractive (ref Gtk.TextIter iter, string text, bool default_editable);" />
2003-03-07 01:30:00 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2003-07-31 21:44:39 +00:00
<Parameter Name= "text" Type= "System.String" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary >
Insert text if the cursor is at an editable point in
the buffer
</summary>
<param name= "iter" > a location in the buffer</param>
<param name= "text" > the text to be inserted</param>
<param name= "default_editable" > the default editability of buffer</param>
<returns > whether text was actually inserted</returns>
<remarks >
<para >
2003-07-31 21:44:39 +00:00
Similar to <see cref= "M:Gtk.TextBuffer.Insert(Gtk.TextIter,System.String)" /> , but the insertion will not occur if <paramref name= "iter" /> is at a non-editable location in the
2003-07-12 09:20:37 +00:00
buffer. Usually you want to prevent insertions at
ineditable locations if the insertion results from a user
action (is interactive).
</para>
<para >
2003-07-31 21:44:39 +00:00
<paramref name= "default_editable" /> indicates the editability of text that
2003-09-05 02:29:59 +00:00
does not have a tag affecting editability applied to
2003-07-17 06:38:40 +00:00
it. Typically the result of <see cref= "P:Gtk.TextView.Editable" />
2003-07-12 09:20:37 +00:00
is appropriate here.
</para>
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
<Member MemberName= "SetText" >
<MemberSignature Language= "C#" Value= "public void SetText (string text);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "text" Type= "System.String" />
</Parameters>
2003-03-07 01:30:00 +00:00
<Docs >
2003-07-12 09:20:37 +00:00
<summary > Set the contents of the buffer</summary>
<param name= "text" > The new contents of the buffer</param>
<remarks >
<para >
This is equivelant to using the setter of the
<see cref= "P:Gtk.TextBuffer.Text" /> property.
</para>
</remarks>
2003-03-07 01:30:00 +00:00
</Docs>
</Member>
2003-07-17 06:38:40 +00:00
<Member MemberName= "PasteClipboard" >
<MemberSignature Language= "C#" Value= "public void PasteClipboard (Gtk.Clipboard clipboard);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2003-07-31 21:44:39 +00:00
<Parameter Name= "clipboard" Type= "Gtk.Clipboard" />
</Parameters>
2003-07-17 06:38:40 +00:00
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Pastes the contents of a clipboard at the insertion point.</summary>
2003-07-17 06:38:40 +00:00
<param name= "clipboard" > a <see cref= "T:Gtk.Clipboard" /> </param>
2004-07-22 21:52:21 +00:00
<remarks />
2003-07-17 06:38:40 +00:00
</Docs>
</Member>
2003-12-24 01:35:30 +00:00
<Member MemberName= "GType" >
<MemberSignature Language= "C#" Value= "public static GLib.GType GType { get; };" />
<MemberType > Property</MemberType>
<ReturnValue >
<ReturnType > GLib.GType</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-21 20:14:42 +00:00
<summary > GType Property.</summary>
2005-05-23 20:41:51 +00:00
<value > a <see cref= "T:GLib.GType" /> </value>
2004-06-21 20:14:42 +00:00
<remarks > Returns the native <see cref= "T:GLib.GType" /> value for <see cref= "T:Gtk.TextBuffer" /> .</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnModifiedChanged" >
<MemberSignature Language= "C#" Value= "protected virtual void OnModifiedChanged ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.ModifiedChanged" /> event.</summary>
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.ModifiedChanged" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnInsertText" >
<MemberSignature Language= "C#" Value= "protected virtual void OnInsertText (Gtk.TextIter pos, string text);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "pos" Type= "Gtk.TextIter" />
<Parameter Name= "text" Type= "System.String" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.InsertText" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "pos" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "text" > a <see cref= "T:System.String" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.InsertText" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnChanged" >
<MemberSignature Language= "C#" Value= "protected virtual void OnChanged ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.Changed" /> event.</summary>
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.Changed" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnPixbufInserted" >
<MemberSignature Language= "C#" Value= "protected virtual void OnPixbufInserted (Gtk.TextIter pos, Gdk.Pixbuf pixbuf);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "pos" Type= "Gtk.TextIter" />
<Parameter Name= "pixbuf" Type= "Gdk.Pixbuf" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.PixbufInserted" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "pos" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "pixbuf" > a <see cref= "T:Gdk.Pixbuf" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.PixbufInserted" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnDeleteRange" >
<MemberSignature Language= "C#" Value= "protected virtual void OnDeleteRange (Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.DeleteRange" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "start" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "end" > a <see cref= "T:Gtk.TextIter" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.DeleteRange" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnMarkDeleted" >
<MemberSignature Language= "C#" Value= "protected virtual void OnMarkDeleted (Gtk.TextMark mark);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "mark" Type= "Gtk.TextMark" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.MarkDeleted" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "mark" > a <see cref= "T:Gtk.TextMark" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.MarkDeleted" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnChildAnchorInserted" >
<MemberSignature Language= "C#" Value= "protected virtual void OnChildAnchorInserted (Gtk.TextIter pos, Gtk.TextChildAnchor anchor);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "pos" Type= "Gtk.TextIter" />
<Parameter Name= "anchor" Type= "Gtk.TextChildAnchor" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.ChildAnchorInserted" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "pos" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "anchor" > a <see cref= "T:Gtk.TextChildAnchor" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.ChildAnchorInserted" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnTagApplied" >
<MemberSignature Language= "C#" Value= "protected virtual void OnTagApplied (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "tag" Type= "Gtk.TextTag" />
<Parameter Name= "start_char" Type= "Gtk.TextIter" />
<Parameter Name= "end_char" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.TagApplied" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "tag" > a <see cref= "T:Gtk.TextTag" /> </param>
<param name= "start_char" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "end_char" > a <see cref= "T:Gtk.TextIter" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.TagApplied" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnMarkSet" >
<MemberSignature Language= "C#" Value= "protected virtual void OnMarkSet (Gtk.TextIter location, Gtk.TextMark mark);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "location" Type= "Gtk.TextIter" />
<Parameter Name= "mark" Type= "Gtk.TextMark" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.MarkSet" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "location" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "mark" > a <see cref= "T:Gtk.TextMark" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.MarkSet" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnUserActionBegun" >
<MemberSignature Language= "C#" Value= "protected virtual void OnUserActionBegun ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.UserActionBegun" /> event.</summary>
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.UserActionBegun" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnTagRemoved" >
<MemberSignature Language= "C#" Value= "protected virtual void OnTagRemoved (Gtk.TextTag tag, Gtk.TextIter start_char, Gtk.TextIter end_char);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "tag" Type= "Gtk.TextTag" />
<Parameter Name= "start_char" Type= "Gtk.TextIter" />
<Parameter Name= "end_char" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.TagRemoved" /> event.</summary>
2003-12-24 01:35:30 +00:00
<param name= "tag" > a <see cref= "T:Gtk.TextTag" /> </param>
<param name= "start_char" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "end_char" > a <see cref= "T:Gtk.TextIter" /> </param>
2004-06-15 15:41:25 +00:00
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.TagRemoved" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= "OnUserActionEnded" >
<MemberSignature Language= "C#" Value= "protected virtual void OnUserActionEnded ();" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters />
<Docs >
2004-06-15 15:41:25 +00:00
<summary > Default handler for the <see cref= "M:Gtk.TextBuffer.UserActionEnded" /> event.</summary>
<remarks > Override this method in a subclass to provide a default handler for the <see cref= "M:Gtk.TextBuffer.UserActionEnded" /> event.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
</Member>
<Member MemberName= ".ctor" >
<MemberSignature Language= "C#" Value= "protected TextBuffer (GLib.GType gtype);" />
<MemberType > Constructor</MemberType>
<ReturnValue />
<Parameters >
<Parameter Name= "gtype" Type= "GLib.GType" />
</Parameters>
<Docs >
2004-06-21 20:33:11 +00:00
<summary > Protected Constructor.</summary>
2003-12-24 01:35:30 +00:00
<param name= "gtype" > a <see cref= "T:GLib.GType" /> </param>
2004-06-21 20:33:11 +00:00
<remarks > Chain to this constructor if you have manually registered a native <see cref= "T:GLib.GType" /> value for your subclass.</remarks>
2003-12-24 01:35:30 +00:00
</Docs>
2005-06-16 18:56:42 +00:00
<Attributes >
2005-05-23 20:41:51 +00:00
<Attribute >
<AttributeName > System.Obsolete(Message=null, IsError=False)</AttributeName>
</Attribute>
2005-06-16 18:56:42 +00:00
</Attributes>
</Member>
2004-02-26 18:46:28 +00:00
<Member MemberName= "GetIterAtLineOffset" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtLineOffset (int line_number, int char_offset);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "line_number" Type= "System.Int32" />
<Parameter Name= "char_offset" Type= "System.Int32" />
</Parameters>
<Docs >
2004-03-05 13:40:13 +00:00
<summary > Gets the location of a specific point.</summary>
2004-02-26 18:46:28 +00:00
<param name= "line_number" > a <see cref= "T:System.Int32" /> </param>
<param name= "char_offset" > a <see cref= "T:System.Int32" /> </param>
2004-03-05 13:40:13 +00:00
<returns > The location at the location specified by <paramref name= "line_number" /> and <paramref name= "char_offset" /> .</returns>
<remarks />
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
<Member MemberName= "GetIterAtLine" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtLine (int line_number);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "line_number" Type= "System.Int32" />
</Parameters>
<Docs >
2004-03-05 13:40:13 +00:00
<summary > Gets the location of a particular line.</summary>
<param name= "line_number" > The specified line number.</param>
<returns > The location at the beginning fo the line as specified by <paramref name= "line_number" /> .</returns>
<remarks />
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
<Member MemberName= "GetIterAtMark" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtMark (Gtk.TextMark mark);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "mark" Type= "Gtk.TextMark" />
</Parameters>
<Docs >
2004-03-05 13:40:13 +00:00
<summary > Gets the location of the specified mark.</summary>
<param name= "mark" > The specified mark.</param>
<returns > The location of <paramref name= "mark" /> .</returns>
<remarks />
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
<Member MemberName= "GetIterAtChildAnchor" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtChildAnchor (Gtk.TextChildAnchor anchor);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "anchor" Type= "Gtk.TextChildAnchor" />
</Parameters>
<Docs >
2004-03-05 13:40:13 +00:00
<summary > Gets the location of the specific anchor.</summary>
<param name= "anchor" > A <see cref= "T:Gtk.TextChildAnchor" /> at the current buffer.</param>
<returns > The location at <paramref name= "anchor" /> .</returns>
<remarks />
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
<Member MemberName= "GetIterAtLineIndex" >
<MemberSignature Language= "C#" Value= "public Gtk.TextIter GetIterAtLineIndex (int line_number, int byte_index);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > Gtk.TextIter</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "line_number" Type= "System.Int32" />
<Parameter Name= "byte_index" Type= "System.Int32" />
</Parameters>
<Docs >
2004-03-05 13:40:13 +00:00
<summary > Obtains an iterator pointing to <paramref name= "byte_index" /> within the given line.</summary>
<param name= "line_number" > A line number for the current buffer, counting from 0.</param>
<param name= "byte_index" > The byte index from start of line.</param>
<returns > The location as specified by <paramref name= "line_number" /> and <paramref name= "byte_index" /> .</returns>
<remarks >
<para >
<paramref name= "byte_index" /> 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.
</para>
</remarks>
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
<Member MemberName= "InsertWithTags" >
2004-12-03 18:00:30 +00:00
<MemberSignature Language= "C#" Value= "public void InsertWithTags (ref Gtk.TextIter iter, string text, Gtk.TextTag[] tags);" />
2004-02-26 18:46:28 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
2004-12-03 18:00:30 +00:00
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
2004-02-26 18:46:28 +00:00
<Parameter Name= "text" Type= "System.String" />
2005-05-23 20:41:51 +00:00
<Parameter Name= "tags" Type= "Gtk.TextTag[]" >
<Attributes >
<Attribute >
<AttributeName > System.ParamArray</AttributeName>
</Attribute>
</Attributes>
</Parameter>
2004-02-26 18:46:28 +00:00
</Parameters>
<Docs >
2004-07-22 21:52:21 +00:00
<summary > Inserts <paramref name= "text" /> into buffer at <paramref name= "iter" /> , applying the list of <paramref name= "tags" /> to the newly-inserted text.</summary>
2004-12-03 18:00:30 +00:00
<param name= "iter" > location to insert the text</param>
<param name= "text" > text to insert</param>
<param name= "tags" > tags to apply to <paramref name= "text" /> </param>
<remarks > Equivalent to calling <see cref= "M:Gtk.TextBuffer.Insert()" /> , then <see cref= "Gtk.TextBuffer.ApplyTag()" /> on the inserted text; It is just a convenience function.</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2004-12-03 18:00:30 +00:00
</Docs>
</Member>
<Member MemberName= "InsertWithTagsByName" >
2005-05-23 20:41:51 +00:00
<MemberSignature Language= "C#" Value= "public void InsertWithTagsByName (ref Gtk.TextIter iter, string text, string[] tagnames);" />
2004-12-03 18:00:30 +00:00
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
<Parameter Name= "text" Type= "System.String" />
2005-05-23 20:41:51 +00:00
<Parameter Name= "tagnames" Type= "System.String[]" >
<Attributes >
<Attribute >
<AttributeName > System.ParamArray</AttributeName>
</Attribute>
</Attributes>
</Parameter>
2004-12-03 18:00:30 +00:00
</Parameters>
<Docs >
<summary > Inserts <paramref name= "text" /> into buffer at <paramref name= "iter" /> , applying the list of tags with names <paramref name= "tagnamess" /> to the newly-inserted text.</summary>
<param name= "iter" > location to insert the text</param>
<param name= "text" > text to insert</param>
<param name= "tagnames" > names of the tags to apply to <paramref name= "text" /> </param>
2004-07-22 21:52:21 +00:00
<remarks > Equivalent to calling <see cref= "M:Gtk.TextBuffer.Insert()" /> , then <see cref= "Gtk.TextBuffer.ApplyTag()" /> on the inserted text; It is just a convenience function.</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2004-02-26 18:46:28 +00:00
</Docs>
</Member>
2004-11-05 21:25:40 +00:00
<Member MemberName= "SelectRange" >
<MemberSignature Language= "C#" Value= "public void SelectRange (Gtk.TextIter ins, Gtk.TextIter bound);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "ins" Type= "Gtk.TextIter" />
<Parameter Name= "bound" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
2004-12-21 04:08:27 +00:00
<summary > This function moves the <paramref name= "insert" /> and
<paramref name= "selection_bound" /> marks simultaneously.
2004-12-14 22:04:26 +00:00
</summary>
2004-11-05 21:25:40 +00:00
<param name= "ins" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "bound" > a <see cref= "T:Gtk.TextIter" /> </param>
2004-12-14 22:04:26 +00:00
<remarks >
If you move them in two steps
2004-12-21 04:08:27 +00:00
with <see cref= "M:Gtk.TextBuffer.MoveMark" /> , you will temporarily select a
2004-12-14 22:04:26 +00:00
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.
</remarks>
2005-06-16 18:56:42 +00:00
<since version= "Gtk# 2.4" />
2004-11-05 21:25:40 +00:00
</Docs>
</Member>
2005-04-21 17:10:54 +00:00
<Member MemberName= "Backspace" >
<MemberSignature Language= "C#" Value= "public bool Backspace (ref Gtk.TextIter iter, bool interactive, bool default_editable);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Boolean</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "iter" Type= "Gtk.TextIter&" RefType= "ref" />
<Parameter Name= "interactive" Type= "System.Boolean" />
<Parameter Name= "default_editable" Type= "System.Boolean" />
</Parameters>
<Docs >
<summary > To be added</summary>
<param name= "iter" > a <see cref= "T:Gtk.TextIter" /> </param>
<param name= "interactive" > a <see cref= "T:System.Boolean" /> </param>
<param name= "default_editable" > a <see cref= "T:System.Boolean" /> </param>
<returns > a <see cref= "T:System.Boolean" /> </returns>
<remarks > To be added</remarks>
2005-06-16 19:27:40 +00:00
<since version= "Gtk# 2.6" />
2005-04-21 17:10:54 +00:00
</Docs>
</Member>
2005-10-24 17:08:40 +00:00
<Member MemberName= "InsertWithTags" >
<MemberSignature Language= "C#" Value= "public void InsertWithTags (Gtk.TextIter iter, string text, Gtk.TextTag[] tags);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "iter" Type= "Gtk.TextIter" />
<Parameter Name= "text" Type= "System.String" />
<Parameter Name= "tags" Type= "Gtk.TextTag[]" >
<Attributes >
<Attribute >
<AttributeName > System.ParamArray</AttributeName>
</Attribute>
</Attributes>
</Parameter>
</Parameters>
<Docs >
<param name= "iter" > To be added.</param>
<param name= "text" > To be added.</param>
<param name= "tags" > To be added.</param>
<summary > Inserts text with tag information.</summary>
<remarks > The overload is obsolete, replace by the ref TextIter overload.</remarks>
</Docs>
</Member>
<Member MemberName= "Insert" >
<MemberSignature Language= "C#" Value= "public void Insert (Gtk.TextIter iter, string text);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "iter" Type= "Gtk.TextIter" />
<Parameter Name= "text" Type= "System.String" />
</Parameters>
<Docs >
<param name= "iter" > To be added.</param>
<param name= "text" > To be added.</param>
<summary > Inserts text.</summary>
<remarks > The overload is obsolete, replace by the ref TextIter overload.</remarks>
</Docs>
</Member>
<Member MemberName= "InsertRange" >
<MemberSignature Language= "C#" Value= "public void InsertRange (Gtk.TextIter iter, Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "iter" Type= "Gtk.TextIter" />
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
<param name= "iter" > To be added.</param>
<param name= "start" > To be added.</param>
<param name= "end" > To be added.</param>
<summary > Inserts a range of text.</summary>
<remarks > This overload is obsolete, replaced by ref TextIter overloads since the iters passed in are updated by the caller.</remarks>
</Docs>
</Member>
<Member MemberName= "Delete" >
<MemberSignature Language= "C#" Value= "public void Delete (Gtk.TextIter start, Gtk.TextIter end);" />
<MemberType > Method</MemberType>
<ReturnValue >
<ReturnType > System.Void</ReturnType>
</ReturnValue>
<Parameters >
<Parameter Name= "start" Type= "Gtk.TextIter" />
<Parameter Name= "end" Type= "Gtk.TextIter" />
</Parameters>
<Docs >
<param name= "start" > To be added.</param>
<param name= "end" > To be added.</param>
<summary > Delete text between two iterators.</summary>
<remarks > This overload is obsolete, replaced by ref TextIter overloads since the iters passed in are updated by the caller.</remarks>
</Docs>
</Member>
2003-02-12 02:00:12 +00:00
</Members>
2006-01-17 19:19:58 +00:00
</Type>
