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

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

Программирование с использованием gtkmm 3. Палитра инструментов (ToolPalette)

Оригинал: 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 г.
Перевод: А.Панин
Дата перевода: 15 марта 2014 г.

Палитра инструментов (реализованная в рамках класса Gtk::ToolPalette) аналогична панели инструментов, но содержит сетку из элементов, разделенных на группы. Пользователь может скрыть или раскрыть каждую из групп. Как и в панели инструментов, элементы могут использовать только иконки, только текст или иконки с текстом.

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

Группы элементов палитры инструментов (реализованные в рамках класса Gtk::ToolItemGroup) могут добавляться в палитру инструментов с помощью метода Gtk::Container::add() базового класса, например, следующим образом:

Gtk::ToolItemGroup* group_brushes =
  Gtk::manage(new Gtk::ToolItemGroup("Кисти"));
m_ToolPalette.add(*group_brushes);

После этого элементы палитры инструментов (представленные классом Gtk::ToolItem) могут быть добавлены в группу. Например, следующим образом:

Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton(icon, "Большая"));
button->set_tooltip_text("Большая кисть");
group_brushes->insert(*button);

Впоследствии вы сможете установить обработчик для сигнала "clicked" элемента палитры инструментов на основе класса Gtk::ToolItem. Альтернативным решением является активация возможности переноса элемента на другой виджет, выполняемая с использованием метода Gtk::ToolPalette::add_drag_dest() с последующим вызовом метода Gtk::ToolPalette::get_drag_item() в рамках обработчика сигнала "drag_data_received" другого виджета.

Справочная информация для виджета палитры инструментов (ToolPalette)

Справочная информация для группы элементов палитры инструментов (ToolItemGroup)

Справочная информация для элемента палитры инструментов (ToolItem)

13.1. Захват и перемещение элементов палитры инструментов

Для активации возможности перемещения элементов или групп палитры инструментов на определенный целевой виджет следует вызывать метод add_drag_dest(). После этого вы можете использовать метод get_drag_item() для установления того, какой элемент палитры инструментов (представленный экземпляром класса Gtk::ToolItem) или группа палитры инструментов (представленная экземпляром класса Gtk::ToolItemGroup) была перемещена. Вы можете использовать оператор преобразования типа данных dynamic_cast для установления того, является ли объект элементом или группой палитры инструментов. Например, вы можете использовать его в своем обработчике сигнала "drag_data_received" с целью добавления перенесенного элемента палитры инструментов или показа подходящей иконки в процессе перемещения.

Обратитесь к главе "Механизм захвата и перемещения (Drag and Drop)" для получения общих рекомендаций по работе с механизмом захвата и перемещения элементов пользовательских интерфейсов, созданных с помощью gtkmm.

13.2. Пример использования палитры инструментов

В данном примере в окно добавляется виджет палитры инструментов (ToolPalette) и область для рисования (DrawingArea), которые позволяют пользователю захватывать иконки из палитры инструментов и размещать их в области для рисования. Палитра инструментов содержит несколько групп элементов. Раскрывающиеся списки позволяют пользователю изменять стиль и ориентацию палитры инструментов.

Рисунок 13-1: Палитра инструментов (Tool Palette)

Исходный код

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

#ifndef GTKMM_EXAMPLEWINDOW_H
#define GTKMM_EXAMPLEWINDOW_H

#include <gtkmm.h>
#include "canvas.h"

class ExampleWindow : public Gtk::Window
{
public:
  ExampleWindow();
  virtual ~ExampleWindow();

private:

void load_icon_items();
  void load_toggle_items();
  void load_special_items();

//Обработчики сигналов:
  void on_combo_orientation_changed();
  void on_combo_style_changed();

//Столбцы модели представления данных:
  class ModelColumnsOrientation : public Gtk::TreeModel::ColumnRecord
  {
  public:

ModelColumnsOrientation()
    { add(m_col_value); add(m_col_name); }

Gtk::TreeModelColumn<Gtk::Orientation> m_col_value;
    Gtk::TreeModelColumn<Glib::ustring> m_col_name;
  };

ModelColumnsOrientation m_ColumnsOrientation;

//Столбцы модели представления данных:
  class ModelColumnsStyle : public Gtk::TreeModel::ColumnRecord
  {
  public:

ModelColumnsStyle()
    { add(m_col_value); add(m_col_name); }

Gtk::TreeModelColumn<int> m_col_value; //Мы используем целочисленный беззнаковый тип данных для возможности использования значения -1
    Gtk::TreeModelColumn<Glib::ustring> m_col_name;
  };

ModelColumnsStyle m_ColumnsStyle;

//Дочерние виджеты:
  Gtk::Box m_VBox;
  Gtk::Box m_HBox;
  Gtk::ComboBox m_ComboOrientation;
  Glib::RefPtr<Gtk::ListStore> m_refTreeModelOrientation;
  Gtk::ComboBox m_ComboStyle;
  Glib::RefPtr<Gtk::ListStore> m_refTreeModelStyle;
  Gtk::ToolPalette m_ToolPalette;
  Gtk::ScrolledWindow m_ScrolledWindowPalette;
  Gtk::ScrolledWindow m_ScrolledWindowCanvas;
  Canvas m_Canvas;
};

