GtkCellArea

Запрос размеров области

Как указано в разделе управления геометрией GtkWidget, GTK использует систему управления геометрией «высота для ширины» для вычисления размеров виджетов и пользовательских интерфейсов. GtkCellArea использует те же семантики для расчета размера области для произвольного количества строк GtkTreeModel.

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

Также важно, чтобы области поддерживали выравнивание ячеек с областями, отрисованными для смежных строк (ячейки могут отображаться «в столбцы» внутри области, даже если размеры ячеек в каждой строке отличаются). По этой причине GtkCellArea использует объект GtkCellAreaContext для хранения выравниваний и размеров по ходу (а также общий максимальный минимальный и естественный размер для всех строк, которые были рассчитаны с использованием указанного контекста).

Объект GtkCellAreaContext — это непрозрачный объект, специфичный для GtkCellArea, который его создал (см. gtk_cell_area_create_context()). Владеющий виджет размещения ячеек может создавать любое количество контекстов для расчета размеров строк, которые должны получать одинаковый размер по крайней мере в одной ориентации (горизонтально или вертикально). Однако важно, чтобы тот же объект GtkCellAreaContext, который использовался для запроса размеров для заданной строки GtkTreeModel, использовался при отрисовке или обработке событий для этой строки.

Для запроса ширины всех строк на корневом уровне GtkTreeModel необходимо выполнить следующие действия:

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

Это может быть полезно, так как виджеты GtkCellLayout обычно должны поддерживать запрос и отрисовку строк в GtkTreeModel с чрезвычайно большим количеством строк. В этом случае виджет GtkCellLayout вычисляет необходимую ширину строк в источнике холостого хода или таймаута (см. g_timeout_add()) и, когда виджет запрашивает свою фактическую ширину в GtkWidgetClass.measure(), он просто может проконсультироваться с накопленной шириной в объекте GtkCellAreaContext.

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

В приведенном выше примере виджет Foo должен убедиться, что были рассчитаны размеры некоторых строк (количество строк, которое Foo посчитал подходящим для запроса места в одной итерации таймаута), прежде чем просто вернуть количество места, необходимое для области через GtkCellAreaContext.

Запрос высоты по ширине (или ширины по высоте) области — аналогичная задача, за исключением того, что в этом случае объект GtkCellAreaContext не хранит данные (на самом деле, он не знает, сколько места виджет размещения планирует выделить для каждой строки. За виджетом размещения остается отрисовка каждой строки данных с соответствующей высотой и шириной, которые запросил GtkCellArea).

Для запроса высоты по ширине всех строк на корневом уровне GtkTreeModel необходимо выполнить следующие действия:

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

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

Отрисовка областей

После получения размеров областей, по крайней мере, для строк в видимой области виджета размещения, они могут быть отрисованы во время GtkWidgetClass.snapshot().

Приблизительный пример того, как отрисовать все строки на корневом уровне, выполняется следующим образом:

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

Обработка событий и управление клавиатурным фокусом

Передача событий в область такая же простая, как обработка событий в обычном виджете, а затем передача их в API gtk_cell_area_event() по мере их поступления. Обычно GtkCellArea интересуется только событиями кнопок, однако могут быть реализованы некоторые настраиваемые производные области, заинтересованные в обработке других событий. Обработка события может вызвать срабатывание сигнала “focus-changed”, а также “add-editable” в случае, если была нажата редактируемая ячейка и необходимо начать редактирование. Вы можете вызвать gtk_cell_area_stop_editing() в любое время, чтобы отменить любое редактирование ячейки, которое в настоящее время выполняется.

GtkCellArea управляет клавиатурным фокусом от ячейки к ячейке, аналогично GtkWidget. Для виджетов размещения, которые поддерживают предоставление фокуса ячейкам, важно помнить о передаче GTK_CELL_RENDERER_FOCUSED функциям области для строки, у которой есть фокус, и сообщить области о рисовании фокуса во время отрисовки.

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

