GtkTextBuffer

gtk_text_buffer_new ()

GtkTextBuffer *
gtk_text_buffer_new (GtkTextTagTable *table);

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

gtk_text_buffer_get_line_count ()

int
gtk_text_buffer_get_line_count (GtkTextBuffer *buffer);

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

gtk_text_buffer_get_char_count ()

int
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 char *text,
                        int 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 char *text,
                                  int len);

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

gtk_text_buffer_insert_interactive ()

gboolean
gtk_text_buffer_insert_interactive (GtkTextBuffer *buffer,
                                    GtkTextIter *iter,
                                    const char *text,
                                    int 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 char *text,
                                int 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 char *text,
                                  int 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 char *text,
                                int len,
                                const char *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 char *markup,
                               int len);

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

gtk_text-buffer-insert-paintable ()

void
gtk_text_buffer_insert_paintable (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  GdkPaintable *paintable);

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

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 будет перезапущен для указания места удаления текста.

gtk_text_buffer_set_text ()

void
gtk_text_buffer_set_text (GtkTextBuffer *buffer,
                          const char *text,
                          int len);

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

gtk_text_buffer_get_text ()

char *
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 ()

char *
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 может встречаться и в обычном тексте, поэтому он не является надёжным индикатором наличия рисунка или виджета в буфере.

gtk_text_buffer_insert_child_anchor ()

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

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

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 char *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 char *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” в качестве уведомления о первоначальном размещении метки.

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 char *name);

Удаляет метку с именем name ; метка должна существовать. См. gtk_text_buffer_delete_mark() для получения подробной информации.

gtk_text_buffer_get_mark ()

GtkTextMark *
gtk_text_buffer_get_mark (GtkTextBuffer *buffer,
                          const char *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);

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

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(), то временно выделите область между их старым и новым местоположениями, что может быть неэффективным, так как временно выделенная область заставит пересчитать некоторые данные. Эта функция перемещает их как единое целое, что может быть оптимизировано.

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 char *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 char *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 char *tag_name,
                            const char *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 ()

gboolean
gtk_text_buffer_get_iter_at_line_offset
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                int line_number,
                                int char_offset);

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

До версии 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,
                                    int char_offset);

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

gtk_text_buffer_get_iter_at_line ()

gboolean
gtk_text_buffer_get_iter_at_line (GtkTextBuffer *buffer,
                                  GtkTextIter *iter,
                                  int line_number);

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

gtk_text_buffer_get_iter_at_line_index ()

gboolean
gtk_text_buffer_get_iter_at_line_index
                               (GtkTextBuffer *buffer,
                                GtkTextIter *iter,
                                int line_number,
                                int byte_index);

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

Если 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. Весь буфер находится в диапазоне от первой позиции в буфере (вызовите gtk_text_buffer_get_start_iter() для получения позиции символа 0) до итератора конца.

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,
                                 GdkClipboard *clipboard,
                                 GtkTextIter *override_location,
                                 gboolean default_editable);

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

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

gtk_text_buffer_copy_clipboard ()

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

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

gtk_text_buffer_cut_clipboard ()

void
gtk_text_buffer_cut_clipboard (GtkTextBuffer *buffer,
                               GdkClipboard *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_get_selection_content ()

GdkContentProvider *
gtk_text_buffer_get_selection_content (GtkTextBuffer *buffer);

Получить поставщик содержимого для этого буфера. Его можно использовать для предоставления содержимого buffer в GdkClipboard, см. gdk_clipboard_set_content().

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» только для внешней пары вызовов. Это позволяет создавать пользовательские действия из других пользовательских действий.

Функции изменения буфера «интерактивного» типа, такие как 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,
                                GdkClipboard *clipboard);

Добавляет clipboard в список буферов обмена, в которых содержимое выделения buffer доступно. В большинстве случаев clipboard будет GdkClipboard, возвращённым gtk_widget_get_primary_clipboard() для представления buffer.

gtk_text_buffer_remove-selection-clipboard ()

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

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

gtk_text_buffer_get_can-undo ()

gboolean
gtk_text_buffer_get_can_undo (GtkTextBuffer *buffer);

Получает, есть ли отменяемое действие в истории.

gtk_text-buffer-get-can-redo ()

gboolean
gtk_text_buffer_get_can_redo (GtkTextBuffer *buffer);

Получает, есть ли действие, которое можно повторить, в истории.

gtk_text_buffer_get_enable-undo ()

