Idle Functions
| Chapter 24. Timeouts, I/O and Idle Functions |

## Idle Functions

If you want to specify a method that gets called when nothing else is happening, use the following:

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

This causes gtkmm to call the specified method whenever nothing else is happening. You can add a priority (lower numbers are higher priorities). There are two ways to remove the signal handler: calling `disconnect()` on the `sigc::connection` object, or returning `false` in the signal handler, which should be declared as follows:

    bool 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` (For use with gtkmm 3, not gtkmm 2)

    #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();
      void on_button_clicked();

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

    #endif // GTKMM_EXAMPLE_IDLEEXAMPLE_H

File: `main.cc` (For use with gtkmm 3, not gtkmm 2)

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

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

      IdleExample example;
      return app->run(example);
    }

File: `idleexample.cc` (For use with gtkmm 3, not gtkmm 2)

    #include "idleexample.h"

    IdleExample::IdleExample() :
      m_Box(Gtk::ORIENTATION_VERTICAL, 5),
      m_ButtonQuit("_Quit", true)
    {
      set_border_width(5);

      // Put buttons into container

      // Adding a few widgets:
      add(m_Box);
      m_Box.pack_start(*Gtk::make_managed<Gtk::Label>("Formatting Windows drive C:"));
      m_Box.pack_start(*Gtk::make_managed<Gtk::Label>("100 MB"));
      m_Box.pack_start(m_ProgressBar_c);

      m_Box.pack_start(*Gtk::make_managed<Gtk::Label>(""));

      m_Box.pack_start(*Gtk::make_managed<Gtk::Label>("Formatting Windows drive D:"));
      m_Box.pack_start(*Gtk::make_managed<Gtk::Label>("5000 MB"));
      m_Box.pack_start(m_ProgressBar_d);

      auto hbox = Gtk::make_managed<Gtk::Box>(Gtk::ORIENTATION_HORIZONTAL,10);
      m_Box.pack_start(*hbox);
      hbox->pack_start(m_ButtonQuit, Gtk::PACK_EXPAND_PADDING);

      // Connect the signal handlers:
      m_ButtonQuit.signal_clicked().connect( sigc::mem_fun(*this,
                  &IdleExample::on_button_clicked) );

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

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

      show_all_children();
    }

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

    // 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
    }

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.

Monitoring I/O |  | Chapter 25. Memory management