10 - Advanced FLTK

This chapter explains advanced programming and design topics that will help you to get the most out of FLTK.

Multithreading

FLTK supports multithreaded application using a locking mechanism based on "pthreads". We do not provide a threading interface as part of the library. However a simple example how threads can be implemented for all supported platforms can be found in test/threads.h and test/threads.cxx.

To use the locking mechanism, FLTK must be compiled with --enable-threads set during the configure process. IDE-based versions of FLTK are automatically compiled with locking enabled if possible.

In main(), call Fl::lock() before Fl::run() to start the runtime multithreading support for your program. All callbacks and derived functions like handle() and draw() will now be properly locked. 

  main() {
    Fl::lock();
    /* run thread */
    while(Fl::wait() > 0) {
      if(Fl::thread_message()) {
        /* process your data */
      }
    }
  }

You can now start as many threads as you like. From within a thread (other than the main thread) FLTK calls must be wrapped in the following code: 

  Fl::lock();      // avoid conflicting calls
  ...              // your code here
  Fl::unlock();    // allow other threads to access FLTK again
  Fl::awake(msg);  // tells FLTK that another thread has made changes

FLTK supports multiple platforms, some of them which do not allow any other but the main thread to handle system events and open or close windows. The safe thing to do is to adhere to the following rules for threads on all operating systems:

See also: void awake(void *message), void lock(), void unlock(), void set_awake_cb(void (*cb)(void *), void *thread_message().