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

Библиотека сайта 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 г.
Перевод: А.Панин
Дата перевода: 28 марта 2014 г.

24. Функции с временем ожидания, мониторинг операций ввода/вывода и функции для периодов бездействия

24.1. Функции с временем ожидания

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

sigc::connection Glib::SignalTimeout::connect(const sigc::slot<bool>& slot, unsigned int interval, int priority = Glib::PRIORITY_DEFAULT);

Первым аргументом является слот, который должен использоваться для вызова метода в момент истечения времени ожидания. Вторым аргументом является число миллисекунд между вызовами этого метода. В результате вызова метода вы получите объект идентификации соединения sigc::connection, который может быть использован для деактивации соединения с вызываемым методом с помощью метода disconnect().

my_connection.disconnect();

Другим способом уничтожения соединения с вызываемым методом является использование вашего обработчика сигналов. Это должен быть обработчик типа sigc::slot<bool>. Как вы видите в объявлении метода, ваш обработчик сигналов должен возвращать логическое значение. Объявление вызываемого метода должно выглядеть аналогичным образом:

bool MyCallback() { std::cout << "Hello World!\n" << std::endl; return true; }

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

Ниже приведен пример использования описанной техники.

Исходный код

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

#ifndef GTKMM_EXAMPLE_TIMEREXAMPLE_H
#define GTKMM_EXAMPLE_TIMEREXAMPLE_H

#include <gtkmm.h>
#include <iostream>
#include <map>

class TimerExample : public Gtk::Window
{
public:
  TimerExample();

protected:
  // Обработчики сигналов
  void on_button_add_timer();
  void on_button_delete_timer();
  void on_button_quit();

// Это функция обратного вызова, которая будет вызвана по истечении времени ожидания
  bool on_timeout(int timer_number);

// Данные класса:

Gtk::Box m_Box;
  Gtk::Button m_ButtonAddTimer, m_ButtonDeleteTimer, m_ButtonQuit;

// Отслеживание добавленных таймеров:
  int m_timer_number;

// Эти две константы инициализируются в ходе инициализвции данных класса в рамках конструктора:
  const int count_value;
  const int timeout_value;

// Контейнер map из стандартной библиотеки шаблонов для хранения объектов идентификации наших соединений с вызываемыми методами
  std::map<int, sigc::connection> m_timers;

// Контейнер map из стандартной библиотеки шаблонов для хранения наших значений таймеров.
  // Каждый таймер отсчитывает значения от COUNT_VALUE до 0 и удаляется при равенстве значения 0
  std::map<int, int> m_counters;
};

#endif // GTKMM_EXAMPLE_TIMEREXAMPLE_H

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

#include "timerexample.h"

TimerExample::TimerExample() :
  m_Box(Gtk::ORIENTATION_HORIZONTAL, 10),
  m_ButtonAddTimer("_Добавить", true),
  m_ButtonDeleteTimer("_Удалить", true),
  m_ButtonQuit("_Выход", true),
  m_timer_number(0), // нумерация таймеров начинается с 0
  count_value(5), // каждый таймер уменьшает значение 5 раз перед отсоединением от функции обратного вызова
  timeout_value(1500) // 1500 мс = 1.5 секунды
{
  set_border_width(10);

add(m_Box);
  m_Box.pack_start(m_ButtonAddTimer);
  m_Box.pack_start(m_ButtonDeleteTimer);
  m_Box.pack_start(m_ButtonQuit);

// Установка обработчиков сигналов нажатия для трех кнопок:
  m_ButtonQuit.signal_clicked().connect(sigc::mem_fun(*this,
              &TimerExample::on_button_quit));
  m_ButtonAddTimer.signal_clicked().connect(sigc::mem_fun(*this,
              &TimerExample::on_button_add_timer));
  m_ButtonDeleteTimer.signal_clicked().connect(sigc::mem_fun(*this,
              &TimerExample::on_button_delete_timer));

show_all_children();
}

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

void TimerExample::on_button_add_timer()
{
  // Создание нового объекта сокращает объем кода и демонстрирует нам принцип
  // работы слотов. Мы не передаем ни одного параметра и устанавливаем логическое 
  // значение в качестве результата работы функции с помощью вызова sigc::bind.
  sigc::slot<bool> my_slot = sigc::bind(sigc::mem_fun(*this,
              &TimerExample::on_timeout), m_timer_number);

// А здесь мы соединяем данный слот с сигналом Glib::signal_timeout()
  sigc::connection conn = Glib::signal_timeout().connect(my_slot,
          timeout_value);

// Сохранение данных соединения с вызываемым методом:
  m_timers[m_timer_number] = conn;

// Инициализация значения таймера:
  m_counters[m_timer_number] = count_value + 1;

// Вывод информации в консоль для пользователя:
  std::cout << "добавлена функция с временем ожидания " << m_timer_number++ << std::endl;
}

