GtkTextBuffer

gtk_text_buffer_new ()

GtkTextBuffer *
gtk_text_buffer_new (GtkTextTagTable *table);

Создаёт новый буфер текста.

gtk_text_buffer_get_line_count ()

gint
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);

Получает количество строк в буфере. Это значение кэшируется, поэтому функция очень быстрая.

gtk_text_buffer_get_char_count ()

gint
gtk_text_buffer_get_char_count (GtkTextBuffer *buffer);

Получает количество символов в буфере; обратите внимание, что символы и байты не одно и то же, вы не можете, например, ожидать, что содержимое буфера в строковой форме будет иметь такую длину в байтах. Количество символов кэшируется, поэтому функция очень быстрая.

gtk_text_buffer_get_tag_table ()

GtkTextTagTable *
gtk_text_buffer_get_tag_table (GtkTextBuffer *buffer);

Получить связанную с этим буфером GtkTextTagTable.

gtk_text_buffer_insert ()

void
gtk_text_buffer_insert (GtkTextBuffer *buffer,
                        GtkTextIter *iter,
                        const gchar *text,
                        gint len);

Вставляет len байтов text в позицию iter . Если len равно -1, text должен быть нуль-терминированным и будет вставлен целиком. Издаёт сигнал «insert-text»; фактическая вставка происходит в обработчике по умолчанию для сигнала. iter становится недействительным при вставке (потому что содержимое буфера меняется), но обработчик сигнала по умолчанию пересоздаёт его, чтобы он указывал на конец вставленного текста.

gtk_text_buffer_insert_at_cursor ()

void
gtk_text_buffer_insert_at_cursor (GtkTextBuffer *buffer,
                                  const gchar *text,
                                  gint len);

Просто вызывает gtk_text_buffer_insert(), используя текущую позицию курсора в качестве точки вставки.

gtk_text_buffer_insert_interactive ()

gboolean
gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer,
                                    GtkTextIter *iter,
                                    const gchar *text,
                                    gint len,
                                    gboolean default_editable);

Подобно gtk_text_buffer_insert(), но вставка не произойдёт, если iter находится в нередактируемой позиции в буфере. Обычно вы хотите предотвратить вставки в нередактируемые позиции, если вставка происходит по действию пользователя (интерактивно).

default_editable указывает на редактируемость текста, к которому не применён влияющий на редактируемость тег. Обычно здесь подходит результат gtk_text_view_get_editable().

gtk_text_buffer_insert_interactive_at_cursor ()

gboolean
gtk_text_buffer_insert_interactive_at_cursor
                               (GtkTextBuffer *buffer,
                                const gchar *text,
                                gint len,
                                gboolean default_editable);

Вызывает gtk_text_buffer_insert_interactive() в позиции курсора.

default_editable указывает на редактируемость текста, к которому не применён влияющий на редактируемость тег. Обычно здесь подходит результат gtk_text_view_get_editable().

gtk_text_buffer_insert_range ()

void
gtk_text_buffer_insert_range (GtkTextBuffer *buffer,
                              GtkTextIter *iter,
                              const GtkTextIter *start,
                              const GtkTextIter *end);

Копирует текст, теги и пиксы между start и end (порядок start и end не важен) и вставляет копию в iter . Используется вместо простого получения/вставки текста, потому что сохраняет изображения и теги. Если start и end находятся в другом буфере, отличном от buffer, два буфера должны иметь одну и ту же таблицу тегов.

Реализовано через выбросы сигналов insert_text и apply_tag, поэтому ожидайте их.

gtk_text_buffer_insert_range_interactive ()

gboolean
gtk_text_buffer_insert_range_interactive
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                const GtkTextIter *start,
                                const GtkTextIter *end,
                                gboolean default_editable);

То же самое, что и gtk_text_buffer_insert_range(), но ничего не делает, если точка вставки не редактируема. Параметр default_editable указывает, редактируемый ли текст в позиции iter, если теги, окружающие iter, не влияют на редактируемость. Обычно результат gtk_text_view_get_editable() здесь подходит.

gtk_text_buffer_insert_with_tags ()

void
gtk_text_buffer_insert_with_tags (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  const gchar *text,
                                  gint len,
                                  GtkTextTag *first_tag,
                                  ...);

Вставляет text в buffer в позиции iter, применяя список тегов к нововставленному тексту. Последний указанный тег должен быть NULL для завершения списка. Эквивалентно вызову gtk_text_buffer_insert(), а затем gtk_text_buffer_apply_tag() на вставленном тексте; gtk_text_buffer_insert_with_tags() — просто удобная функция.

gtk_text_buffer_insert_with_tags_by_name ()

void
gtk_text_buffer_insert_with_tags_by_name
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                const gchar *text,
                                gint len,
                                const gchar *first_tag_name,
                                ...);

То же самое, что и gtk_text_buffer_insert_with_tags(), но позволяет передавать имена тегов вместо самих объектов тегов.

gtk_text_buffer_insert_markup ()

void
gtk_text_buffer_insert_markup (GtkTextBuffer *buffer,
                               GtkTextIter *iter,
                               const gchar *markup,
                               gint len);