Базовый пример реализации виртуального метода GtkWidgetClass.focus():

GtkTreeIter iter;
int         minimum_width;
int         natural_width;

valid = gtk_tree_model_get_iter_first (model, &iter);
while (valid)
  {
    gtk_cell_area_apply_attributes (area, model, &iter, FALSE, FALSE);
    gtk_cell_area_get_preferred_width (area, context, widget, NULL, NULL);

    valid = gtk_tree_model_iter_next (model, &iter);
  }
gtk_cell_area_context_get_preferred_width (context, &minimum_width, &natural_width);

Обратите внимание, что виджет размещения отвечает за сопоставление значений GtkDirectionType с тем, как он выстраивает свои ячейки.

Свойства ячейки

Класс GtkCellArea вводит свойства ячеек для GtkCellRenderers. Это предоставляет некоторые общие интерфейсы для определения отношений областей ячеек с их ячейками. Например, в GtkCellAreaBox ячейка может «расширяться» и получать дополнительное пространство, когда область выделяется больше, чем ее полная естественная потребность, или ячейка может быть настроена на «выравнивание» с соседними строками, которые были запрошены и отображены с тем же GtkCellAreaContext.

Используйте gtk_cell_area_class_install_cell_property() для установки свойств ячеек для класса области ячейки и gtk_cell_area_class_find_cell_property() или gtk_cell_area_class_list_cell_properties() для получения информации о существующих свойствах ячеек.

Для установки значения свойства ячейки используйте gtk_cell_area_cell_set_property(), gtk_cell_area_cell_set() или gtk_cell_area_cell_set_valist(). Для получения значения свойства ячейки используйте gtk_cell_area_cell_get_property(), gtk_cell_area_cell_get() или gtk_cell_area_cell_get_valist().

GtkCellCallback ()

gboolean
(*GtkCellCallback) (GtkCellRenderer *renderer,
                    gpointer data);

Тип обратных функций, используемых для итерации по рендерерам ячеек GtkCellArea, см. gtk_cell_area_foreach().

GtkCellAllocCallback ()

gboolean
(*GtkCellAllocCallback) (GtkCellRenderer *renderer,
                         const GdkRectangle *cell_area,
                         const GdkRectangle *cell_background,
                         gpointer data);

Тип обратных функций, используемых для итерации по рендерерам ячеек и выделенным областям внутри GtkCellArea, см. gtk_cell_area_foreach_alloc().

GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID()

#define             GTK_CELL_AREA_WARN_INVALID_CELL_PROPERTY_ID(object, property_id, pspec)

Эта макрокоманда должна использоваться для вывода стандартного предупреждения о непредвиденных свойствах в set_cell_property() и get_cell_property() реализациях.

gtk_cell_area_add ()

void
gtk_cell_area_add (GtkCellArea *area,
                   GtkCellRenderer *renderer);

Добавляет renderer в area со стандартными свойствами дочерних ячеек.

gtk_cell_area_remove ()

void
gtk_cell_area_remove (GtkCellArea *area,
                      GtkCellRenderer *renderer);

Удаляет renderer из area .

gtk_cell_area_has_renderer ()

gboolean
gtk_cell_area_has_renderer (GtkCellArea *area,
                            GtkCellRenderer *renderer);

Проверяет, содержит ли area объект renderer .

gtk_cell_area_foreach ()

void
gtk_cell_area_foreach (GtkCellArea *area,
                       GtkCellCallback callback,
                       gpointer callback_data);

Вызывает callback для каждой GtkCellRenderer в area .

gtk_cell_area_foreach_alloc ()

void
gtk_cell_area_foreach_alloc (GtkCellArea *area,
                             GtkCellAreaContext *context,
                             GtkWidget *widget,
                             const GdkRectangle *cell_area,
                             const GdkRectangle *background_area,
                             GtkCellAllocCallback callback,
                             gpointer callback_data);