#endif //GTKMM_EXAMPLEWINDOW_H

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

#ifndef GTKMM_EXAMPLE_CANVAS_H
#define GTKMM_EXAMPLE_CANVAS_H

#include <gtkmm.h>

// Этот небольшой класс канвы находится здесь только потому, что
// gtkmm пока еще не имеет класса канвы.
// Реальные приложения, скорее всего, должны использовать класс GooCanvas::Canvas (goocanvasmm) вместо этого класса.
class Canvas : public Gtk::DrawingArea
{
public:
  Canvas();
  virtual ~Canvas();

private:

class CanvasItem
  {
  public:
    CanvasItem(Gtk::Widget* canvas, Gtk::ToolButton* button, double x, double y)
    {
      const Glib::ustring icon_name(button->get_icon_name());

Glib::RefPtr<Gtk::IconTheme> icon_theme = Gtk::IconTheme::get_for_screen(canvas->get_screen());
      int width = 0;
      int height = 0; //игнорируется
      Gtk::IconSize::lookup(Gtk::ICON_SIZE_DIALOG, width, height);
      this->pixbuf = icon_theme->load_icon(icon_name, width, Gtk::ICON_LOOKUP_GENERIC_FALLBACK);
      this->x = x;
      this->y = y;
    }

Glib::RefPtr<Gdk::Pixbuf> pixbuf;
    double x, y;
  };

void item_draw(const CanvasItem *item,
    const Cairo::RefPtr<Cairo::Context>& cr,
    bool preview);

virtual bool on_draw(const Cairo::RefPtr<Cairo::Context>& cr);
  virtual void on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, 
    int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time);
  virtual bool on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
  virtual bool on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, guint time);
  virtual void on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time);

bool m_drag_data_requested_for_drop; //Таким образом, мы будем знать, что делать в рамках обработчика on_drag_data_received().
  CanvasItem* m_drop_item;
  
  typedef std::vector<CanvasItem*> type_vec_items;
  type_vec_items m_canvas_items;
};

#endif //GTKMM_EXAMPLE_CANVAS_H

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

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

Canvas::Canvas()
: m_drag_data_requested_for_drop(false),
  m_drop_item()
{
  set_app_paintable();
}

Canvas::~Canvas()
{
  while(!m_canvas_items.empty())
  {
    type_vec_items::iterator iter = m_canvas_items.begin();
    CanvasItem* item = *iter;
    delete item;
    m_canvas_items.erase(iter);
  }

if(m_drop_item)
    delete m_drop_item;
}

void Canvas::item_draw(const CanvasItem *item,
  const Cairo::RefPtr<Cairo::Context>& cr,
  bool preview)
{
  if(!item || !item->pixbuf)
    return;

const double cx = item->pixbuf->get_width();
  const double cy = item->pixbuf->get_height();

Gdk::Cairo::set_source_pixbuf(cr,
    item->pixbuf,
    item->x - cx * 0.5, item->y - cy * 0.5);

if(preview)
    cr->paint_with_alpha(0.6);
  else
    cr->paint();
}

bool Canvas::on_draw(const Cairo::RefPtr<Cairo::Context>& cr)
{
  cr->set_source_rgb(1.0, 1.0, 1.0);
  const Gtk::Allocation allocation = get_allocation();
  cr->rectangle(0, 0, allocation.get_width(), allocation.get_height());
  cr->fill();

for(type_vec_items::iterator iter = m_canvas_items.begin();
    iter != m_canvas_items.end(); ++iter )
  {
    item_draw(*iter, cr, false);
  }

if(m_drop_item)
    item_draw (m_drop_item, cr, true);

return true;
}