Вставляет текст из markup в позицию iter. markup будет вставлен целиком и должен быть завершён нулём, а также являться допустимым UTF-8. Вызывает сигнал “insert-text”, возможно, несколько раз; фактическая вставка происходит в обработчике по умолчанию для сигнала. iter будет указывать на конец вставленного текста по возвращении.

Since: 3.16

gtk_text_buffer_delete ()

void
gtk_text_buffer_delete (GtkTextBuffer *buffer,
                        GtkTextIter *start,
                        GtkTextIter *end);

Удаляет текст между start и end. Порядок start и end на самом деле не важен; gtk_text_buffer_delete() их переупорядочит. Эта функция на самом деле вызывает сигнал “delete-range”, а обработчик по умолчанию для этого сигнала удаляет текст. Поскольку буфер изменяется, все активные итераторы становятся недействительными после вызова этой функции; однако start и end будут перезапущены, чтобы указать на место удаления текста.

gtk_text_buffer_delete_interactive ()

gboolean
gtk_text_buffer_delete_interactive (GtkTextBuffer *buffer,
                                    GtkTextIter *start_iter,
                                    GtkTextIter *end_iter,
                                    gboolean default_editable);

Удаляет весь редактируемый текст в заданном диапазоне. Вызывает gtk_text_buffer_delete() для каждого редактируемого поддиапазона [start,end). start и end перепроверяются, чтобы указать на место последнего удалённого диапазона или остаются неизменными, если текст не был удалён.

gtk_text_buffer_backspace ()

gboolean
gtk_text_buffer_backspace (GtkTextBuffer *buffer,
                           GtkTextIter *iter,
                           gboolean interactive,
                           gboolean default_editable);

Выполняет соответствующее действие, как если бы пользователь нажал клавишу Delete с курсором в позиции, указанной параметром iter. В обычном случае будет удалён один символ, но при объединении акцентов может быть удалено более одного символа, а при объединении прекомпонованных символов и акцентов — меньше одного символа.

Поскольку буфер изменяется, все активные итераторы становятся недействительными после вызова этой функции; однако, iter будет повторно инициализирован для указания места, где был удалён текст.

С: 2.6

gtk_text_buffer_set_text ()

void
gtk_text_buffer_set_text (GtkTextBuffer *buffer,
                          const gchar *text,
                          gint len);

Удаляет текущее содержимое buffer и вставляет вместо него text. Если len равно -1, text должен быть завершён нулём. text должен быть валидным UTF-8.

gtk_text_buffer_get_text ()

gchar *
gtk_text_buffer_get_text (GtkTextBuffer *buffer,
                          const GtkTextIter *start,
                          const GtkTextIter *end,
                          gboolean include_hidden_chars);

Возвращает текст в диапазоне [start ,end ). Исключает неотображаемый текст (текст, помеченный тегами, которые устанавливают атрибут невидимости), если include_hidden_chars равен FALSE. Не включает символы, представляющие встроенные изображения, поэтому индексы байтов и символов в возвращаемой строке не соответствуют индексам байтов и символов в буфере. Противопоставьте gtk_text_buffer_get_slice().

gtk_text_buffer_get_slice ()

gchar *
gtk_text_buffer_get_slice (GtkTextBuffer *buffer,
                           const GtkTextIter *start,
                           const GtkTextIter *end,
                           gboolean include_hidden_chars);

Возвращает текст в диапазоне [start ,end ). Исключает неотображаемый текст (текст, помеченный тегами, которые устанавливают атрибут невидимости), если include_hidden_chars равен FALSE. Возвращаемая строка включает символ 0xFFFC всякий раз, когда буфер содержит встроенные изображения, поэтому индексы байтов и символов в возвращаемой строке соответствуют индексам байтов и символов в буфере. Противопоставьте gtk_text_buffer_get_text(). Обратите внимание, что 0xFFFC может встречаться и в обычном тексте, поэтому это не надёжный индикатор того, что в буфере находится pixbuf или виджет.

gtk_text_buffer_insert_pixbuf ()

void
gtk_text_buffer_insert_pixbuf (GtkTextBuffer *buffer,
                               GtkTextIter *iter,
                               GdkPixbuf *pixbuf);

Вставляет изображение в буфер текста в позиции iter. Изображение будет учитываться как один символ в подсчёте символов и будет представлено в Unicode символом «замены объекта» 0xFFFC при получении содержимого буфера в виде строки. Обратите внимание, что варианты «слайса» для получения частей буфера в виде строки включают этот символ для pixbuфов, но варианты «текста» — нет. Например, см. gtk_text_buffer_get_slice() и gtk_text_buffer_get_text().

gtk_text_buffer_insert_child_anchor ()

void
gtk_text_buffer_insert_child_anchor (GtkTextBuffer *buffer,
                                     GtkTextIter *iter,
                                     GtkTextChildAnchor *anchor);