Вызывает callback для каждой GtkCellRenderer в area с выделенным прямоугольником внутри cell_area .

gtk_cell_area_event ()

int
gtk_cell_area_event (GtkCellArea *area,
                     GtkCellAreaContext *context,
                     GtkWidget *widget,
                     GdkEvent *event,
                     const GdkRectangle *cell_area,
                     GtkCellRendererState flags);

Делегирует обработку события GtkCellArea.

gtk_cell_area_snapshot ()

void
gtk_cell_area_snapshot (GtkCellArea *area,
                        GtkCellAreaContext *context,
                        GtkWidget *widget,
                        GtkSnapshot *snapshot,
                        const GdkRectangle *background_area,
                        const GdkRectangle *cell_area,
                        GtkCellRendererState flags,
                        gboolean paint_focus);

Создаёт моментальную копию ячеек area в соответствии с макетом area в заданных координатах.

gtk_cell_area_get_cell_allocation ()

void
gtk_cell_area_get_cell_allocation (GtkCellArea *area,
                                   GtkCellAreaContext *context,
                                   GtkWidget *widget,
                                   GtkCellRenderer *renderer,
                                   const GdkRectangle *cell_area,
                                   GdkRectangle *allocation);

Определяет выделение renderer внутри area, если area должно быть отрисовано в cell_area.

gtk_cell_area_get_cell_at-position ()

GtkCellRenderer *
gtk_cell_area_get_cell_at_position (GtkCellArea *area,
                                    GtkCellAreaContext *context,
                                    GtkWidget *widget,
                                    const GdkRectangle *cell_area,
                                    int x,
                                    int y,
                                    GdkRectangle *alloc_area);

Получает GtkCellRenderer в координатах x и y внутри area и необязательно возвращает полное выделение ячейки внутри cell_area.

gtk_cell_area_create_context ()

GtkCellAreaContext *
gtk_cell_area_create_context (GtkCellArea *area);

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

gtk_cell_area_copy_context ()

GtkCellAreaContext *
gtk_cell_area_copy_context (GtkCellArea *area,
                            GtkCellAreaContext *context);

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

Например, GtkIconView создаёт все значки (строки) с одинаковой шириной, а ячейки в них — с одинаковым горизонтальным выравниванием. Однако каждая строка значков может иметь отдельный общий размер высоты. GtkIconView использует это, чтобы запросить высоту каждой строки на основе контекста, который уже использовался для запроса всех отображаемых ширин строк.

gtk_cell_area_get_request_mode ()

GtkSizeRequestMode
gtk_cell_area_get_request_mode (GtkCellArea *area);

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

gtk_cell_area_get_preferred_width ()

void
gtk_cell_area_get_preferred_width (GtkCellArea *area,
                                   GtkCellAreaContext *context,
                                   GtkWidget *widget,
                                   int *minimum_width,
                                   int *natural_width);

Получает начальную минимальную и естественную ширину области ячейки.

area будет хранить некоторую геометрическую информацию в context по ходу; при запросе размеров произвольного числа строк, не важно проверять minimum_width и natural_width этого вызова, а лучше обратиться к gtk_cell_area_context_get_preferred_width() после серии запросов.

gtk_cell_area_get_preferred_height_for_width ()

void
gtk_cell_area_get_preferred_height_for_width
                               (GtkCellArea *area,
                                GtkCellAreaContext *context,
                                GtkWidget *widget,
                                int width,
                                int *minimum_height,
                                int *natural_height);

Получает минимальную и естественную высоту области ячейки, если ей будет задана указанная width .

area хранит некоторую геометрическую информацию в context во время вызова gtk_cell_area_get_preferred_width(). Важно выполнить серию запросов gtk_cell_area_get_preferred_width() с context сначала, а затем вызвать gtk_cell_area_get_preferred_height_for_width() для каждой области ячеек индивидуально, чтобы получить высоту для ширины каждой полностью запрошенной строки.