bool Canvas::on_drag_motion(const Glib::RefPtr<Gdk::DragContext>& context,
  int x, int y, guint time)
{
  m_drag_data_requested_for_drop = false; //Это захват, осуществленный вместо перемещения.

if(m_drop_item)
  {
    // Индикатор перемещения уже установлен, поэтому просто обновляем позицию.

m_drop_item->x = x;
    m_drop_item->y = y;

queue_draw();
    context->drag_status(Gdk::ACTION_COPY, time);
  }
  else
  {
    // Запрос данных операции захвата и перемещения для создания индикатора перемещения.
    // Это приведет к вызову обработчика on_drag_data_received().
    const Glib::ustring target = drag_dest_find_target(context);

if (target.empty())
      return false;

drag_get_data(context, target, time);
  }

Gtk::DrawingArea::on_drag_motion(context, x, y, time);
  return true;
}

void Canvas::on_drag_data_received(const Glib::RefPtr<Gdk::DragContext>& context, int x, int y, const Gtk::SelectionData& selection_data, guint info, guint time)
{
  // Поиск кнопки палитры инструментов, с которой началось выполнение операции захвата и перемещения.
  Gtk::Widget* widget = drag_get_source_widget(context);

Gtk::ToolPalette* drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
  while(widget && !drag_palette)
  {
    widget = widget->get_parent();
    drag_palette = dynamic_cast<Gtk::ToolPalette*>(widget);
  }

Gtk::ToolItem* drag_item = 0;
  if(drag_palette)
    drag_item = drag_palette->get_drag_item(selection_data);

// Создание индикатора перемещения после нахождения кнопки палитры инструментов:
  Gtk::ToolButton* button = dynamic_cast<Gtk::ToolButton*>(drag_item);
  if(!button)
    return;

if(m_drop_item)
  {
    delete m_drop_item;
    m_drop_item = 0;
  }

CanvasItem* item = new CanvasItem(this, button, x, y);

if(m_drag_data_requested_for_drop)
  {
    m_canvas_items.push_back(item);

// Отправка сигнала о приеме элемента и последующая перерисовка.
    context->drag_finish(true /* success */, false /* del */, time);
  }
  else
  {
    m_drop_item = item;

// Мы получаем эти данные благодаря запросу в рамках метода drag_motion,
    // а не благодаря запросу в рамках метода drag_drop, поэтому мы просто
    // должны осуществить вызов метода gdk_drag_status () без непосредственной
    // модификации данных.
    context->drag_status(Gdk::ACTION_COPY, time);
  }

queue_draw();

Gtk::DrawingArea::on_drag_data_received(context, x, y, selection_data, info, time);
}

bool Canvas::on_drag_drop(const Glib::RefPtr<Gdk::DragContext>& context, int /* x */, int /* y */, guint time)
{
  // Запрос данных операции захвата и перемещения для создания перемещенного элемента.
  // Это приведет к вызову обработчика on_drag_data_received().
  const Glib::ustring target = drag_dest_find_target(context);

if (target.empty())
    return false;

m_drag_data_requested_for_drop = true;
  drag_get_data(context, target, time);

return true;
}

void Canvas::on_drag_leave(const Glib::RefPtr<Gdk::DragContext>& context, guint time)
{
  //Этот сигнал генерируется для удаления элемента палитры в ходе перемещения либо тогда,
  //когда курсор движется в направлении от виджета, либо при перемещении нами элемента.

if(!m_drop_item)
    return;

delete m_drop_item;
  m_drop_item = 0;

queue_draw();

Gtk::DrawingArea::on_drag_leave(context, time);
}

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

#include "examplewindow.h"

void ExampleWindow::load_icon_items()
{
  Glib::RefPtr<Gtk::IconTheme> icon_theme = Gtk::IconTheme::get_for_screen(get_screen());

typedef std::vector<Glib::ustring> type_stringvec;
  type_stringvec icon_names = icon_theme->list_icons();

// Получение имен для всех контекстов и имен иконок для каждого из контекстов.
  const type_stringvec contexts = icon_theme->list_contexts();

for (type_stringvec::const_iterator iter = contexts.begin(); iter != contexts.end(); ++iter)
  {
    const Glib::ustring context_name = *iter;
    Gtk::ToolItemGroup* group =
      Gtk::manage(new Gtk::ToolItemGroup(context_name));
    m_ToolPalette.add(*group);

// Итеративный обход списка имен иконок с соответствующим заполнением модели представления данных.
    type_stringvec icon_names = icon_theme->list_icons(context_name);
    std::sort(icon_names.begin(), icon_names.end());
    const guint max_icons = 10;
    guint icons_count = 0;
    for (type_stringvec::const_iterator iconiter = icon_names.begin(); iconiter != icon_names.end(); ++iconiter)
    {
      const Glib::ustring id = *iconiter;
      Gtk::ToolButton* button = Gtk::manage(new Gtk::ToolButton());
      button->set_icon_name(id);
      button->set_tooltip_text(id);
      button->set_is_important();
      group->insert(*button);

/* Предотвращает использование неоправданно большого количества иконок: */
      ++icons_count;
      if(icons_count >= max_icons)
        break;
    }
  }
}

