Idle Functions
Prev | Chapter 17. Timeouts, I/O and Idle Functions | Next

## Idle Functions

What if you have a method you want called when nothing else is happening? Hook it up using the following:

    Connection Gtk::Main::idle.connect(Slot0<int> idlefunc, int priority);

This causes gtkmm to call the specified method whenever nothing else is happening. You can add a priority (lower numbers are higher priorities). If you don't supply a priority value, then Gtk::PRIORITY_DEFAULT will be used. There are two ways to remove the signal handler: calling `disconnect` on the Connection object, or returning `false` (or 0) in the signal handler, which should be declared as follows:

    int idleFunc();

Since this is very similar to the methods above this explanation should be sufficient to understand what's going on. However, here's a little example:

Source Code

File: idleexample.h

    #ifndef GTKMM_EXAMPLE_IDLEEXAMPLE_H
    #define GTKMM_EXAMPLE_IDLEEXAMPLE_H

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

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

    protected:
      // Signal Handlers:
      bool on_timer();
      bool on_idle();

      // Member data:
      Gtk::VBox m_Box;
      Gtk::Button m_ButtonQuit;
      Gtk::ProgressBar m_ProgressBar_c;
      Gtk::ProgressBar m_ProgressBar_d;
    };

    #endif // GTKMM_EXAMPLE_IDLEEXAMPLE_H

File: idleexample.cc

    #include "idleexample.h"

    IdleExample::IdleExample() :
      m_Box(false, 5),
      m_ButtonQuit(Gtk::Stock::QUIT)
    {
      set_border_width(5);

      // Put buttons into container

      // Adding a few widgets:
      add(m_Box);
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("Formatting Windows drive C:")) );
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("100 MB")) );
      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("Formatting Windows drive D:")) );
      m_Box.pack_start( *Gtk::manage(new Gtk::Label("5000 MB")) );
      m_Box.pack_start(m_ProgressBar_d);

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

      // Connect the signal handlers:
      m_ButtonQuit.signal_pressed().connect( SigC::slot(*this, &Gtk::Widget::hide) );

      // formatting drive c in timeout signal handler - called once every 50ms
      Glib::signal_timeout().connect( SigC::slot(*this, &IdleExample::on_timer), 50 );

      // formatting drive d in idle signal handler - called as quickly as possible
      Glib::signal_idle().connect( SigC::slot(*this, &IdleExample::on_idle) );

      show_all_children();
    }

    // this timer callback function is executed once every 50ms (set in connection above).
    // Use timeouts when speed is not critical. (ie periodically updating something).
    bool IdleExample::on_timer()
    {
      double value = m_ProgressBar_c.get_fraction();

      // Update progressbar 1/500th each time:
      m_ProgressBar_c.set_fraction(value + 0.002);

      return value < 0.99;  // return false when done
    }

    // This idle callback function is executed as often as possible, hence it is ideal for
    // processing intensive tasks.
    bool IdleExample::on_idle()
    {
      double value = m_ProgressBar_d.get_fraction();

      // Update progressbar 1/5000th each time:
      m_ProgressBar_d.set_fraction(value + 0.0002);

      return value < 0.99;  // return false when done
    }

File: main.cc

    #include "idleexample.h"
    #include <gtkmm/main.h>

    int main (int argc, char *argv[])
    {
      Gtk::Main app(argc, argv);

      IdleExample example;
      Gtk::Main::run(example);

      return 0;
    }

This example points out the difference of idle and timeout methods a little. If you need methods that are called periodically, and speed is not very important, then you want timeout methods. If you want methods that are called as often as possible (like calculating a fractal in background), then use idle methods.

Try executing the example and increasing the system load. The upper progress bar will increase steadily; the lower one will slow down.

Prev | Up | Next
Monitoring I/O | Home | Chapter 18. Memory management