Если в какой-то момент ширина одной строки изменяется, её необходимо снова запросить с помощью gtk_cell_area_get_preferred_width(), а затем снова проверить полную ширину запрошенных строк с помощью gtk_cell_area_context_get_preferred_width().

gtk_cell_area_get_preferred_height ()

void
gtk_cell_area_get_preferred_height (GtkCellArea *area,
                                    GtkCellAreaContext *context,
                                    GtkWidget *widget,
                                    int *minimum_height,
                                    int *natural_height);

Получает начальную минимальную и естественную высоту области ячейки.

area будет хранить некоторую геометрическую информацию в context по ходу выполнения; при запросе размеров по произвольному числу строк, неважно проверять minimum_height и natural_height этого вызова, а скорее обратиться к gtk_cell_area_context_get_preferred_height() после серии запросов.

gtk_cell_area_get_preferred_width_for_height ()

void
gtk_cell_area_get_preferred_width_for_height
                               (GtkCellArea *area,
                                GtkCellAreaContext *context,
                                GtkWidget *widget,
                                int height,
                                int *minimum_width,
                                int *natural_width);

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

area хранит некоторую геометрическую информацию в context по ходу выполнения вызова gtk_cell_area_get_preferred_height(). Важно выполнить серию запросов gtk_cell_area_get_preferred_height() с context сначала, а затем вызвать gtk_cell_area_get_preferred_width_for_height() для каждой области ячейки индивидуально, чтобы получить высоту для ширины каждой полностью запрошенной строки.

Если в какой-то момент высота одной строки изменяется, её следует снова запросить с помощью gtk_cell_area_get_preferred_height(), а затем снова проверить полную высоту запрошенных строк с помощью gtk_cell_area_context_get_preferred_height().

gtk_cell_area_get_current_path_string ()

const char *
gtk_cell_area_get_current_path_string (GtkCellArea *area);

Получает строковое представление текущего GtkTreePath для текущего применённого GtkTreeIter. Оно неявно обновляется при вызове gtk_cell_area_apply_attributes() и может использоваться для взаимодействия с рендерерами из подклассов GtkCellArea.

gtk_cell_area_apply_attributes ()

void
gtk_cell_area_apply_attributes (GtkCellArea *area,
                                GtkTreeModel *tree_model,
                                GtkTreeIter *iter,
                                gboolean is_expander,
                                gboolean is_expanded);

Применяет все подключённые атрибуты к рендерерам в area, извлекая значения из tree_model.

gtk_cell_area_attribute_connect ()

void
gtk_cell_area_attribute_connect (GtkCellArea *area,
                                 GtkCellRenderer *renderer,
                                 const char *attribute,
                                 int column);

Подключает attribute для применения значений из column для используемого GtkTreeModel.

gtk_cell_area_attribute_disconnect ()

void
gtk_cell_area_attribute_disconnect (GtkCellArea *area,
                                    GtkCellRenderer *renderer,
                                    const char *attribute);

Отключает attribute для renderer в area, чтобы атрибут больше не обновлялся значениями из модели.

gtk_cell_area_attribute_get_column ()

int
gtk_cell_area_attribute_get_column (GtkCellArea *area,
                                    GtkCellRenderer *renderer,
                                    const char *attribute);

Возвращает столбец модели, к которому сопоставлен атрибут, или -1, если атрибут не сопоставлен.

gtk_cell_area_class_install_cell_property ()

void
gtk_cell_area_class_install_cell_property
                               (GtkCellAreaClass *aclass,
                                guint property_id,
                                GParamSpec *pspec);

Устанавливает свойство ячейки в классе области ячейки.

gtk_cell_area_class_find_cell_property ()

GParamSpec *
gtk_cell_area_class_find_cell_property
                               (GtkCellAreaClass *aclass,
                                const char *property_name);