Вставляет анкор виджета-потомка в буфер текста в позиции iter. Анкор будет учитываться как один символ в подсчёте символов и будет представлен в Unicode символом «замены объекта» 0xFFFC при получении содержимого буфера в виде строки. Обратите внимание, что варианты «слайса» для получения частей буфера в виде строки включают этот символ для анкоров потомков, но варианты «текста» — нет. Например, см. gtk_text_buffer_get_slice() и gtk_text_buffer_get_text(). Рассмотрите gtk_text_buffer_create_child_anchor() как более удобную альтернативу этой функции. Буфер добавит ссылку на анкор, поэтому вы можете unref его после вставки.

gtk_text_buffer_create_child_anchor ()

GtkTextChildAnchor *
gtk_text_buffer_create_child_anchor (GtkTextBuffer *buffer,
                                     GtkTextIter *iter);

Это функция-обёртка, которая просто создаёт дочерний якорь с помощью gtk_text_child_anchor_new() и вставляет его в буфер с помощью gtk_text_buffer_insert_child_anchor(). Новый якорь принадлежит буферу; счётчик ссылок не возвращается вызывающей стороне gtk_text_buffer_create_child_anchor().

gtk_text_buffer_create_mark ()

GtkTextMark *
gtk_text_buffer_create_mark (GtkTextBuffer *buffer,
                             const gchar *mark_name,
                             const GtkTextIter *where,
                             gboolean left_gravity);

Создаёт метку в позиции where . Если mark_name — NULL, метка анонимная; в противном случае метку можно получить по имени, используя gtk_text_buffer_get_mark(). Если у метки есть левая гравитация, и текст вставляется в текущее местоположение метки, метка будет перемещена влево от недавно вставленного текста. Если у метки есть правая гравитация (left_gravity = FALSE), метка окажется справа от вставленного текста. Стандартный курсор слева направо — это метка с правой гравитацией (при вводе курсор остаётся справа от текста, который вы вводите).

Вызывающая сторона этой функции не владеет ссылкой на возвращённый GtkTextMark, поэтому вы можете игнорировать возвращаемое значение, если хотите. Метки принадлежат буферу и исчезают вместе с буфером.

Выдаёт сигнал “mark-set” в качестве уведомления о первоначальном размещении метки.

gtk_text_buffer_move_mark ()

void
gtk_text_buffer_move_mark (GtkTextBuffer *buffer,
                           GtkTextMark *mark,
                           const GtkTextIter *where);

Перемещает mark в новое местоположение where . Выдаёт сигнал “mark-set” в качестве уведомления о перемещении.

gtk_text_buffer_move_mark_by_name ()

void
gtk_text_buffer_move_mark_by_name (GtkTextBuffer *buffer,
                                   const gchar *name,
                                   const GtkTextIter *where);

Перемещает метку с именем name (которая должна существовать) в местоположение where . Подробности см. в gtk_text_buffer_move_mark().

gtk_text_buffer_add_mark ()

void
gtk_text_buffer_add_mark (GtkTextBuffer *buffer,
                          GtkTextMark *mark,
                          const GtkTextIter *where);

Добавляет метку в позиции where . Метка не должна добавляться в другой буфер, и если её имя не NULL, то в буфере не должно быть другой метки с таким же именем.

Выдаёт сигнал “mark-set” в качестве уведомления о первоначальном размещении метки.

С: 2.12

gtk_text_buffer_delete_mark ()

void
gtk_text_buffer_delete_mark (GtkTextBuffer *buffer,
                             GtkTextMark *mark);

Удаляет mark, чтобы она больше не находилась нигде в буфере. Удаляет ссылку, которую буфер держит на метку, поэтому если вы не вызвали g_object_ref() на метке, она будет освобождена. Даже если метка не освобождается, большинство операций с mark становятся недействительными до тех пор, пока она снова не будет добавлена в буфер с помощью gtk_text_buffer_add_mark(). Используйте gtk_text_mark_get_deleted(), чтобы узнать, была ли метка удалена из её буфера. Сигнал “mark-deleted” будет выпущен в качестве уведомления после удаления метки.

gtk_text_buffer_delete_mark_by_name ()

void
gtk_text_buffer_delete_mark_by_name (GtkTextBuffer *buffer,
                                     const gchar *name);

Удаляет метку с именем name; метка должна существовать. Подробности см. в gtk_text_buffer_delete_mark().

gtk_text_buffer_get_mark ()

GtkTextMark *
gtk_text_buffer_get_mark (GtkTextBuffer *buffer,
                          const gchar *name);

Возвращает метку с именем name в буфере buffer или NULL, если такая метка в буфере отсутствует.

gtk_text_buffer_get_insert ()

GtkTextMark *
gtk_text_buffer_get_insert (GtkTextBuffer *buffer);

Возвращает метку, представляющую курсор (точку вставки). Эквивалентно вызову gtk_text_buffer_get_mark() для получения метки с именем «insert», но немного эффективнее и требует меньше набора.

gtk_text_buffer_get_selection_bound ()

GtkTextMark *
gtk_text_buffer_get_selection_bound (GtkTextBuffer *buffer);

Возвращает метку, представляющую границу выделения. Эквивалентно вызову gtk_text_buffer_get_mark() для получения метки с именем «selection_bound», но немного эффективнее и требует меньше набора.

