* GtkTextBuffer:text:
*
* The text content of the buffer. Without child widgets and images,
- * see gtk_text_buffer_get_text () for more information.
+ * see gtk_text_buffer_get_text() for more information.
*
* Since: 2.8
*/
/**
* GtkTextBuffer:cursor-position:
*
- * The position of the insert mark (as offset from the beginning of the buffer).
- * It is useful for getting notified when the cursor moves.
+ * The position of the insert mark (as offset from the beginning
+ * of the buffer). It is useful for getting notified when the
+ * cursor moves.
*
* Since: 2.10
*/
* @location: position to insert @pixbuf in @textbuffer
* @pixbuf: the #GdkPixbuf to be inserted
*
- * The insert_pixbuf signal is emitted to insert a
- * #GdkPixbuf in a #GtkTextBuffer.
- * Insertion actually occurs in the default handler.
+ * The insert_pixbuf signal is emitted to insert a #GdkPixbuf
+ * in a #GtkTextBuffer. Insertion actually occurs in the default handler.
*
* Note that if your handler runs before the default handler it must not
* invalidate the @location iter (or has to revalidate it).
* The default signal handler revalidates it to be placed after the
* inserted @pixbuf.
*
- * See also:
- * gtk_text_buffer_insert_pixbuf().
+ * See also: gtk_text_buffer_insert_pixbuf().
*/
signals[INSERT_PIXBUF] =
g_signal_new (I_("insert_pixbuf"),
* #GtkTextChildAnchor in a #GtkTextBuffer.
* Insertion actually occurs in the default handler.
*
- * Note that if your handler runs before the default handler it must not
- * invalidate the @location iter (or has to revalidate it).
+ * Note that if your handler runs before the default handler it must
+ * not invalidate the @location iter (or has to revalidate it).
* The default signal handler revalidates it to be placed after the
* inserted @anchor.
*
- * See also:
- * gtk_text_buffer_insert_child_anchor().
+ * See also: gtk_text_buffer_insert_child_anchor().
*/
signals[INSERT_CHILD_ANCHOR] =
g_signal_new (I_("insert_child_anchor"),
* which run after the default handler (see g_signal_connect_after())
* do not have access to the deleted text.
*
- * See also:
- * gtk_text_buffer_delete().
+ * See also: gtk_text_buffer_delete().
*/
signals[DELETE_RANGE] =
g_signal_new (I_("delete_range"),
/**
* gtk_text_buffer_new:
- * @table: a tag table, or NULL to create a new one
+ * @table: a tag table, or %NULL to create a new one
*
* Creates a new text buffer.
*
* Return value: the buffer's tag table
**/
GtkTextTagTable*
-gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer)
+gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
static void
gtk_text_buffer_real_insert_text (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- const gchar *text,
- gint len)
+ GtkTextIter *iter,
+ const gchar *text,
+ gint len)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
* insertion occurs (because the buffer contents change), but the
* default signal handler revalidates it to point to the end of the
* inserted text.
- *
**/
void
gtk_text_buffer_insert (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- const gchar *text,
- gint len)
+ GtkTextIter *iter,
+ const gchar *text,
+ gint len)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
* @text: some text in UTF-8 format
* @len: length of text, in bytes
*
- * Simply calls gtk_text_buffer_insert (), using the current
+ * Simply calls gtk_text_buffer_insert(), using the current
* cursor position as the insertion point.
**/
void
gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
- const gchar *text,
- gint len)
+ const gchar *text,
+ gint len)
{
GtkTextIter iter;
* @default_editable: default editability of buffer
*
* Like gtk_text_buffer_insert(), but the insertion will not occur if
- * @iter is at a non-editable location in the buffer. Usually you
+ * @iter is at a non-editable location in the buffer. Usually you
* want to prevent insertions at ineditable locations if the insertion
* results from a user action (is interactive).
*
* @len: length of text in bytes, or -1
* @default_editable: default editability of buffer
*
- * Calls gtk_text_buffer_insert_interactive () at the cursor
+ * Calls gtk_text_buffer_insert_interactive() at the cursor
* position.
*
* @default_editable indicates the editability of text that doesn't
*
* Inserts @text into @buffer at @iter, applying the list of tags to
* the newly-inserted text. The last tag specified must be NULL to
- * terminate the list. Equivalent to calling gtk_text_buffer_insert (),
- * then gtk_text_buffer_apply_tag () on the inserted text;
- * gtk_text_buffer_insert_with_tags () is just a convenience function.
+ * terminate the list. Equivalent to calling gtk_text_buffer_insert(),
+ * then gtk_text_buffer_apply_tag() on the inserted text;
+ * gtk_text_buffer_insert_with_tags() is just a convenience function.
**/
void
gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer,
* @first_tag_name: name of a tag to apply to @text
* @Varargs: more tag names
*
- * Same as gtk_text_buffer_insert_with_tags (), but allows you
+ * Same as gtk_text_buffer_insert_with_tags(), but allows you
* to pass in tag names instead of tag objects.
**/
void
* @end: another position in @buffer
*
* Deletes text between @start and @end. The order of @start and @end
- * is not actually relevant; gtk_text_buffer_delete () will reorder
+ * is not actually relevant; gtk_text_buffer_delete() will reorder
* them. This function actually emits the "delete_range" signal, 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, the @start and @end will be
* re-initialized to point to the location where text was deleted.
- *
**/
void
gtk_text_buffer_delete (GtkTextBuffer *buffer,
* @default_editable: whether the buffer is editable by default
*
* Deletes all <emphasis>editable</emphasis> text in the given range.
- * Calls gtk_text_buffer_delete () for each editable sub-range of
+ * Calls gtk_text_buffer_delete() for each editable sub-range of
* [@start,@end). @start and @end are revalidated to point to
* the location of the last deleted range, or left untouched if
* no text was deleted.
* representing embedded images, so byte and character indexes into
* the returned string do <emphasis>not</emphasis> correspond to byte
* and character indexes into the buffer. Contrast with
- * gtk_text_buffer_get_slice ().
+ * gtk_text_buffer_get_slice().
*
* Return value: an allocated UTF-8 string
**/
gchar*
-gtk_text_buffer_get_text (GtkTextBuffer *buffer,
+gtk_text_buffer_get_text (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
- gboolean include_hidden_chars)
+ gboolean include_hidden_chars)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (start != NULL, NULL);
* embedded images, so byte and character indexes into
* the returned string <emphasis>do</emphasis> correspond to byte
* and character indexes into the buffer. Contrast with
- * gtk_text_buffer_get_text (). Note that 0xFFFC can occur in normal
+ * gtk_text_buffer_get_text(). 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.
*
* Return value: an allocated UTF-8 string
**/
gchar*
-gtk_text_buffer_get_slice (GtkTextBuffer *buffer,
+gtk_text_buffer_get_slice (GtkTextBuffer *buffer,
const GtkTextIter *start,
const GtkTextIter *end,
- gboolean include_hidden_chars)
+ gboolean include_hidden_chars)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
g_return_val_if_fail (start != NULL, NULL);
*/
static void
-gtk_text_buffer_real_insert_pixbuf (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- GdkPixbuf *pixbuf)
+gtk_text_buffer_real_insert_pixbuf (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ GdkPixbuf *pixbuf)
{
_gtk_text_btree_insert_pixbuf (iter, pixbuf);
* this character for pixbufs, but the "text" variants do
* not. e.g. see gtk_text_buffer_get_slice() and
* gtk_text_buffer_get_text().
- *
**/
void
-gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- GdkPixbuf *pixbuf)
+gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ GdkPixbuf *pixbuf)
{
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
g_return_if_fail (iter != NULL);
* by the Unicode "object replacement character" 0xFFFC. Note that the
* "slice" variants for obtaining portions of the buffer as a string
* include this character for child anchors, but the "text" variants do
- * not. e.g. see gtk_text_buffer_get_slice() and
+ * not. E.g. see gtk_text_buffer_get_slice() and
* gtk_text_buffer_get_text(). Consider
* gtk_text_buffer_create_child_anchor() as a more convenient
* alternative to this function. The buffer will add a reference to
* the anchor, so you can unref it after insertion.
- *
**/
void
gtk_text_buffer_insert_child_anchor (GtkTextBuffer *buffer,
* gtk_text_buffer_set_mark:
* @buffer: a #GtkTextBuffer
* @mark_name: name of the mark
- * @iter: location for the mark.
- * @left_gravity: if the mark is created by this function, gravity for the new
- * mark.
+ * @iter: location for the mark
+ * @left_gravity: if the mark is created by this function, gravity for
+ * the new mark
* @should_exist: if %TRUE, warn if the mark does not exist, and return
- * immediately.
+ * immediately
*
- * Move the mark to the given position, if not @should_exist, create the mark.
+ * Move the mark to the given position, if not @should_exist,
+ * create the mark.
*
* Return value: mark
**/
static GtkTextMark*
-gtk_text_buffer_set_mark (GtkTextBuffer *buffer,
- GtkTextMark *existing_mark,
- const gchar *mark_name,
+gtk_text_buffer_set_mark (GtkTextBuffer *buffer,
+ GtkTextMark *existing_mark,
+ const gchar *mark_name,
const GtkTextIter *iter,
- gboolean left_gravity,
- gboolean should_exist)
+ gboolean left_gravity,
+ gboolean should_exist)
{
GtkTextIter location;
GtkTextMark *mark;
*
* Creates a mark at position @where. If @mark_name is %NULL, the mark
* is anonymous; otherwise, the mark can be retrieved by name using
- * gtk_text_buffer_get_mark (). If a mark has left gravity, and text is
+ * gtk_text_buffer_get_mark(). If a mark has left gravity, and text is
* inserted at the mark's current location, the mark will be moved to
* the left of the newly-inserted text. If the mark has right gravity
* (@left_gravity = %FALSE), the mark will end up on the right of
* with right gravity (when you type, the cursor stays on the right
* side of the text you're typing).
*
- * The caller of this function does <emphasis>not</emphasis> own a reference
- * to the returned #GtkTextMark, so you can ignore the return value
- * if you like. Marks are owned by the buffer and go away when the
- * buffer does.
+ * The caller of this function does <emphasis>not</emphasis> own a
+ * reference to the returned #GtkTextMark, so you can ignore the
+ * return value if you like. Marks are owned by the buffer and go
+ * away when the buffer does.
*
* Emits the "mark_set" signal as notification of the mark's initial
* placement.
* Return value: the new #GtkTextMark object
**/
GtkTextMark*
-gtk_text_buffer_create_mark (GtkTextBuffer *buffer,
- const gchar *mark_name,
+gtk_text_buffer_create_mark (GtkTextBuffer *buffer,
+ const gchar *mark_name,
const GtkTextIter *where,
- gboolean left_gravity)
+ gboolean left_gravity)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), NULL);
* as notification of the move.
**/
void
-gtk_text_buffer_move_mark (GtkTextBuffer *buffer,
- GtkTextMark *mark,
+gtk_text_buffer_move_mark (GtkTextBuffer *buffer,
+ GtkTextMark *mark,
const GtkTextIter *where)
{
g_return_if_fail (GTK_IS_TEXT_MARK (mark));
**/
void
gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- GtkTextMark *mark)
+ GtkTextIter *iter,
+ GtkTextMark *mark)
{
g_return_if_fail (GTK_IS_TEXT_MARK (mark));
g_return_if_fail (!gtk_text_mark_get_deleted (mark));
* @buffer: a #GtkTextBuffer
* @name: a mark name
*
- * Returns the mark named @name in buffer @buffer, or NULL if no such
+ * Returns the mark named @name in buffer @buffer, or %NULL if no such
* mark exists in the buffer.
*
- * Return value: a #GtkTextMark, or NULL
+ * Return value: a #GtkTextMark, or %NULL
**/
GtkTextMark*
-gtk_text_buffer_get_mark (GtkTextBuffer *buffer,
- const gchar *name)
+gtk_text_buffer_get_mark (GtkTextBuffer *buffer,
+ const gchar *name)
{
GtkTextMark *mark;
* @where: new location for mark
*
* Moves the mark named @name (which must exist) to location @where.
- * See gtk_text_buffer_move_mark () for details.
+ * See gtk_text_buffer_move_mark() for details.
**/
void
gtk_text_buffer_move_mark_by_name (GtkTextBuffer *buffer,
* @name: name of a mark in @buffer
*
* Deletes the mark named @name; the mark must exist. See
- * gtk_text_buffer_delete_mark () for details.
+ * gtk_text_buffer_delete_mark() for details.
**/
void
-gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer,
- const gchar *name)
+gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer,
+ const gchar *name)
{
GtkTextMark *mark;
* @buffer: a #GtkTextBuffer
*
* Returns the mark that represents the cursor (insertion point).
- * Equivalent to calling gtk_text_buffer_get_mark () to get the mark
+ * Equivalent to calling gtk_text_buffer_get_mark() to get the mark
* named "insert", but very slightly more efficient, and involves less
* typing.
*
* @buffer: a #GtkTextBuffer
*
* Returns the mark that represents the selection bound. Equivalent
- * to calling gtk_text_buffer_get_mark () to get the mark named
+ * to calling gtk_text_buffer_get_mark() to get the mark named
* "selection_bound", but very slightly more efficient, and involves
* less typing.
*
* @anchor: a child anchor that appears in @buffer
*
* Obtains the location of @anchor within @buffer.
- *
**/
void
gtk_text_buffer_get_iter_at_child_anchor (GtkTextBuffer *buffer,
*
*
* Creates a tag and adds it to the tag table for @buffer.
- * Equivalent to calling gtk_text_tag_new () and then adding the
+ * Equivalent to calling gtk_text_tag_new() and then adding the
* tag to the buffer's tag table. The returned tag is owned by
* the buffer's tag table, so the ref count will be equal to one.
*
}
static void
-gtk_text_buffer_real_apply_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
+gtk_text_buffer_real_apply_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
const GtkTextIter *start,
const GtkTextIter *end)
{
}
static void
-gtk_text_buffer_real_remove_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
+gtk_text_buffer_real_remove_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
const GtkTextIter *start,
const GtkTextIter *end)
{
}
static void
-gtk_text_buffer_real_mark_set (GtkTextBuffer *buffer,
+gtk_text_buffer_real_mark_set (GtkTextBuffer *buffer,
const GtkTextIter *iter,
- GtkTextMark *mark)
+ GtkTextMark *mark)
{
GtkTextMark *insert;
}
static void
-gtk_text_buffer_emit_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
- gboolean apply,
+gtk_text_buffer_emit_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
+ gboolean apply,
const GtkTextIter *start,
const GtkTextIter *end)
{
* Emits the "apply_tag" signal on @buffer. The default
* handler for the signal applies @tag to the given range.
* @start and @end do not have to be in order.
- *
**/
void
-gtk_text_buffer_apply_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
+gtk_text_buffer_apply_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
const GtkTextIter *start,
const GtkTextIter *end)
{
* Emits the "remove_tag" signal. The default handler for the signal
* removes all occurrences of @tag from the given range. @start and
* @end don't have to be in order.
- *
**/
void
-gtk_text_buffer_remove_tag (GtkTextBuffer *buffer,
- GtkTextTag *tag,
+gtk_text_buffer_remove_tag (GtkTextBuffer *buffer,
+ GtkTextTag *tag,
const GtkTextIter *start,
const GtkTextIter *end)
*
* Calls gtk_text_tag_table_lookup() on the buffer's tag table to
* get a #GtkTextTag, then calls gtk_text_buffer_apply_tag().
- *
**/
void
-gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
- const gchar *name,
+gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
+ const gchar *name,
const GtkTextIter *start,
const GtkTextIter *end)
{
*
* Calls gtk_text_tag_table_lookup() on the buffer's tag table to
* get a #GtkTextTag, then calls gtk_text_buffer_remove_tag().
- *
- *
**/
void
-gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
- const gchar *name,
+gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
+ const gchar *name,
const GtkTextIter *start,
const GtkTextIter *end)
{
* line. The @char_offset must exist, offsets off the end of the line
* are not allowed. Note <emphasis>characters</emphasis>, not bytes;
* UTF-8 may encode one character as multiple bytes.
- *
**/
void
-gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- gint line_number,
- gint char_offset)
+gtk_text_buffer_get_iter_at_line_offset (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gint line_number,
+ gint char_offset)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
* @byte_index must be the start of a UTF-8 character, and must not be
* beyond the end of the line. Note <emphasis>bytes</emphasis>, not
* characters; UTF-8 may encode one character as multiple bytes.
- *
**/
void
gtk_text_buffer_get_iter_at_line_index (GtkTextBuffer *buffer,
* Initializes @iter to the start of the given line.
**/
void
-gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- gint line_number)
+gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gint line_number)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
* the iterator one past the last valid character in the buffer.
**/
void
-gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
- GtkTextIter *iter,
- gint char_offset)
+gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
+ GtkTextIter *iter,
+ gint char_offset)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
* 0. The entire buffer lies in the range from the first position in
* the buffer (call gtk_text_buffer_get_start_iter() to get
* character position 0) to the end iterator.
- *
**/
void
-gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer,
- GtkTextIter *iter)
+gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer,
+ GtkTextIter *iter)
{
g_return_if_fail (iter != NULL);
g_return_if_fail (GTK_IS_TEXT_BUFFER (buffer));
*
* Retrieves the first and last iterators in the buffer, i.e. the
* entire buffer lies within the range [@start,@end).
- *
**/
void
gtk_text_buffer_get_bounds (GtkTextBuffer *buffer,
* gtk_text_buffer_set_modified (@buffer, FALSE). When the buffer is modified,
* it will automatically toggled on the modified bit again. When the modified
* bit flips, the buffer emits a "modified_changed" signal.
- *
**/
void
-gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
- gboolean setting)
+gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
+ gboolean setting)
{
gboolean fixed_setting;
}
static void
-paste_from_buffer (ClipboardRequest *request_data,
- GtkTextBuffer *src_buffer,
- const GtkTextIter *start,
- const GtkTextIter *end)
+paste_from_buffer (ClipboardRequest *request_data,
+ GtkTextBuffer *src_buffer,
+ const GtkTextIter *start,
+ const GtkTextIter *end)
{
GtkTextIter insert_point;
GtkTextBuffer *buffer = request_data->buffer;
* @buffer: a #GtkTextBuffer
* @clipboard: a #GtkClipboard
*
- * Adds @clipboard to the list of clipboards in which the selection contents
- * of @buffer are available. In most cases, @clipboard will be the #GtkClipboard
- * of type %GDK_SELECTION_PRIMARY for a view of @buffer.
+ * Adds @clipboard to the list of clipboards in which the selection
+ * contents of @buffer are available. In most cases, @clipboard will be
+ * the #GtkClipboard of type %GDK_SELECTION_PRIMARY for a view of @buffer.
**/
void
gtk_text_buffer_add_selection_clipboard (GtkTextBuffer *buffer,
/**
* gtk_text_buffer_remove_selection_clipboard:
* @buffer: a #GtkTextBuffer
- * @clipboard: a #GtkClipboard added to @buffer by gtk_text_buffer_add_selection_clipboard().
+ * @clipboard: a #GtkClipboard added to @buffer by
+ * gtk_text_buffer_add_selection_clipboard()
*
- * Removes a #GtkClipboard added with gtk_text_buffer_add_selection_clipboard()
+ * Removes a #GtkClipboard added with
+ * gtk_text_buffer_add_selection_clipboard().
**/
void
gtk_text_buffer_remove_selection_clipboard (GtkTextBuffer *buffer,
* gtk_text_buffer_paste_clipboard:
* @buffer: a #GtkTextBuffer
* @clipboard: the #GtkClipboard to paste from
- * @override_location: location to insert pasted text, or %NULL for at the cursor
+ * @override_location: location to insert pasted text, or %NULL for
+ * at the cursor
* @default_editable: whether the buffer is editable by default
*
- * Pastes the contents of a clipboard at the insertion point, or at @override_location.
- * (Note: pasting is asynchronous, that is, we'll ask for the paste data and
- * return, and at some point later after the main loop runs, the paste
- * data will be inserted.)
- *
+ * Pastes the contents of a clipboard at the insertion point, or at
+ * @override_location. (Note: pasting is asynchronous, that is, we'll
+ * ask for the paste data and return, and at some point later after
+ * the main loop runs, the paste data will be inserted.)
**/
void
gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
* re-initialized to point to the location where text was deleted.
*
* Return value: %TRUE if the buffer was modified
-
+ *
* Since: 2.6
**/
gboolean
/**
* gtk_text_buffer_cut_clipboard:
* @buffer: a #GtkTextBuffer
- * @clipboard: the #GtkClipboard object to cut to.
+ * @clipboard: the #GtkClipboard object to cut to
* @default_editable: default editability of the buffer
*
* Copies the currently-selected text to a clipboard, then deletes
* said text if it's editable.
- *
**/
void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
/**
* gtk_text_buffer_copy_clipboard:
* @buffer: a #GtkTextBuffer
- * @clipboard: the #GtkClipboard object to copy to.
+ * @clipboard: the #GtkClipboard object to copy to
*
* Copies the currently-selected text to a clipboard.
- *
**/
void
gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer,
* Return value: whether the selection has nonzero length
**/
gboolean
-gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer,
- GtkTextIter *start,
- GtkTextIter *end)
+gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer,
+ GtkTextIter *start,
+ GtkTextIter *end)
{
g_return_val_if_fail (GTK_IS_TEXT_BUFFER (buffer), FALSE);
* gtk_text_buffer_end_user_action() can then be grouped when creating
* an undo stack. #GtkTextBuffer maintains a count of calls to
* gtk_text_buffer_begin_user_action() that have not been closed with
- * a call to gtk_text_buffer_end_user_action(), and emits the "begin_user_action"
- * and "end_user_action" signals only for the outermost pair of calls.
- * This allows you to build user actions from other user actions.
+ * a call to gtk_text_buffer_end_user_action(), and emits the
+ * "begin_user_action" and "end_user_action" signals only for the
+ * outermost pair of calls. This allows you to build user actions
+ * from other user actions.
*
* The "interactive" buffer mutation functions, such as
* gtk_text_buffer_insert_interactive(), automatically call begin/end
* provide for copying and as DND source. The targets in the list are
* added with %info values from the #GtkTextBufferTargetInfo enum,
* using gtk_target_list_add_rich_text_targets() and
- * gtk_target_list_add_text_targets()
+ * gtk_target_list_add_text_targets().
*
* Return value: the #GtkTargetList
*
* for pasting and as DND destination. The targets in the list are
* added with %info values from the #GtkTextBufferTargetInfo enum,
* using gtk_target_list_add_rich_text_targets() and
- * gtk_target_list_add_text_targets()
+ * gtk_target_list_add_text_targets().
*
* Return value: the #GtkTargetList
*
projects / ~andy / gtk / commitdiff