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

## Monitoring I/O

TODO: This is now in Glib, not Gdk. A nifty feature of GDK (one of the libraries underlying gtkmm) is the ability to have it check for data on a file descriptor for you. This is especially useful for networking applications. The following method is used to do this:

    sigc::connection Glib::Main::SignalInput::connect(const SlotType& sd, int source,
                                        Glib::InputCondition condition);

The first argument is a slot (SlotType is a typedef to a sigc::slot<>) you wish to have called when then the specified event (see argument 3) occurs on the file descriptor you specify using argument two. Argument three may be one or more (using `|`) of:

- GDK_INPUT_READ - Call your method when there is data ready for reading on your file descriptor.

- GDK_INPUT_WRITE - Call your method when the file descriptor is ready for writing.

- GDK_INPUT_EXCEPTION - Call your method when an exception happened on the file descriptor.

The return value is a sigc::connection that may be used to stop monitoring this file descriptor using its `disconnect` method. The `sd` signal handler should be declared as follows:

    void input_callback(int source, GdkInputCondition condition);

where `source` and `condition` are as specified above. As usual the slot is created with `sigc::mem_fun()` (for a member method of an object.), or `sigc::ptr_fun` (for a function).

A little (and somewhat dirty) example follows. To use the example just execute it from a terminal; it doesn't create a window. It will create a pipe named `testpipe` in the current directory. Then start another shell and execute `cat >testpipe`. The example will print each line you enter until you type `quit`.

Source Code

File: main.cc

    #include <gtkmm/main.h>
    #include <fcntl.h>
    #include <unistd.h>
    #include <sys/types.h>
    #include <sys/stat.h>
    #include <iostream>

    int read_fd;

    /*
      send to the fifo with:
      echo "Hello" > testfifo

      quit the program with:
      echo "Q" > testfifo
    */

    // this will be our signal handler for read operations
    // it will print out the message sent to the fifo
    // and quit the program if the message was, or began
    // with, '*'
    bool MyCallback(Glib::IOCondition io_condition)
    {
      if ((io_condition & Glib::IO_IN) == 0) {
        std::cerr << "Invalid fifo response" << std::endl;
      }
      else {
        char buffer[PIPE_BUF];
        int result;
        while ((result = read(read_fd, buffer, PIPE_BUF)) > 0) {
          if (*buffer == 'Q') Gtk::Main::quit();
          else write(0, buffer, result);
        }
      }
      return true;
    }

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

      if (access("testfifo", F_OK) == -1) {
        // fifo doesn't exit - create it
        if (mkfifo("testfifo", 0666) != 0) {
          std::cerr << "error creating fifo" << std::endl;
          return -1;
        }
      }

      read_fd = open("testfifo", O_RDONLY | O_NONBLOCK);
      if (read_fd == -1)
      {
        std::cerr << "error opening fifo" << std::endl;
        return -1;
      }

      // connect the signal handler
      Glib::signal_io().connect(sigc::ptr_fun(MyCallback), read_fd, Glib::IO_IN);

      // and last but not least - run the application main loop
      app.run();

      // now remove the temporary fifo
      if(unlink("testfifo"))
        std::cerr << "error removing fifo" << std::endl;

      return 0;
    }

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