Наши партнеры

Библиотека сайта rus-linux.net

Программирование с использованием gtkmm 3. Собственные виджеты

Оригинал: Programming with gtkmm 3
Авторы: Murray Cumming, Bernhard Rieder, Jonathon Jongsma, Ole Laursen, Marko Anastasov, Daniel Elstner, Chris Vine, David King, Pedro Ferreira, Kjell Ahlstedt
Дата публикации: 15 Октября 2013 г.
Перевод: А.Панин
Дата перевода: 10 Апреля 2014 г.

28. Собственные виджеты

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

28.1. Собственные контейнерные виджеты

При наследовании класса виджета от класса Gtk::Container вы должны перекрыть следующие виртуальные методы:

get_request_mode_vfunc(): Возврат указания на предпочтительный для контейнера режим запроса размера типа Gtk::SizeRequestMode.
get_preferred_width_vfunc(): Расчет минимальной и обычной ширины контейнера.
get_preferred_height_vfunc(): Расчет минимальной и обычной высоты контейнера.
get_preferred_width_for_height_vfunc(): Расчет минимальной и обычной ширины контейнера в случае передачи заданного значения высоты.
get_preferred_height_for_width_vfunc(): Расчет минимальной и обычной высоты контейнера в случае передачи заданного значения ширины.
on_size_allocate(): Позиционирование дочерних виджетов при условии передачи реальных значений высоты и ширины контейнера.
forall_vfunc(): Вызов одной и той же функции обратного вызова для каждого из дочерних виджетов.
on_add(): Добавление дочернего виджета в контейнер.
on_remove(): Удаление дочернего виджета из контейнера.
child_type_vfunc(): Возврат типа доступного для вставки дочернего виджета.

Виртуальные методы get_request_mode_vfunc(), get_preferred_width_vfunc(), get_preferred_height_vfunc(), get_preferred_width_for_height_vfunc(), get_preferred_height_for_width_vfunc() и on_size_allocate() контролируют размещение дочерних виджетов. Например, в том случае, если ваш контейнер содержит 2 дочерних виджета, причем один находится под другим, ваш метод get_request_vfunc() может возвращать идентификатор режима изменения высоты в зависимости от ширины. После этого ваш метод get_preferred_width_func() может возвращать максимальное из значений ширины дочерних виджетов, а метод get_preferred_height_for_width_vfunc() - сумму их высот. Если вы захотите добавить границу между дочерними виджетами, вам придется также добавить ее ширину к значениям ширины и высоты. Контейнер вашего виджета будет использовать эти результирующие значения для гарантированного получения вашим виджетом достаточного пространства, а не меньшего пространства, чем ему требуется. Путем получения параметров родительского виджета каждого из виджетов, с последующим получением параметров его родительского виджета, данный алгоритм в конце концов позволяет вычислить размеры окна верхнего уровня.

Нет никакой гарантии, что вы получите тот идентификатор режима запроса размера типа Gtk::SizeRequestMode, который вы предлагали использовать. Следовательно, все четыре метода get_preferred_xxx_vfunc() должны возвращать имеющие смысл значения.

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

В том случае, если ваш контейнерный виджет не является окном верхнего уровня на основе унаследованного от класса Gtk::Window класса, вам, скорее всего, придется осуществлять вызов метода Gtk::Widget::set_has_window(false) в рамках вашего конструктора. Это значит, что ваш контейнерный виджет не будет создавать свой экземпляр класса Gtk::Window, а будет использовать окно родительского виджета. (Обратите внимание на различия классов Gtk::Window и Gdk::Window). В том случае, если вашему контейнерному виджету не требуется свой экземпляр класса Gdk::Window, причем его класс не наследуется от класса Gtk::Window, вы должны также перекрыть метод on_realize() таким же образом, как описано в разделе "Собственные виджеты общего назначения". И в том случае, если ваш контейнерный виджет не осуществляет прорисовку непосредственно в расположенном уровнем ниже окне на основе класса Gdk::Window, вы, скорее всего, должны осуществить вызов метода set_redraw_on_allocate(false) для повышения производительности.

Перекрывая метод forall_vfunc(), вы можете позволить приложениям управлять всеми дочерними виджетами контейнерных виджетов. Например, метод show_all_children() использует этот метод для поиска всех дочерних виджетов и их показа.