void ExampleWindow::load_toggle_items()
{
  Gtk::ToolItemGroup* group = 
    Gtk::manage(new Gtk::ToolItemGroup("Радио-кнопки"));
  m_ToolPalette.add(*group);

Gtk::RadioToolButton::Group radio_group;

for(int i = 1; i <= 10; ++i)
  {
    const Glib::ustring label = Glib::ustring::compose("#%1", i);
    Gtk::RadioToolButton* button = Gtk::manage(new Gtk::RadioToolButton());
    button->set_group(radio_group);
    button->set_label(label);
   
    group->insert(*button);
  }
}

static Gtk::ToolItem* create_entry_item(const Glib::ustring& text)
{
  Gtk::Entry* entry = Gtk::manage(new Gtk::Entry());
  entry->set_text(text);
  entry->set_width_chars(5);

Gtk::ToolItem* item = Gtk::manage(new Gtk::ToolItem());
  item->add(*entry);

return item;
}

void ExampleWindow::load_special_items()
{
  Gtk::ToolItemGroup* group = Gtk::manage(new Gtk::ToolItemGroup());

Gtk::Button *label_button = Gtk::manage(new Gtk::Button("Дополнительные возможности"));
  label_button->show();
  group->set_label_widget(*label_button);
  m_ToolPalette.add(*group);

Gtk::ToolItem* item = create_entry_item ("homogeneous=false");
  group->insert(*item);
  //TODO: Добавить вызов Gtk::Container::set_child_property().
  gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                           "homogeneous", FALSE, NULL);

item = create_entry_item ("homogeneous=FALSE, expand=TRUE");
  group->insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           NULL);

item = create_entry_item ("homogeneous=FALSE, expand=TRUE, fill=FALSE");
  group->insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           "fill", FALSE, NULL);

item = create_entry_item ("homogeneous=FALSE, expand=TRUE, new-row=TRUE");
  group->insert(*item);
  gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (item->gobj()),
                           "homogeneous", FALSE, "expand", TRUE,
                           "new-row", TRUE, NULL);

Gtk::ToolButton *button = Gtk::manage(new Gtk::ToolButton());
  button->set_icon_name("go-up");
  button->set_tooltip_text("Показывать только в вертикальных палитрах");
  group->insert(*button);
  button->set_visible_horizontal(false);

button = Gtk::manage(new Gtk::ToolButton());
  button->set_icon_name("go-next");
  button->set_tooltip_text("Показывать только в горизонтальных палитрах");
  group->insert(*button);
  button->set_visible_vertical(false);

button = Gtk::manage(new Gtk::ToolButton());
  button->set_icon_name("edit-delete");
  button->set_tooltip_text("Вообще не показывать");
  button->set_no_show_all();
  group->insert(*button);
  button->set_visible_vertical(false);

button = Gtk::manage(new Gtk::ToolButton());
  button->set_icon_name("view-fullscreen");
  button->set_tooltip_text("Расширить этот элемент");
  group->insert(*button);
  gtk_container_child_set (GTK_CONTAINER (group->gobj()), GTK_WIDGET (button->gobj()),
                           "homogeneous", FALSE,
                           "expand", TRUE,
                           NULL);

button = Gtk::manage(new Gtk::ToolButton());
  button->set_icon_name("help-browser");
  button->set_tooltip_text("Обычный элемент");
  group->insert(*button);
}