Выделенный в настоящее время текст в buffer — это область между метками «selection_bound» и «insert». Если «selection_bound» и «insert» находятся в одном месте, выделения нет. gtk_text_buffer_get_selection_bounds() — это еще одна удобная функция для работы с выделением, если вам нужно только узнать, есть ли выделение и каковы его границы.

gtk_text_buffer_get_has_selection ()

gboolean
gtk_text_buffer_get_has_selection (GtkTextBuffer *buffer);

Указывает, есть ли в буфере выделенный текст.

Since: 2.10

gtk_text_buffer_place_cursor ()

void
gtk_text_buffer_place_cursor (GtkTextBuffer *buffer,
                              const GtkTextIter *where);

Эта функция перемещает метки «insert» и «selection_bound» одновременно. Если вы перемещаете их по отдельности с помощью gtk_text_buffer_move_mark(), между их старым и новым местоположениями временно выделится область, что может быть довольно неэффективно, поскольку временно выделенная область заставит пересчитывать некоторые данные. Эта функция перемещает их как единое целое, что оптимизировано.

gtk_text_buffer_select_range ()

void
gtk_text_buffer_select_range (GtkTextBuffer *buffer,
                              const GtkTextIter *ins,
                              const GtkTextIter *bound);

Эта функция перемещает метки «insert» и «selection_bound» одновременно. Если вы перемещаете их по отдельности с помощью gtk_text_buffer_move_mark(), между их старым и новым местоположениями временно выделится область, что может быть довольно неэффективно, поскольку временно выделенная область заставит пересчитывать некоторые данные. Эта функция перемещает их как единое целое, что оптимизировано.

Since: 2.4

gtk_text_buffer_apply_tag ()

void
gtk_text_buffer_apply_tag (GtkTextBuffer *buffer,
                           GtkTextTag *tag,
                           const GtkTextIter *start,
                           const GtkTextIter *end);

Вызывает сигнал «apply-tag» на buffer. Обработчик по умолчанию сигнала применяет tag к заданной области. start и end не обязательно должны быть упорядочены.

gtk_text_buffer_remove_tag ()

void
gtk_text_buffer_remove_tag (GtkTextBuffer *buffer,
                            GtkTextTag *tag,
                            const GtkTextIter *start,
                            const GtkTextIter *end);

Вызывает сигнал «remove-tag». Обработчик по умолчанию сигнала удаляет все вхождения tag из заданной области. start и end не обязательно должны быть упорядочены.

gtk_text_buffer_apply_tag_by_name ()

void
gtk_text_buffer_apply_tag_by_name (GtkTextBuffer *buffer,
                                   const gchar *name,
                                   const GtkTextIter *start,
                                   const GtkTextIter *end);

Вызывает gtk_text_tag_table_lookup() в таблице тегов буфера, чтобы получить GtkTextTag, затем вызывает gtk_text_buffer_apply_tag().

gtk_text_buffer_remove_tag_by_name ()

void
gtk_text_buffer_remove_tag_by_name (GtkTextBuffer *buffer,
                                    const gchar *name,
                                    const GtkTextIter *start,
                                    const GtkTextIter *end);

Вызывает gtk_text_tag_table_lookup() в таблице тегов буфера, чтобы получить GtkTextTag, затем вызывает gtk_text_buffer_remove_tag().

gtk_text_buffer_remove_all_tags ()

void
gtk_text_buffer_remove_all_tags (GtkTextBuffer *buffer,
                                 const GtkTextIter *start,
                                 const GtkTextIter *end);

Удаляет все теги в диапазоне между start и end. Будьте осторожны с этой функцией; она может удалить теги, добавленные кодом, не связанным с кодом, который вы сейчас пишете. То есть, использование этой функции, вероятно, плохая идея, если у вас есть две или более не связанные друг с другом части кода, добавляющие теги.

gtk_text_buffer_create_tag ()

GtkTextTag *
gtk_text_buffer_create_tag (GtkTextBuffer *buffer,
                            const gchar *tag_name,
                            const gchar *first_property_name,
                            ...);

Создает тег и добавляет его в таблицу тегов для buffer. Эквивалентно вызову gtk_text_tag_new(), а затем добавлению тега в таблицу тегов буфера. Возвращаемый тег принадлежит таблице тегов буфера, поэтому счетчик ссылок будет равен единице.

Если tag_name равен NULL, тег анонимный.

Если tag_name не равен NULL, тег с именем tag_name не должен уже существовать в таблице тегов для этого буфера.

Аргумент first_property_name и последующие аргументы представляют собой список свойств, которые нужно установить для тега, как в g_object_set().

gtk_text_buffer_get_iter_at_line_offset ()

void
gtk_text_buffer_get_iter_at_line_offset
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                gint line_number,
                                gint char_offset);

Получает итератор, указывающий на char_offset в заданной строке. Обратите внимание на символы, а не байты; UTF-8 может кодировать один символ как несколько байтов.

До версии 3.20 недопустимо передавать некорректное расположение.

С версии 3.20, если line_number больше, чем количество строк в buffer, возвращается итератор конца. И если char_offset выходит за пределы строки, возвращается итератор конца строки.

gtk_text_buffer_get_iter_at_offset ()

void
gtk_text_buffer_get_iter_at_offset (GtkTextBuffer *buffer,
                                    GtkTextIter *iter,
                                    gint char_offset);