Находит свойство ячейки класса области ячейки по имени.

gtk_cell_area_class_list_cell_properties ()

GParamSpec **
gtk_cell_area_class_list_cell_properties
                               (GtkCellAreaClass *aclass,
                                guint *n_properties);

Возвращает все свойства ячейки класса области ячейки.

gtk_cell_area_add_with_properties ()

void
gtk_cell_area_add_with_properties (GtkCellArea *area,
                                   GtkCellRenderer *renderer,
                                   const char *first_prop_name,
                                   ...);

Добавляет renderer в area, одновременно устанавливая свойства ячейки. Подробнее см. gtk_cell_area_add() и gtk_cell_area_cell_set().

gtk_cell_area_cell_set ()

void
gtk_cell_area_cell_set (GtkCellArea *area,
                        GtkCellRenderer *renderer,
                        const char *first_prop_name,
                        ...);

Устанавливает одно или несколько свойств ячейки для cell в area.

gtk_cell_area_cell_get ()

void
gtk_cell_area_cell_get (GtkCellArea *area,
                        GtkCellRenderer *renderer,
                        const char *first_prop_name,
                        ...);

Получает значения одного или нескольких свойств ячейки для renderer в area.

gtk_cell_area_cell_set_valist ()

void
gtk_cell_area_cell_set_valist (GtkCellArea *area,
                               GtkCellRenderer *renderer,
                               const char *first_property_name,
                               va_list var_args);

Устанавливает одно или несколько свойств ячейки для renderer в area.

gtk_cell_area_cell_get_valist ()

void
gtk_cell_area_cell_get_valist (GtkCellArea *area,
                               GtkCellRenderer *renderer,
                               const char *first_property_name,
                               va_list var_args);

Получает значения одного или нескольких свойств ячейки для renderer в area.

gtk_cell_area_cell_set_property ()

void
gtk_cell_area_cell_set_property (GtkCellArea *area,
                                 GtkCellRenderer *renderer,
                                 const char *property_name,
                                 const GValue *value);

Устанавливает свойство ячейки для renderer в area.

gtk_cell_area_cell_get_property ()

void
gtk_cell_area_cell_get_property (GtkCellArea *area,
                                 GtkCellRenderer *renderer,
                                 const char *property_name,
                                 GValue *value);

Получает значение свойства ячейки для renderer в area.

gtk_cell_area_is_activatable ()

gboolean
gtk_cell_area_is_activatable (GtkCellArea *area);

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

gtk_cell_area_activate ()

gboolean
gtk_cell_area_activate (GtkCellArea *area,
                        GtkCellAreaContext *context,
                        GtkWidget *widget,
                        const GdkRectangle *cell_area,
                        GtkCellRendererState flags,
                        gboolean edit_only);

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

gtk_cell_area_focus ()

gboolean
gtk_cell_area_focus (GtkCellArea *area,
                     GtkDirectionType direction);

Этот метод должен вызываться виджетом-макетом, владеющим area, когда фокус должен передаваться area или перемещаться внутри area для заданных direction и данных строки.

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

gtk_cell_area_set_focus_cell ()

void
gtk_cell_area_set_focus_cell (GtkCellArea *area,
                              GtkCellRenderer *renderer);

Явно устанавливает текущую ячейку с фокусом на renderer.

Обычно вызывается реализациями GtkCellAreaClass.focus() или GtkCellAreaClass.event(), но также может использоваться для реализации функций, таких как gtk_tree_view_set_cursor_on_cell().

gtk_cell_area_get_focus_cell ()

GtkCellRenderer *
gtk_cell_area_get_focus_cell (GtkCellArea *area);

Получает текущую ячейку с фокусом для area.

gtk_cell_area_add_focus_sibling ()

void
gtk_cell_area_add_focus_sibling (GtkCellArea *area,
                                 GtkCellRenderer *renderer,
                                 GtkCellRenderer *sibling);