void TimerExample::on_button_delete_timer()
{
  // существуют ли таймеры?
  if(m_timers.empty())
  {
    // таймеров не осталось
    std::cout << "Простите, но таймеров больше не осталось." << std::endl;
  }
  else
  {
    // получение идентификатора первого таймера
    int timer_number = m_timers.begin()->first;

// Вывод информации для пользователя:
    std::cout << "отсоединение таймера в ручном режиме " << timer_number
        << std::endl;

// Удаление значения таймера из набора значений
    m_counters.erase(timer_number);

// Отсоединение обработчика сигналов:
    m_timers[timer_number].disconnect();

// Разрыв соединения с вызываемым методом:
    m_timers.erase(timer_number);
  }
}

bool TimerExample::on_timeout(int timer_number)
{
  // Вывод номера таймера:
  std::cout << "Таймер " << timer_number;

// уменьшение и проверка значения таймера
  if (--m_counters[timer_number] == 0)
  {
    std::cout << " был отсоединен" <<  std::endl;

// удаление значения таймера из контейнера map стандартной библиотеки шаблонов
    m_counters.erase(timer_number);

// удаление объекта идентификации соединения таймера с вызываемым методом из контейнера map стандартной библиотеки шаблонов
    m_timers.erase(timer_number);

// Учтите, что нам не нужно явно вызывать метод disconnect() с использованием объекта идентификации
    // соединения для разрыва соединения с вызываемым методом, так как объект Gtk::Main делает это после того, как мы возвращаем значение false.
    return false;
  }

// Вывод значения таймера
  std::cout << " - " << m_counters[timer_number] << "/"
      << count_value << std::endl;

// Продолжаем работу (пока не отсоединяем вызываемый метод):
  return true;
}

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

24.2. Мониторинг операций ввода/вывода

Полезной функцией Glib (одной из библиотек, лежащих в основе gtkmm) является возможность проверки наличия данных при работе с файловым дескриптором. Это особенно полезно при создании сетевых приложений. Для использования этой функции может быть задействован следующий метод:

sigc::connection Glib::SignalInput::connect(const sigc::slot<bool,Glib::IOCondition>& slot,
                                    int fd, Glib::IOCondition condition,
                                    int priority = Glib::PRIORITY_DEFAULT);

Первый аргумент является слотом, который должен быть вызван в момент, когда установленное (с помощью аргумента 3) событие происходит с файловым дескриптором, заданным вами с помощью второго аргумента. Для третьего аргумента может использоваться один или несколько из приведенных ниже флагов (объединение флагов происходит с помощью оператора |):

Glib::IO_IN - Ваш метод будет вызван тогда, когда данные будут доступны для чтения из вашего файлового дескриптора.
Glib::IO_OUT - Ваш метод будет вызван тогда, когда файловый дескриптор будет готов для записи.
Glib::IO_PRI - Ваш метод будет вызван тогда, когда для чтения из файлового дескриптора будут доступны важные данные.
Glib::IO_ERR - Ваш метод будет вызван тогда, когда при работе с файловым дескриптором произойдет ошибка.
Glib::IO_HUP - Ваш метод будет вызван тогда, когда произойдет разрыв соединения (соединение, обычно создаваемое с использованием каналов или сокетов, будет нарушено).

Возвращаемое значение является объектом идентификации соединения типа sigc::connection, который может использоваться для прекращения мониторинга данного файлового дескриптора путем вызова метода disconnect(). Обработчик сигналов для используемого слота должен быть объявлен следующим образом:

bool input_callback(Glib::IOCondition condition);

причем для аргумента condition используются описанные выше флаги. Как обычно, слот создается с помощью вызова sigc::mem_fun() (для метода класса) или вызова sigc::ptr_fun() (для функции).

Ниже приведен небольшой пример. Для использования этого примера просто запустите скомпилированное приложение из терминала; оно не создает окон. Данное приложение создаст именованный канал с именем testfifo в текущей директории. После запуска откройте еще один терминал и выполните команду "Hello" > testinfo. Приложение будет выводить каждую переданную вами строку до того момента, пока вы не выполните команду echo "Q" > testfifo.

Исходный код

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

#include <build/config.h>
#include <gtkmm/application.h>
#include <glibmm/main.h>
#include <glibmm/iochannel.h>
#include <fcntl.h>
#include <iostream>

#include <unistd.h> //Компилятор SUN Forte размещает макрос F_OK в данном заголовочном файле.

//Компилятор SUN Forte требует подключения этих заголовочных файлов для использования функции mkfifo:
#include <sys/types.h>
#include <sys/stat.h>

Glib::RefPtr<Gtk::Application> app;

int read_fd;
Glib::RefPtr<Glib::IOChannel> iochannel;

/*
  данные помещаются в именованный канал с помощью команды:
  echo "Hello" > testfifo

выполнение программы завершается с помощью команды:
  echo "Q" > testfifo
*/

// эта функция будет нашим обработчиком сигналов, связанных с чтением данных
// она будет печатать сообщение, переданное в именованный канал
// и завершать работу программы в том случае, если было передано сообщение 'Q'.
bool MyCallback(Glib::IOCondition io_condition)
{

if ((io_condition & Glib::IO_IN) == 0) {
    std::cerr << "Некорректный ответ от именованного канала" << std::endl;
  }
  else {
   Glib::ustring buf;

iochannel->read_line(buf);
   std::cout << buf;
   if (buf == "Q\n")
     app->quit();

}
  return true;
}