Инициализирует iter в позиции char_offset символов от начала всего буфера. Если char_offset равно -1 или больше, чем количество символов в буфере, iter инициализируется итератором конца, итератором после последнего допустимого символа в буфере.

gtk_text_buffer_get_iter_at_line ()

void
gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  gint line_number);

Инициализирует iter в начало заданной строки. Если line_number больше, чем количество строк в buffer, возвращается итератор конца.

gtk_text_buffer_get-iter-at-line-index ()

void
gtk_text_buffer_get_iter_at_line_index
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                gint line_number,
                                gint byte_index);

Получает итератор, указывающий на byte_index внутри заданной строки. byte_index должен быть началом UTF-8 символа. Обратите внимание на байты, а не символы; UTF-8 может кодировать один символ как несколько байтов.

До версии 3.20 не разрешалось передавать некорректное местоположение.

Начиная с версии 3.20, если line_number больше, чем количество строк в buffer , возвращается итератор конца. А если byte_index находится за пределами строки, возвращается итератор конца строки.

gtk_text_buffer_get_iter_at_mark ()

void
gtk_text_buffer_get_iter_at_mark (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  GtkTextMark *mark);

Инициализирует iter текущим положением mark.

gtk_text_buffer_get_iter_at_child_anchor ()

void
gtk_text_buffer_get_iter_at_child_anchor
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                GtkTextChildAnchor *anchor);

Получает расположение anchor внутри buffer.

gtk_text_buffer_get_start_iter ()

void
gtk_text_buffer_get_start_iter (GtkTextBuffer *buffer,
                                GtkTextIter *iter);

Инициализирует iter первой позицией в буфере текста. Это эквивалентно использованию gtk_text_buffer_get_iter_at_offset() для получения итератора по смещению 0.

gtk_text_buffer_get_end_iter ()

void
gtk_text_buffer_get_end_iter (GtkTextBuffer *buffer,
                              GtkTextIter *iter);

Инициализирует iter “итератором конца”, следующим за последним допустимым символом в буфере текста. Если обращаться к нему с помощью gtk_text_iter_get_char(), значение итератора конца равно 0. Весь буфер находится в диапазоне от первой позиции в буфере (чтобы получить позицию символа 0, вызовите gtk_text_buffer_get_start_iter()) до итератора конца.

gtk_text_buffer_get_bounds ()

void
gtk_text_buffer_get_bounds (GtkTextBuffer *buffer,
                            GtkTextIter *start,
                            GtkTextIter *end);

Возвращает первый и последний итераторы в буфере, т. е. весь буфер лежит в диапазоне [start ,end ).

gtk_text_buffer_get_modified ()

gboolean
gtk_text_buffer_get_modified (GtkTextBuffer *buffer);

Указывает, был ли буфер изменён с момента последнего вызова gtk_text_buffer_set_modified(), установившего флаг изменения в FALSE. Используется, например, для активации функции «сохранить» в текстовом редакторе.

gtk_text_buffer_set_modified ()

void
gtk_text_buffer_set_modified (GtkTextBuffer *buffer,
                              gboolean setting);

Используется для отслеживания того, был ли буфер изменён с момента последней сохранения. Всякий раз, когда буфер сохраняется на диск, вызывайте gtk_text_buffer_set_modified (buffer, FALSE). При изменении буфера, бит модификации автоматически устанавливается снова. Когда бит модификации изменяется, буфер испускает сигнал “modified-changed”.

gtk_text_buffer_delete_selection ()

gboolean
gtk_text_buffer_delete_selection (GtkTextBuffer *buffer,
                                  gboolean interactive,
                                  gboolean default_editable);

Удаляет диапазон между метками «вставка» и «selection_bound», то есть текущий выделенный текст. Если interactive равно TRUE, редактируемость выделения будет учитываться (пользователи не могут удалить нередактируемый текст).

gtk_text_buffer_paste_clipboard ()

void
gtk_text_buffer_paste_clipboard (GtkTextBuffer *buffer,
                                 GtkClipboard *clipboard,
                                 GtkTextIter *override_location,
                                 gboolean default_editable);

Вставляет содержимое буфера обмена. Если override_location равно NULL, вставленный текст будет вставлен в позицию курсора, или выделение буфера будет заменено, если выделение непустое.

Примечание: вставка асинхронна, то есть мы запрашиваем данные вставки и возвращаем, и в какой-то момент позже, после выполнения основного цикла, данные вставки будут вставлены.

gtk_text_buffer_copy_clipboard ()

void
gtk_text_buffer_copy_clipboard (GtkTextBuffer *buffer,
                                GtkClipboard *clipboard);

Копирует текущий выделенный текст в буфер обмена.

gtk_text_buffer_cut_clipboard ()

void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
                               GtkClipboard *clipboard,
                               gboolean default_editable);

Копирует текущий выделенный текст в буфер обмена, а затем удаляет указанный текст, если он редактируемый.

gtk_text_buffer_get_selection_bounds ()

gboolean
gtk_text_buffer_get_selection_bounds (GtkTextBuffer *buffer,
                                      GtkTextIter *start,
                                      GtkTextIter *end);