gboolean
gtk_text_buffer_get_enable_undo (GtkTextBuffer *buffer);

Получает, сохраняет ли буфер изменения в буфере, чтобы разрешить действия отмены и повтора.

См. gtk_text_buffer_begin_irreversible_action() и gtk_text_buffer_end_irreversible_action(), чтобы создать изменения в буфере, которые нельзя отменить.

gtk_text_buffer_set_enable_undo ()

void
gtk_text_buffer_set_enable_undo (GtkTextBuffer *buffer,
                                 gboolean enable_undo);

Устанавливает, включены ли отменяемые действия в буфере текста. Если включено, пользователь сможет отменить последнее количество действий до gtk_text_buffer_get_max_undo_levels().

См. gtk_text_buffer_begin_irreversible_action() и gtk_text_buffer_end_irreversible_action(), чтобы создать изменения в буфере, которые нельзя отменить.

gtk_text_buffer_get_max_undo_levels ()

guint
gtk_text_buffer_get_max_undo_levels (GtkTextBuffer *buffer);

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

gtk_text_buffer_set_max_undo_levels ()

void
gtk_text_buffer_set_max_undo_levels (GtkTextBuffer *buffer,
                                     guint max_undo_levels);

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

gtk_text_buffer_undo ()

void
gtk_text_buffer_undo (GtkTextBuffer *buffer);

Отменяет последнее отменяемое действие в буфере, если оно есть.

gtk_text_buffer_redo ()

void
gtk_text_buffer_redo (GtkTextBuffer *buffer);

Повторяет следующее действие, подлежащее повторному выполнению, в буфере, если оно есть.

gtk_text_buffer_begin_irreversible_action ()

void
gtk_text_buffer_begin_irreversible_action
                               (GtkTextBuffer *buffer);

Обозначает начало действия, которое нельзя отменить. Это приведет к очистке всех предыдущих операций в очереди отмены/повторного выполнения.

После завершения необратимого действия следует вызвать gtk_text_buffer_end_irreversible_action().

Вы можете вложенно вызывать пары gtk_text_buffer_begin_irreversible_action() и gtk_text_buffer_end_irreversible_action().

gtk_text_buffer_end_irreversible_action ()

void
gtk_text_buffer_end_irreversible_action
                               (GtkTextBuffer *buffer);

Обозначает конец действия, которое нельзя отменить. Это приведет к очистке всех предыдущих операций в очереди отмены/повторного выполнения.

Этот метод следует вызывать после завершения модификаций буфера текста после вызова gtk_text_buffer_begin_irreversible_action().

Вы можете вложенно вызывать пары gtk_text_buffer_begin_irreversible_action() и gtk_text_buffer_end_irreversible_action().

Сигнал “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().

Флаги: Run Last

Сигнал “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().

Флаги: Run Last

Сигнал “changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

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

Флаги: Run Last

Сигнал “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().

Флаги: Run Last

Сигнал “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().

Флаги: Run Last

Сигнал “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().

Флаги: Run Last

Сигнал “insert-paintable”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               GdkPaintable  *paintable,
               gpointer       user_data)

Сигнал “insert-paintable” генерируется для вставки GdkPaintable в GtkTextBuffer. Вставка фактически выполняется в обработчике по умолчанию.

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

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

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

Сигнал “insert-text”

void
user_function (GtkTextBuffer *textbuffer,
               GtkTextIter   *location,
               char          *text,
               int            len,
               gpointer       user_data)

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

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

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

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

Сигнал “mark-deleted”

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

Сигнал “mark-deleted” генерируется как уведомление после удаления GtkTextMark.

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

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

Сигнал “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().

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

Сигнал “modified-changed”

void
user_function (GtkTextBuffer *textbuffer,
               gpointer       user_data)

Сигнал “modified-changed” генерируется, когда бит изменения GtkTextBuffer меняет значение.

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

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

Сигнал “paste-done”

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

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

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

Сигнал “redo”

void
user_function (GtkTextBuffer *buffer,
               gpointer       user_data)

Сигнал "redo" генерируется, когда выполняется запрос на повторное выполнение ранее отменённой операции.

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

Сигнал “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().

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

Сигнал “undo”

void
user_function (GtkTextBuffer *buffer,
               gpointer       user_data)

Сигнал «undo» генерируется, когда был выполнен запрос на отмену предыдущей операции или группы операций.

Флаги: Run Last