Хотя ваш контейнерный виджет и может иметь свой метод для упаковки дочерних виджетов, вы всегда должны предоставлять реализации виртуальных методов on_add() и on_remove() из базового класса, следовательно, методы add() и remove() должны выполнять соответствующие операции при вызове.

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

28.1.1. Пример

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

Рисунок 28-1: Собственный контейнерный виджет

Исходный код

Файл: examplewindow.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: mycontainer.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#ifndef GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H
#define GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

#include <gtkmm/container.h>

class MyContainer : public Gtk::Container
{
public:
  MyContainer();
  virtual ~MyContainer();

void set_child_widgets(Gtk::Widget& child_one, Gtk::Widget& child_two);

protected:

//Перекрытые методы:
  virtual Gtk::SizeRequestMode get_request_mode_vfunc() const;
  virtual void get_preferred_width_vfunc(int& minimum_width, int& natural_width) const;
  virtual void get_preferred_height_for_width_vfunc(int width, int& minimum_height, int& natural_height) const;
  virtual void get_preferred_height_vfunc(int& minimum_height, int& natural_height) const;
  virtual void get_preferred_width_for_height_vfunc(int height, int& minimum_width, int& natural_width) const;
  virtual void on_size_allocate(Gtk::Allocation& allocation);

virtual void forall_vfunc(gboolean include_internals, GtkCallback callback, gpointer callback_data);

virtual void on_add(Gtk::Widget* child);
  virtual void on_remove(Gtk::Widget* child);
  virtual GType child_type_vfunc() const;

Gtk::Widget* m_child_one;
  Gtk::Widget* m_child_two;
};

#endif //GTKMM_CUSTOM_CONTAINER_MYCONTAINER_H

Файл: examplewindow.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#include <iostream>
#include "examplewindow.h"