Добавляет sibling в область фокуса renderer. Фокус будет нарисован вокруг renderer и всех его соседей, если renderer может получить фокус для данной строки.

События, обрабатываемые фокусными соседями, также могут активировать указанный фокусируемый renderer.

gtk_cell_area_remove_focus_sibling ()

void
gtk_cell_area_remove_focus_sibling (GtkCellArea *area,
                                    GtkCellRenderer *renderer,
                                    GtkCellRenderer *sibling);

Удаляет sibling из списка фокусных соседей renderer (см. gtk_cell_area_add_focus_sibling()).

gtk_cell_area_is_focus_sibling ()

gboolean
gtk_cell_area_is_focus_sibling (GtkCellArea *area,
                                GtkCellRenderer *renderer,
                                GtkCellRenderer *sibling);

Возвращает, является ли sibling одним из фокусных соседей renderer (см. gtk_cell_area_add_focus_sibling()).

gtk_cell_area_get_focus_siblings ()

const GList *
gtk_cell_area_get_focus_siblings (GtkCellArea *area,
                                  GtkCellRenderer *renderer);

Получает фокусные соседние элементы рендеринга ячеек для renderer.

gtk_cell_area_get_focus_from_sibling ()

GtkCellRenderer *
gtk_cell_area_get_focus_from_sibling (GtkCellArea *area,
                                      GtkCellRenderer *renderer);

Получает GtkCellRenderer, который ожидается для фокусирования, для которого renderer является, или может быть, соседом.

Это удобно для подклассов GtkCellArea при обработке событий, после определения рендера в месте события, он может затем выбрать активацию ячейки фокуса, для которой ячейка события может быть соседом.

gtk_cell_area_get_edited_cell ()

GtkCellRenderer *
gtk_cell_area_get_edited_cell (GtkCellArea *area);

Получает GtkCellRenderer в area, который в настоящее время редактируется.

gtk_cell_area_get_edit_widget ()

GtkCellEditable *
gtk_cell_area_get_edit_widget (GtkCellArea *area);

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

gtk_cell_area_activate_cell ()

gboolean
gtk_cell_area_activate_cell (GtkCellArea *area,
                             GtkWidget *widget,
                             GtkCellRenderer *renderer,
                             GdkEvent *event,
                             const GdkRectangle *cell_area,
                             GtkCellRendererState flags);

Этот метод используется подклассами GtkCellArea при обработке событий для активации ячеек. Базовый класс GtkCellArea активирует ячейки для событий клавиатуры самостоятельно в своей реализации GtkCellArea->activate().

gtk_cell_area_stop_editing ()

void
gtk_cell_area_stop_editing (GtkCellArea *area,
                            gboolean canceled);

Явно останавливает редактирование текущей ячейки.

Если canceled имеет значение TRUE, текущий редактируемый элемент отображения ячейки вызовет сигнал ::editing-canceled, в противном случае будет вызван сигнал ::editing-done на текущем элементе редактирования.

См. gtk_cell_area_get_edited_cell() и gtk_cell_area_get_edit_widget().

gtk_cell_area_inner_cell_area ()

void
gtk_cell_area_inner_cell_area (GtkCellArea *area,
                               GtkWidget *widget,
                               const GdkRectangle *cell_area,
                               GdkRectangle *inner_area);

Эта вспомогательная функция для реализаций GtkCellArea позволяет получить внутреннюю область, где будет отрисовываться заданный GtkCellRenderer. Она удаляет любой отступ, добавленный ранее функцией gtk_cell_area_request_renderer().

gtk_cell_area_request-renderer ()

void
gtk_cell_area_request_renderer (GtkCellArea *area,
                                GtkCellRenderer *renderer,
                                GtkOrientation orientation,
                                GtkWidget *widget,
                                int for_size,
                                int *minimum_size,
                                int *natural_size);

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