Возвращает TRUE, если текст выделен; помещает границы выделения в start и end (если выделение имеет длину 0, то start и end заполняются одним и тем же значением). start и end будут в порядке возрастания. Если start и end равны NULL, то они не заполняются, но возвращаемое значение всё равно указывает, выделен ли текст.

gtk_text_buffer_begin_user_action ()

void
gtk_text_buffer_begin_user_action (GtkTextBuffer *buffer);

Вызывается для указания того, что операции с буфером между этим вызовом и вызовом gtk_text_buffer_end_user_action() являются частью одной видимой пользователю операции. Операции между gtk_text_buffer_begin_user_action() и gtk_text_buffer_end_user_action() могут быть сгруппированы при создании стека отмены. GtkTextBuffer сохраняет счёт вызовов gtk_text_buffer_begin_user_action(), которые не были закрыты вызовом gtk_text_buffer_end_user_action(), и испускает сигналы «begin-user-action» и «end-user-action» только для самой внешней пары вызовов. Это позволяет формировать пользовательские действия из других пользовательских действий.

Функции изменения буфера «interactive», такие как gtk_text_buffer_insert_interactive(), автоматически вызывают begin/end user action вокруг выполняемых операций с буфером, поэтому нет необходимости добавлять дополнительные вызовы, если ваше пользовательское действие состоит только из одного вызова одной из таких функций.

gtk_text_buffer_end_user_action ()

void
gtk_text_buffer_end_user_action (GtkTextBuffer *buffer);

Должен быть сопряжён с вызовом gtk_text_buffer_begin_user_action(). Смотрите эту функцию для полного объяснения.

gtk_text_buffer_add_selection_clipboard ()

void
gtk_text_buffer_add_selection_clipboard
                               (GtkTextBuffer *buffer,
                                GtkClipboard *clipboard);

Добавляет clipboard в список буферов обмена, в которых доступно содержимое выделения buffer. В большинстве случаев, clipboard будет буфером обмена GtkClipboard типа GDK_SELECTION_PRIMARY для просмотра buffer.

gtk_text_buffer_remove_selection_clipboard ()

void
gtk_text_buffer_remove_selection_clipboard
                               (GtkTextBuffer *buffer,
                                GtkClipboard *clipboard);

Удаляет GtkClipboard, добавленный с помощью gtk_text_buffer_add_selection_clipboard().

GtkTextBufferDeserializeFunc ()

gboolean
(*GtkTextBufferDeserializeFunc) (GtkTextBuffer *register_buffer,
                                 GtkTextBuffer *content_buffer,
                                 GtkTextIter *iter,
                                 const guint8 *data,
                                 gsize length,
                                 gboolean create_tags,
                                 gpointer user_data,
                                 GError **error);

Функция, вызываемая для десериализации форматированного текста, сериализованного с помощью gtk_text_buffer_serialize(), и вставки его в позицию iter.

gtk_text_buffer_deserialize ()

gboolean
gtk_text_buffer_deserialize (GtkTextBuffer *register_buffer,
                             GtkTextBuffer *content_buffer,
                             GdkAtom format,
                             GtkTextIter *iter,
                             const guint8 *data,
                             gsize length,
                             GError **error);

Эта функция десериализует форматированный текст в формате format и вставляет его в позицию iter.

Для использования формата formats он должен быть зарегистрирован с помощью gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset() предварительно.

С: 2.10

gtk_text_buffer_deserialize_get_can_create_tags ()

gboolean
gtk_text_buffer_deserialize_get_can_create_tags
                               (GtkTextBuffer *buffer,
                                GdkAtom format);

Эта функция возвращает значение, заданное с помощью gtk_text_buffer_deserialize_set_can_create_tags()

С: 2.10

gtk_text_buffer_deserialize_set_can_create_tags ()

void
gtk_text_buffer_deserialize_set_can_create_tags
                               (GtkTextBuffer *buffer,
                                GdkAtom format,
                                gboolean can_create_tags);

Используйте эту функцию, чтобы позволить функции десериализации форматированного текста создавать новые теги в буфере получателя. Обратите внимание, что использование этой функции почти всегда плохая идея, потому что зарегистрированные вами функции форматированного текста должны знать, как сопоставлять формат форматированного текста, который они обрабатывают, с набором тегов вашего буфера текста.

Возможность создания новых (произвольных!) тегов в буфере получателя предназначена для специальных форматов форматированного текста, таких как внутренний, зарегистрированный с помощью gtk_text_buffer_register_deserialize_tagset(), потому что этот формат по сути представляет собой дамп внутренней структуры буфера источника, включая имена его тегов.

Вы должны разрешить создание тегов только в том случае, если вы знаете, что делаете, например, если вы определили имя набора тегов для буферов текста вашего приложения и знаете, что прием новых тегов из этих буферов приемлем, потому что вы знаете, что ваше приложение может обрабатывать вновь созданные теги.

Since: 2.10

gtk_text_buffer_get_copy_target_list ()

GtkTargetList *
gtk_text_buffer_get_copy_target_list (GtkTextBuffer *buffer);