int main(int argc, char *argv[])
{
  app = Gtk::Application::create(argc, argv, "org.gtkmm.example");

if (access("testfifo", F_OK) == -1) {
    // именованного канала не существует - создаем его
    #ifdef HAVE_MKFIFO
    if (mkfifo("testfifo", 0666) != 0) {
      std::cerr << "ошибка при создании именованного канала" << std::endl;
      return -1;
    }
    #else
      std::cerr << "ошибка при создании именованного канала: Данная платформа не поддерживает функцию mkfifo()"
          << std::endl;
    #endif //HAVE_MKFIFO
  }

read_fd = open("testfifo", O_RDONLY);
  if (read_fd == -1)
  {
    std::cerr << "ошибка при открытии именованного канала" << std::endl;
    return -1;
  }

// установка обработчика сигналов
  Glib::signal_io().connect(sigc::ptr_fun(MyCallback), read_fd, Glib::IO_IN);

// Создание объекта канала ввода/вывода на основе файлового дескриптора
  iochannel = Glib::IOChannel::create_from_fd(read_fd);

// и последняя, но важная операция - запуск основного цикла обработки событий приложения
  app->run();

// а теперь удаление временного файла именованного канала
  if(unlink("testfifo"))
    std::cerr << "ошибка при удалении файла именованного канала" << std::endl;

return 0;
}

24.3. Функции для периодов бездействия

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

sigc::connection  Glib::SignalIdle::connect(const sigc::slot<bool>& slot, int priority = Glib::PRIORITY_DEFAULT_IDLE);

Он принуждает gtkmm к вызову заданного метода в моменты, когда ничего другого не происходит. При этом вы можете задать приоритет операции (меньшие значения соответствуют более высоким приоритетам). Существует два способа удаления обработчика сигналов: вызов метода disconnect() объекта идентификации соединения типа sigc::connection или возврат логического значения false из обработчика сигналов, который должен быть объявлен следующим образом:

bool idleFunc();

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

Исходный код

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

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

#include "idleexample.h"

IdleExample::IdleExample() :
  m_Box(Gtk::ORIENTATION_VERTICAL, 5),
  m_ButtonQuit("_Выход", true)
{
  set_border_width(5);

// Размещение кнопок в контейнере

// Добавление нескольких виджетов:
  add(m_Box);
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("Форматирование диска C: ОС Windows")));
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("100 МБ")) );
  m_Box.pack_start(m_ProgressBar_c);

m_Box.pack_start( *Gtk::manage(new Gtk::Label("")) );

m_Box.pack_start( *Gtk::manage(new Gtk::Label("Форматирование диска D: ОС Windows")));
  m_Box.pack_start( *Gtk::manage(new Gtk::Label("5000 МБ")) );
  m_Box.pack_start(m_ProgressBar_d);

Gtk::Box* hbox = Gtk::manage( new Gtk::Box(Gtk::ORIENTATION_HORIZONTAL,10));
  m_Box.pack_start(*hbox);
  hbox->pack_start(m_ButtonQuit, Gtk::PACK_EXPAND_PADDING);

// Установка обработчиков сигналов:
  m_ButtonQuit.signal_clicked().connect( sigc::mem_fun(*this,
              &IdleExample::on_button_clicked) );

// форматирование диска c в рамках обработчика сигналов с временем ожидания - вызов каждые 50мс
  Glib::signal_timeout().connect( sigc::mem_fun(*this, &IdleExample::on_timer),
          50 );

// форматирование диска d в рамках обработчика сигналов для периодов бездействия - вызов так часто, как это возможно
  Glib::signal_idle().connect( sigc::mem_fun(*this, &IdleExample::on_idle) );

show_all_children();
}

void IdleExample::on_button_clicked()
{
  hide();
}

// эта функция обратного вызова с временем ожидания вызывается один раз в 50 мс (что 
// установлено в коде создания соединения выше).  Используйте таймауты в тех случаях,  
// когда время выполнения задачи не критично. (например, для периодического обновления значения какого-либо параметра).
bool IdleExample::on_timer()
{
  double value = m_ProgressBar_c.get_fraction();

// Увеличение значения индикатора степени выполнения задачи на 1/500 каждый раз:
  m_ProgressBar_c.set_fraction(value + 0.002);
 
  return value < 0.99;  // возвращение значения false при заполнении индикатора
}

// Эта функция обратного вызова для периодов бездействия вызывается так часто, как это 
// возможно, следовательно, она идеальна для выполнения сложных вычислительных задач.
bool IdleExample::on_idle()
{
  double value = m_ProgressBar_d.get_fraction();

// Увеличение значения индикатора степени выполнения задачи на 1/500 каждый раз:
  m_ProgressBar_d.set_fraction(value + 0.0002);

return value < 0.99;  // возвращение значения false при заполнении индикатора
}

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

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

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

Следующий раздел : Управление памятью.