ExampleWindow::ExampleWindow()
: m_VBox(Gtk::ORIENTATION_VERTICAL, 6),
  m_HBox(Gtk::ORIENTATION_HORIZONTAL, 6)
{
  set_title("Пример использования класса Gtk::ToolPalette");
  set_size_request(600, 600);
  set_border_width(6);

add(m_VBox);

//Раскрывающийся список для установки ориентации:
  m_refTreeModelOrientation = Gtk::ListStore::create(m_ColumnsOrientation);
  Gtk::TreeModel::Row row = *(m_refTreeModelOrientation->append());
  row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_HORIZONTAL;
  row[m_ColumnsOrientation.m_col_name] = "Горизонтальная";
  row = *(m_refTreeModelOrientation->append());
  row[m_ColumnsOrientation.m_col_value] = Gtk::ORIENTATION_VERTICAL;
  row[m_ColumnsOrientation.m_col_name] = "Вертикальная";
  m_ComboOrientation.set_model(m_refTreeModelOrientation);
  m_VBox.pack_start(m_ComboOrientation, Gtk::PACK_SHRINK);
  m_ComboOrientation.pack_start(m_ColumnsOrientation.m_col_name);
  m_ComboOrientation.signal_changed().connect(
    sigc::mem_fun(*this, &ExampleWindow::on_combo_orientation_changed) );
  m_ComboOrientation.set_active(row);

//Раскрывающийся список для установки стиля:
  m_refTreeModelStyle = Gtk::ListStore::create(m_ColumnsStyle);
  row = *(m_refTreeModelStyle->append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_TEXT;
  row[m_ColumnsStyle.m_col_name] = "Текст";
  row = *(m_refTreeModelStyle->append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH;
  row[m_ColumnsStyle.m_col_name] = "Иконки и текст";
  row = *(m_refTreeModelStyle->append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_BOTH_HORIZ;
  row[m_ColumnsStyle.m_col_name] = "Иконки и текст с горизонтальным расположением";
  row = *(m_refTreeModelStyle->append());
  row[m_ColumnsStyle.m_col_value] = Gtk::TOOLBAR_ICONS;
  row[m_ColumnsStyle.m_col_name] = "Иконки";
  row = *(m_refTreeModelStyle->append());
  row[m_ColumnsStyle.m_col_value] = -1; // Имеет специальное значение в этом примере.
  row[m_ColumnsStyle.m_col_name] = "Стандартный стиль";
  m_ComboStyle.set_model(m_refTreeModelStyle);
  m_VBox.pack_start(m_ComboStyle, Gtk::PACK_SHRINK);
  m_ComboStyle.pack_start(m_ColumnsStyle.m_col_name);
  m_ComboStyle.signal_changed().connect(
    sigc::mem_fun(*this, &ExampleWindow::on_combo_style_changed) );
  m_ComboStyle.set_active(row);

//Добавление и заполнение палитры инструментов:
  load_icon_items();
  load_toggle_items();
  load_special_items();

m_VBox.pack_start(m_HBox, Gtk::PACK_EXPAND_WIDGET);

m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
  m_ScrolledWindowPalette.set_border_width(6);
  m_ScrolledWindowPalette.add(m_ToolPalette);
  m_HBox.pack_start(m_ScrolledWindowPalette);

on_combo_orientation_changed();

m_ScrolledWindowCanvas.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_ALWAYS);
  m_ScrolledWindowCanvas.set_border_width(6);
  m_ScrolledWindowCanvas.add(m_Canvas);
  m_ScrolledWindowCanvas.set_size_request(200, -1);
  m_HBox.pack_start(m_ScrolledWindowCanvas);

m_ToolPalette.add_drag_dest(m_Canvas,
    Gtk::DEST_DEFAULT_HIGHLIGHT, Gtk::TOOL_PALETTE_DRAG_ITEMS, Gdk::ACTION_COPY);

show_all_children();
}

ExampleWindow::~ExampleWindow()
{
}

void ExampleWindow::on_combo_orientation_changed()
{
  Gtk::TreeModel::iterator iter = m_ComboOrientation.get_active();
  if(!iter)
    return;

Gtk::TreeModel::Row row = *iter;
  const Gtk::Orientation value = row[m_ColumnsOrientation.m_col_value];
 
  m_ToolPalette.set_orientation(value);

if(value == Gtk::ORIENTATION_HORIZONTAL)
    m_ScrolledWindowPalette.set_policy(Gtk::POLICY_AUTOMATIC, Gtk::POLICY_NEVER);
  else
    m_ScrolledWindowPalette.set_policy(Gtk::POLICY_NEVER, Gtk::POLICY_AUTOMATIC);
}

void ExampleWindow::on_combo_style_changed()
{
  Gtk::TreeModel::iterator iter = m_ComboStyle.get_active();
  if(!iter)
    return;

Gtk::TreeModel::Row row = *iter;
  const int value = row[m_ColumnsStyle.m_col_value];
 
  if(value == -1)
    m_ToolPalette.unset_style();
  else
    m_ToolPalette.set_style((Gtk::ToolbarStyle)value);
}

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

Следующий раздел : 14. Объекты установки диапазонов значений (Adjustments).