Эта функция возвращает список целей, которые этот буфер текста может предоставить для копирования и в качестве источника перетаскивания. Цели в списке добавляются с помощью значений info из перечисления GtkTextBufferTargetInfo, используя gtk_target_list_add_rich_text_targets() и gtk_target_list_add_text_targets().

Since: 2.10

gtk_text_buffer_get_deserialize_formats ()

GdkAtom *
gtk_text_buffer_get_deserialize_formats
                               (GtkTextBuffer *buffer,
                                gint *n_formats);

Эта функция возвращает зарегистрированные форматы десериализации форматированного текста с помощью buffer, используя gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset()

Since: 2.10

gtk_text_buffer_get_paste_target_list ()

GtkTargetList *
gtk_text_buffer_get_paste_target_list (GtkTextBuffer *buffer);

Эта функция возвращает список целей, которые этот буфер текста поддерживает для вставки и в качестве пункта назначения перетаскивания. Цели в списке добавляются с помощью значений info из перечисления GtkTextBufferTargetInfo, используя gtk_target_list_add_rich_text_targets() и gtk_target_list_add_text_targets().

Since: 2.10

gtk_text_buffer_get_serialize_formats ()

GdkAtom *
gtk_text_buffer_get_serialize_formats (GtkTextBuffer *buffer,
                                       gint *n_formats);

Эта функция возвращает зарегистрированные форматы сериализации форматированного текста с помощью buffer, используя gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset()

Since: 2.10

gtk_text_buffer_register_deserialize_format ()

GdkAtom
gtk_text_buffer_register_deserialize_format
                               (GtkTextBuffer *buffer,
                                const gchar *mime_type,
                                GtkTextBufferDeserializeFunc function,
                                gpointer user_data,
                                GDestroyNotify user_data_destroy);

Эта функция регистрирует функцию десериализации форматированного текста function вместе с ее mime_type в переданном buffer.

Since: 2.10

gtk_text_buffer_register_deserialize_tagset ()

GdkAtom
gtk_text_buffer_register_deserialize_tagset
                               (GtkTextBuffer *buffer,
                                const gchar *tagset_name);

Эта функция регистрирует внутренний формат сериализации форматированного текста GTK+ с переданным buffer . Подробности см. в gtk_text_buffer_register_serialize_tagset().

С: 2.10

gtk_text_buffer_register_serialize_format ()

GdkAtom
gtk_text_buffer_register_serialize_format
                               (GtkTextBuffer *buffer,
                                const gchar *mime_type,
                                GtkTextBufferSerializeFunc function,
                                gpointer user_data,
                                GDestroyNotify user_data_destroy);

Эта функция регистрирует формат сериализации форматированного текста function вместе с его mime_type с переданным buffer .

С: 2.10

gtk_text_buffer_register_serialize_tagset ()

GdkAtom
gtk_text_buffer_register_serialize_tagset
                               (GtkTextBuffer *buffer,
                                const gchar *tagset_name);

Эта функция регистрирует внутренний формат сериализации форматированного текста GTK+ с переданным buffer . Внутренний формат не соответствует никакому стандартному формату форматированного текста и работает только между экземплярами GtkTextBuffer. Он может сериализовать все теги и встроенные pixbuфы буфера текста.

Эта функция — просто обёртка вокруг gtk_text_buffer_register_serialize_format(). Используемый MIME-тип для регистрации — “application/x-gtk-text-buffer-rich-text”, или “application/x-gtk-text-buffer-rich-text;format=tagset_name ”, если было передано tagset_name.

tagset_name можно использовать для ограничения передачи форматированного текста буферам с совместимыми наборами тегов, чтобы избежать вставки неизвестных тегов. Вероятно, обычно нужно передавать идентификатор != NULL, так как набор тегов NULL требует от принимающего буфера обработки вставки произвольных тегов.

С: 2.10

GtkTextBufferSerializeFunc ()

guint8 *
(*GtkTextBufferSerializeFunc) (GtkTextBuffer *register_buffer,
                               GtkTextBuffer *content_buffer,
                               const GtkTextIter *start,
                               const GtkTextIter *end,
                               gsize *length,
                               gpointer user_data);

Функция, вызываемая для сериализации содержимого буфера текста. Она должна вернуть сериализованную форму содержимого.

gtk_text_buffer_serialize ()

guint8 *
gtk_text_buffer_serialize (GtkTextBuffer *register_buffer,
                           GtkTextBuffer *content_buffer,
                           GdkAtom format,
                           const GtkTextIter *start,
                           const GtkTextIter *end,
                           gsize *length);

Эта функция сериализует часть текста между start и end в формате форматированного текста, представленном format .

Формат, который нужно использовать, должен быть зарегистрирован предварительно с помощью gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset().

С: 2.10

gtk_text_buffer_unregister_deserialize_format ()

void
gtk_text_buffer_unregister_deserialize_format
                               (GtkTextBuffer *buffer,
                                GdkAtom format);

Эта функция отменяет регистрацию формата форматированного текста, ранее зарегистрированного с помощью gtk_text_buffer_register_deserialize_format() или gtk_text_buffer_register_deserialize_tagset().

С: 2.10