ExampleWindow::ExampleWindow()
: m_VBox(Gtk::ORIENTATION_VERTICAL),
  m_Button_One("Дочерний виджет номер один"),
  m_Label_Two("Дочерний виджет 2"),
  m_Button_Quit("Выход")
{
  set_title("Пример собственного контейнерного виджета");
  set_border_width(6);
  set_default_size(400, 200);

add(m_VBox);

//Добавление дочерних виджетов в собственный контейнерный виджет:
  m_MyContainer.set_child_widgets(m_Button_One, m_Label_Two);

m_Label_Two.set_alignment(1.0, 0.5);

m_VBox.pack_start(m_MyContainer, Gtk::PACK_EXPAND_WIDGET);
  m_VBox.pack_start(m_ButtonBox, Gtk::PACK_SHRINK);

m_ButtonBox.pack_start(m_Button_Quit, Gtk::PACK_SHRINK);
  m_ButtonBox.set_border_width(6);
  m_ButtonBox.set_layout(Gtk::BUTTONBOX_END);
  m_Button_Quit.signal_clicked().connect( sigc::mem_fun(*this,
              &ExampleWindow::on_button_quit) );

show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_button_quit()
{
  hide();
}

Файл: main.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: mycontainer.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#include <iostream>
#include <algorithm> // std::max
#include "mycontainer.h"

MyContainer::MyContainer()
: m_child_one(0), m_child_two(0)
{
  set_has_window(false);
  set_redraw_on_allocate(false);
}

MyContainer::~MyContainer()
{
/*
  // Эти вызовы метода Gtk::Widget::unparent() необходимы тогда, когда экземпляр класса MyContainer
  // уничтожается перед экземпляром класса дочернего виджета. Но если вы используете версию gtkmm, в 
  // которой ошибка https://bugzilla.gnome.org/show_bug.cgi?id=605728
  // не была исправлена (версию gtkmm 3.7.10 или более раннюю) и дочерние виджеты будут 
  // уничтожены до уничтожения контейнерного виджета, эти вызовы могут привести к аварийному завершению
  // работы приложения. Это происходит из-за того, что метод on_remove() не вызывается при
  // уничтожении дочерних виджетов.
  if (m_child_one)
    m_child_one->unparent();

if (m_child_two)
    m_child_two->unparent();
*/
}

void MyContainer::set_child_widgets(Gtk::Widget& child_one,
        Gtk::Widget& child_two)
{
  m_child_one = &child_one;
  m_child_two = &child_two;

m_child_one->set_parent(*this);
  m_child_two->set_parent(*this);
}

//Данный пример контейнерного виджета является упрощенной версией вертикального контейнера общего назначения (VBox) для хранения не более двух виджетов.
Gtk::SizeRequestMode MyContainer::get_request_mode_vfunc() const
{
  return Gtk::SIZE_REQUEST_HEIGHT_FOR_WIDTH;
}

//Установление суммарных минимального и обычного размеров областей, необходимых 
//для этого контейнерного виджета и его дочерних виджетов.
void MyContainer::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
{
  int child_minimum_width[2] = {0, 0};
  int child_natural_width[2] = {0, 0};

if(m_child_one && m_child_one->get_visible())
    m_child_one->get_preferred_width(child_minimum_width[0], child_natural_width[0]);

if(m_child_two && m_child_two->get_visible())
    m_child_two->get_preferred_width(child_minimum_width[1], child_natural_width[1]);

//Запрос установки ширины, равной наибольшей ширине дочернего виджета.
  minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
  natural_width = std::max(child_natural_width[0], child_natural_width[1]);
}

void MyContainer::get_preferred_height_for_width_vfunc(int width,
   int& minimum_height, int& natural_height) const
{
  int child_minimum_height[2] = {0, 0};
  int child_natural_height[2] = {0, 0};
  int nvis_children = 0;

if(m_child_one && m_child_one->get_visible())
  {
    ++nvis_children;
    m_child_one->get_preferred_height_for_width(width, child_minimum_height[0],
                                                child_natural_height[0]);
  }

if(m_child_two && m_child_two->get_visible())
  {
    ++nvis_children;
    m_child_two->get_preferred_height_for_width(width, child_minimum_height[1],
                                                child_natural_height[1]);
  }

//Установленная высота будет разделена поровну между видимыми дочерними виджетами.
  //Запрос установки высоты, равной произведению количества видимых дочерних виджетов 
  //и наибольшей высоты дочернего виджета.
  minimum_height = nvis_children * std::max(child_minimum_height[0],
                                            child_minimum_height[1]);
  natural_height = nvis_children * std::max(child_natural_height[0],
                                            child_natural_height[1]);
}

void MyContainer::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
{
  int child_minimum_height[2] = {0, 0};
  int child_natural_height[2] = {0, 0};
  int nvis_children = 0;

if(m_child_one && m_child_one->get_visible())
  {
    ++nvis_children;
    m_child_one->get_preferred_height(child_minimum_height[0], child_natural_height[0]);
  }

if(m_child_two && m_child_two->get_visible())
  {
    ++nvis_children;
    m_child_two->get_preferred_height(child_minimum_height[1], child_natural_height[1]);
  }

void MyContainer::get_preferred_width_for_height_vfunc(int height,
   int& minimum_width, int& natural_width) const
{
  int child_minimum_width[2] = {0, 0};
  int child_natural_width[2] = {0, 0};
  int nvis_children = 0;

//Получение количества видимых дочерних виджетов.
  if(m_child_one && m_child_one->get_visible())
    ++nvis_children;
  if(m_child_two && m_child_two->get_visible())
    ++nvis_children;

if(nvis_children > 0)
  {
    //Разделение высоты поровну между видимыми дочерними виджетами.
    const int height_per_child = height / nvis_children;

if(m_child_one && m_child_one->get_visible())
      m_child_one->get_preferred_width_for_height(height_per_child,
                   child_minimum_width[0], child_natural_width[0]);

if(m_child_two && m_child_two->get_visible())
      m_child_two->get_preferred_width_for_height(height_per_child,
                   child_minimum_width[1], child_natural_width[1]);
  }

//Запрос установки ширины, равной наибольшей ширине виджета.
  minimum_width = std::max(child_minimum_width[0], child_minimum_width[1]);
  natural_width = std::max(child_natural_width[0], child_natural_width[1]);
}

void MyContainer::on_size_allocate(Gtk::Allocation& allocation)
{
  //Выполнение каких-либо действий с областью, которая была на самом деле предоставлена:
  //(Нам не будет предоставлена область с шириной и высотой меньше запрошенных, хотя
  //значения ширины и высоты и могут быть больше запрошенных.)

//Использование предоставленного пространства для данного контейнера:
  set_allocation(allocation);

//Получение количества видимых дочерних виджетов.
  int nvis_children = 0;
  if(m_child_one && m_child_one->get_visible())
    ++nvis_children;
  if(m_child_two && m_child_two->get_visible())
    ++nvis_children;

if(nvis_children <= 0)
    return;

//Распределение пространства между дочерними виджетами:
  Gtk::Allocation child_allocation_one;
  Gtk::Allocation child_allocation_two;

//Размещение первого дочернего виджета в левом верхнем углу:
  child_allocation_one.set_x( allocation.get_x() );
  child_allocation_one.set_y( allocation.get_y() );

//Размещение виджета таким образом, чтобы он занял всю ширину доступной области:
  child_allocation_one.set_width( allocation.get_width() );

if(m_child_one && m_child_one->get_visible())
  {
    //Разделение высоты поровну между видимыми дочерними виджетами.
    child_allocation_one.set_height( allocation.get_height() / nvis_children);
    m_child_one->size_allocate(child_allocation_one);
  }
  else
    child_allocation_one.set_height(0);

//Размещение второго дочернего виджета под первым дочерним виджетом:
  child_allocation_two.set_x( allocation.get_x() );
  child_allocation_two.set_y( allocation.get_y() +
          child_allocation_one.get_height());

//Размещение виджета таким образом, чтобы он занял всю ширину доступной области:
  child_allocation_two.set_width( allocation.get_width() );

//Данный виджет также должен занять всю оставшуюся высоту:
  child_allocation_two.set_height( allocation.get_height() -
          child_allocation_one.get_height());

if(m_child_two && m_child_two->get_visible())
    m_child_two->size_allocate(child_allocation_two);
}

void MyContainer::forall_vfunc(gboolean, GtkCallback callback, gpointer callback_data)
{
  if(m_child_one)
    callback(m_child_one->gobj(), callback_data);

if(m_child_two)
    callback(m_child_two->gobj(), callback_data);
}

void MyContainer::on_add(Gtk::Widget* child)
{
  if(!m_child_one)
  {
    m_child_one = child;
    m_child_one->set_parent(*this);
  }
  else if(!m_child_two)
  {
    m_child_two = child;
    m_child_two->set_parent(*this);
  }
}

void MyContainer::on_remove(Gtk::Widget* child)
{
  if(child)
  {
    const bool visible = child->get_visible();
    bool found = false;

if(child == m_child_one)
    {
      m_child_one = 0;
      found = true;
    }
    else if(child == m_child_two)
    {
      m_child_two = 0;
      found = true;
    }

if(found)
    {
      child->unparent();

if(visible)
        queue_resize();
    }
  }
}

GType MyContainer::child_type_vfunc() const
{
  //В том случае, если все еще имеется пространство для одного виджета, сообщается
  //тип виджета, который может быть добавлен.
  if(!m_child_one || !m_child_two)
    return Gtk::Widget::get_type();
  else
  {
    //Добавить большее количество виджетов невозможно.
    return G_TYPE_NONE;
  }
}

28.2. Собственные виджеты общего назначения

Наследуя класс виджета от класса Gtk::Widget, вы можете непосредственно осуществлять все операции прорисовки вашего виджета вместо размещения дочерних виджетов в рамках собственного виджета. К примеру, виджет вывода строки на основе класса Gtk::Label прорисовывает символы выводимой строки, не используя при этом сторонние виджеты.

При наследовании класса виджета от класса Gtk::Widget вы должны перекрыть приведенные ниже виртуальные методы. Методы, отмеченные как (необязательные), не должны перекрываться во всех виджетах общего назначения. При этом методы базового класса могут подходить для реализации функций виджета.

get_request_mode_vfunc(): (необязательный) Возврат предпочтительного для виджета режима запроса размеров типа Gtk::SizeRequestMode.
get_preferred_width_vfunc(): Расчет минимальной и обычной ширины виджета.
get_preferred_height_vfunc(): Расчет минимальной и обычной высоты виджета.
get_preferred_width_for_height_vfunc(): Расчет минимальной и обычной ширины виджета в случае передачи заданного значения высоты.
get_preferred_height_for_width_vfunc(): расчет минимальной и обычной высоты виджета в случае передачи заданного значения ширины.
on_size_allocate(): Позиционирование виджета на основании реальных значений ширины и высоты.
on_realize(): Ассоциация окна на основе класса Gdk::Window с виджетом.
on_unrealize(): (необязательный) Разрыв ассоциации с окном на основе класса Gdk::Window.
on_map(): (необязательный)
on_unmap(): (необязательный)
on_draw(): Прорисовка виджета с использованием переданного экземпляра класса контекста Cairo Cairo::Context.

Первые 6 методов аналогичны методам из предыдущего списка и перекрываются при работе с собственными контейнерными виджетами. Эти методы кратко описаны в разделе "Собственные контейнерные виджеты".

Большей части собственных виджетов общего назначения требуется собственное окно на основе класса Gdk::Window для рисования на его поверхности. Впоследствии вы можете вызвать метод Gtk::Widget::set_has_window(true) в рамках вашего конструктора. (Это стандартное значение аргумента.) В том случае, если вы не осуществите вызов метода set_has_window(false), вы должны перекрыть метод on_realize() и осуществить вызовы методов Gtk::Widget::set_realized() и Gtk::Widget::set_window() из перекрытого метода.

28.2.1. Пример

В рамках данного примера реализован виджет, который выводит треугольник Пенроуза.

Рисунок 28-2: Собственный виджет общего назначения

Исходный код

Файл: mywidget.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#ifndef GTKMM_CUSTOM_WIDGET_MYWIDGET_H
#define GTKMM_CUSTOM_WIDGET_MYWIDGET_H

#include <gtkmm/widget.h>
#include <gtkmm/cssprovider.h>

class MyWidget : public Gtk::Widget
{
public:
  MyWidget();
  virtual ~MyWidget();

protected:

Glib::RefPtr<Gdk::Window> m_refGdkWindow;
  Glib::RefPtr<Gtk::CssProvider> m_refStyleProvider;

int m_scale;
};

#endif //GTKMM_CUSTOM_WIDGET_MYWIDGET_H

Файл: examplewindow.h (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: examplewindow.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: main.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

Файл: mywidget.cc (Для использования совместно с gtkmm 3, а не с gtkmm 2)

#include "mywidget.h"
#include <gdkmm/general.h>  // для вспомогательных функций библиотеки cairo
#include <iostream>
//#include <gtk/gtkwidget.h> //Для макроса GTK_IS_WIDGET()
#include <cstring>

MyWidget::MyWidget() :
  //В системе типов GType имя будет на самом деле gtkmm__CustomObject_mywidget
  Glib::ObjectBase("mywidget"),
  Gtk::Widget(),
  m_scale(1000)
{
  set_has_window(true);

//Данный вызов выводит имя из системы типов GType, которое должно использоваться в файле CSS.
  std::cout << "Имя GType: " << G_OBJECT_TYPE_NAME(gobj()) << std::endl;

//Данный вызов показывает, что тип GType все еще происходит от типа класса Gtk::Widget:
  //std::cout << "Тип Gtype происходит от типа класса GtkWidget?:" << GTK_IS_WIDGET(gobj()) << std::endl;

//Установка стиля для того, чтобы внешний вид данного виджета мог настраиваться с
  //помощью файла таблицы стилей CSS:
  gtk_widget_class_install_style_property(GTK_WIDGET_CLASS(
              G_OBJECT_GET_CLASS(gobj())),
      g_param_spec_int("example_scale",
        "Масштаб рисунка примера",
        "Используемый при выводе рисунка масштаб. Это просто нелепый пример.",
        G_MININT,
        G_MAXINT,
        500,
        G_PARAM_READABLE) );

m_refStyleProvider = Gtk::CssProvider::create();
  Glib::RefPtr<Gtk::StyleContext> refStyleContext = get_style_context();
  refStyleContext->add_provider(m_refStyleProvider, 
    GTK_STYLE_PROVIDER_PRIORITY_APPLICATION);
    
  try
  {
    m_refStyleProvider->load_from_path("custom_gtk.css");
  }
  catch(const Glib::Error& ex)
  {
    std::cerr << "Ошибка при вызове метода Gtk::CssProvider::load_from_path(): " << ex.what() << std::endl;
  }
}

MyWidget::~MyWidget()
{
}

Gtk::SizeRequestMode MyWidget::get_request_mode_vfunc() const
{
  //Использование стандартного значения, предоставленного базовым классом.
  return Gtk::Widget::get_request_mode_vfunc();
}

//Установление суммарных минимальных и обычных размеров области, необходимой
//для данного виджета.
//Давайте сделаем так, чтобы этот простой виджет из примера всегда требовал область 
//минимального размера 60x50 и обычного размера 100x70.
void MyWidget::get_preferred_width_vfunc(int& minimum_width, int& natural_width) const
{
  minimum_width = 60;
  natural_width = 100;
}

void MyWidget::get_preferred_height_for_width_vfunc(int /* width */,
   int& minimum_height, int& natural_height) const
{
  minimum_height = 50;
  natural_height = 70;
}

void MyWidget::get_preferred_height_vfunc(int& minimum_height, int& natural_height) const
{
  minimum_height = 50;
  natural_height = 70;
}

void MyWidget::get_preferred_width_for_height_vfunc(int /* height */,
   int& minimum_width, int& natural_width) const
{
  minimum_width = 60;
  natural_width = 100;
}

void MyWidget::on_size_allocate(Gtk::Allocation& allocation)
{
  //Выполнение каких-либо действий с полученной нами реальной областью:
  //(Мы не получим область с шириной или высотой меньше запрошенных, хотя и можем
  //получить область с шириной и высотой больше запрошенных)

//Использование полученных параметров размещения для данного контейнера:
  set_allocation(allocation);

if(m_refGdkWindow)
  {
    m_refGdkWindow->move_resize( allocation.get_x(), allocation.get_y(),
            allocation.get_width(), allocation.get_height() );
  }
}

void MyWidget::on_map()
{
  //Вызов метода базового класса:
  Gtk::Widget::on_map();
}

void MyWidget::on_unmap()
{
  //Вызов метода базового класса:
  Gtk::Widget::on_unmap();
}

void MyWidget::on_realize()
{
  //Не нужно вызывать метод базового класса Gtk::Widget::on_realize().
  //Он предназначен только для виджетов, при создании которых был вызван метод set_has_window(false).

set_realized();

//Получение стиля из темы или файла CSS:
  get_style_property("example_scale", m_scale);
  std::cout << "параметр m_scale (example_scale из темы/файла css): "
      << m_scale << std::endl;

if(!m_refGdkWindow)
  {
    //Создание экземпляра класса Gdk::Window:

GdkWindowAttr attributes;
    memset(&attributes, 0, sizeof(attributes));

Gtk::Allocation allocation = get_allocation();

//Установка начальной позиции и размера окна на основе класса Gdk::Window:
    attributes.x = allocation.get_x();
    attributes.y = allocation.get_y();
    attributes.width = allocation.get_width();
    attributes.height = allocation.get_height();

attributes.event_mask = get_events () | Gdk::EXPOSURE_MASK;
    attributes.window_type = GDK_WINDOW_CHILD;
    attributes.wclass = GDK_INPUT_OUTPUT;

m_refGdkWindow = Gdk::Window::create(get_parent_window(), &attributes,
            GDK_WA_X | GDK_WA_Y);
    set_window(m_refGdkWindow);

//установка цветов
    override_background_color(Gdk::RGBA("red"));
    override_color(Gdk::RGBA("blue"));

//активация механизма приема виджетом событий перерисовки
    m_refGdkWindow->set_user_data(gobj());
  }
}

void MyWidget::on_unrealize()
{
  m_refGdkWindow.reset();

//Вызов метода базового класса:
  Gtk::Widget::on_unrealize();
}

bool MyWidget::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
  const double scale_x = (double)get_allocation().get_width() / m_scale;
  const double scale_y = (double)get_allocation().get_height() / m_scale;

// прорисовка фона
  Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_background_color());
  cr->paint();

// прорисовка изображения треугольника
  Gdk::Cairo::set_source_rgba(cr, get_style_context()->get_color());
  cr->move_to(155.*scale_x, 165.*scale_y);
  cr->line_to(155.*scale_x, 838.*scale_y);
  cr->line_to(265.*scale_x, 900.*scale_y);
  cr->line_to(849.*scale_x, 564.*scale_y);
  cr->line_to(849.*scale_x, 438.*scale_y);
  cr->line_to(265.*scale_x, 100.*scale_y);
  cr->line_to(155.*scale_x, 165.*scale_y);
  cr->move_to(265.*scale_x, 100.*scale_y);
  cr->line_to(265.*scale_x, 652.*scale_y);
  cr->line_to(526.*scale_x, 502.*scale_y);
  cr->move_to(369.*scale_x, 411.*scale_y);
  cr->line_to(633.*scale_x, 564.*scale_y);
  cr->move_to(369.*scale_x, 286.*scale_y);
  cr->line_to(369.*scale_x, 592.*scale_y);
  cr->move_to(369.*scale_x, 286.*scale_y);
  cr->line_to(849.*scale_x, 564.*scale_y);
  cr->move_to(633.*scale_x, 564.*scale_y);
  cr->line_to(155.*scale_x, 838.*scale_y);
  cr->stroke();

return true;
}

Следующий раздел : Многопоточные программы.