gtk_text_buffer_unregister_serialize_format ()

void
gtk_text_buffer_unregister_serialize_format
                               (GtkTextBuffer *buffer,
                                GdkAtom format);

Эта функция отменяет регистрацию формата форматированного текста, ранее зарегистрированного с помощью gtk_text_buffer_register_serialize_format() или gtk_text_buffer_register_serialize_tagset()

С: 2.10

Сигнал “apply-tag”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextTag    *tag,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::apply-tag генерируется для применения тега к диапазону текста в GtkTextBuffer. Применение фактически происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен их перепроверять).

См. также: gtk_text_buffer_apply_tag(), gtk_text_buffer_insert_with_tags(), gtk_text_buffer_insert_range().

Флаги: Выполнить последним

Сигнал “begin-user-action”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::begin-user-action генерируется в начале однократного, видимого пользователю, действия с GtkTextBuffer.

См. также: gtk_text_buffer_begin_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection().

Флаги: Выполнить последним

Сигнал “changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::changed генерируется, когда содержимое GtkTextBuffer изменилось.

Флаги: Выполнить последним

Сигнал “delete-range”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::delete-range генерируется для удаления диапазона из GtkTextBuffer.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен их перепроверять). Обработчик сигнала по умолчанию перепроверяет итераторы start и end, чтобы оба указывали на место, где текст был удален. Обработчики, которые выполняются после обработчика по умолчанию (см. g_signal_connect_after()), не имеют доступа к удаленному тексту.

См. также: gtk_text_buffer_delete().

Флаги: Выполнить последним

Сигнал “end-user-action”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::end-user-action генерируется в конце однократного, видимого пользователю, действия с GtkTextBuffer.

См. также: gtk_text_buffer_end_user_action(), gtk_text_buffer_insert_interactive(), gtk_text_buffer_insert_range_interactive(), gtk_text_buffer_delete_interactive(), gtk_text_buffer_backspace(), gtk_text_buffer_delete_selection(), gtk_text_buffer_backspace().

Флаги: Выполнить последним

Сигнал “insert-child-anchor”

void
user_function (GtkTextBuffer      *textbuffer,
               GtkTextIter        *location,
               GtkTextChildAnchor *anchor,
               gpointer            user_data)

Сигнал ::insert-child-anchor генерируется для вставки GtkTextChildAnchor в GtkTextBuffer. Вставка фактически происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен его перепроверять). Обработчик сигнала по умолчанию перепроверяет его, чтобы он располагался после вставленного anchor.

См. также: gtk_text_buffer_insert_child_anchor().

Флаги: Выполнить последним

Сигнал “insert-pixbuf”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               GdkPixbuf     *pixbuf,
               gpointer       user_data)

Сигнал ::insert-pixbuf генерируется для вставки GdkPixbuf в GtkTextBuffer. Вставка выполняется в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен его перевалидировать). Обработчик сигнала по умолчанию перевалидирует его, чтобы поместить его после вставленного pixbuf.

См. также: gtk_text_buffer_insert_pixbuf().

Флаги: Run Last

Сигнал “insert-text”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               gchar         *text,
               gint           len,
               gpointer       user_data)

Сигнал ::insert-text генерируется для вставки текста в GtkTextBuffer. Вставка происходит в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительным итератор location (или должен его перевалидировать). Обработчик сигнала по умолчанию перевалидирует его, чтобы указать на конец вставленного текста.

См. также: gtk_text_buffer_insert(), gtk_text_buffer_insert_range().

Флаги: Run Last

Сигнал “mark-deleted”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextMark   *mark,
               gpointer       user_data)

Сигнал ::mark-deleted генерируется после удаления GtkTextMark.

См. также: gtk_text_buffer_delete_mark().

Флаги: Run Last

Сигнал “mark-set”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               GtkTextMark   *mark,
               gpointer       user_data)

Сигнал ::mark-set генерируется после установки GtkTextMark.

См. также: gtk_text_buffer_create_mark(), gtk_text_buffer_move_mark().

Флаги: Run Last

Сигнал “modified-changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал ::modified-changed генерируется при изменении флага модификации GtkTextBuffer.

См. также: gtk_text_buffer_set_modified().

Флаги: Run Last

Сигнал “paste-done”

void
user_function (GtkTextBuffer *textbuffer,
               GtkClipboard  *clipboard,
               gpointer       user_data)

Сигнал paste-done генерируется после завершения операции вставки. Это полезно для корректного прокручивания области просмотра до конца вставленного текста. Дополнительные сведения см. в gtk_text_buffer_paste_clipboard().

Флаги: Run Last

С: 2.16

Сигнал “remove-tag”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextTag    *tag,
               GtkTextIter   *start,
               GtkTextIter   *end,
               gpointer       user_data)

Сигнал ::remove-tag генерируется для удаления всех вхождений tag из диапазона текста в GtkTextBuffer. Удаление выполняется в обработчике по умолчанию.

Обратите внимание, что если ваш обработчик выполняется до обработчика по умолчанию, он не должен делать недействительными итераторы start и end (или должен их перевалидировать).

См. также: gtk_text_buffer_remove_tag().

Флаги: Run Last