gr_glut.h

Go to the documentation of this file.

/* $Id: gr_glut.h 18327 2014-12-02 04:27:31Z ksimek $ */
/* =========================================================================== *
   |
   |  Copyright (c) 1994-2010 by Kobus Barnard (author)
   |
   |  Personal and educational use of this code is granted, provided that this
   |  header is kept intact, and that the authorship is not misrepresented, that
   |  its use is acknowledged in publications, and relevant papers are cited.
   |
   |  For other use contact the author (kobus AT cs DOT arizona DOT edu).
   |
   |  Please note that the code in this file has not necessarily been adequately
   |  tested. Naturally, there is no guarantee of performance, support, or fitness
   |  for any particular task. Nonetheless, I am interested in hearing about
   |  problems that you encounter.
   |
   |  Author:  Kyle Simek
 * =========================================================================== */

#ifndef KJB_GR_CPP_GLUT_H
#define KJB_GR_CPP_GLUT_H

#ifdef KJB_HAVE_GLUT

#include <l_cpp/l_exception.h>
#include <string>
#include <vector>

#ifdef KJB_HAVE_BST_THREAD
#include <boost/thread.hpp>
#endif


namespace boost {

template <class R>
class function0;

template <class R, class T1, class T2>
class function2;

template <class R, class T1, class T2, class T3>
class function3;

template <class R, class T1, class T2, class T3, class T4>
class function4;

//class mutex;
} // namespace boost
namespace kjb
{
namespace opengl
{

class Glut
{
// TODO: 
// menu handling
// idle callback
    public:
    static unsigned int get_display_mode()
    {
        return display_mode_;
    }
    static void set_display_mode(unsigned int display_mode);

    static void set_init_window_size(int w, int h);

    static void set_init_window_position(int x, int y);

    static void init();

    static void init(int argc, char** argv);

    static bool is_initialized();

    static bool is_running();

    static void push_current_window();

    static void pop_current_window();


    static void set_idle_callback(boost::function0<void> cb);

    static void add_timer_callback(size_t msec, boost::function0<void> cb);

    static void clear_idle_callback();

    static void enable_multithreading();

    static boost::thread::id thread_id();

    static void post_redisplay_t(int wnd_handle);


    static void push_task_t(boost::function0<void> task);


#ifdef KJB_HAVE_BST_THREAD

    static boost::mutex* mutex;
#endif

    static void task_pump_t();

    static void task_pump();


    static void disable_warnings();

    static bool warnings_enabled();

    static void test_initialized(const std::string& obj_name);

private:
    static void idle();

    static void timer(int i);

    static void idle_t();
private:

    static unsigned int display_mode_;
    static bool initialized_;
    static bool warnings_;

    static int init_h_;
    static int init_w_;
    static int init_x_;
    static int init_y_;

    static boost::function0<void>* idle_callback_;
    static std::vector<boost::function0<void> > timer_callbacks_;
    static std::vector<size_t> timer_gaps_;

    static bool multithreading_enabled_;
    static std::vector<bool> redisplay_flags_;
    static std::vector<int> redisplay_wnds_;

    static std::vector<boost::function0<void> > tasks_;



    static int cur_wnd_stack_;

#ifdef KJB_HAVE_BST_THREAD
    static boost::thread::id* thread_id_;
#endif

};


class Glut_window
{
// TODO: 
// menu handling
// timers?
// stacking
// set_active
// visibility callback
// entry_callback
public:
    Glut_window( const std::string& title);

    Glut_window(
            int width,
            int height,
            const std::string& title = DEFAULT_WINDOW_TITLE
            );

    Glut_window(
            int width,
            int height,
            int pos_x,
            int pos_y,
            const std::string& title
            );

    ~Glut_window();

    void set_size(int width, int height);

    int get_width() const;

    int get_height() const;

    void set_position(int x, int y);

    int get_handle() const;

    void set_current() const;

    void redisplay() const;

    /*
     * A thread-safe version of redisplay().
     *
     * This makes no direct calls to glut or opengl, but enqueues
     * a redisplay event with the Glut class, which is processed
     * at the next idle event.
     *
     */
    void redisplay_t() const;

    bool is_thread_safe() const;



    // ////////////////////
    //  CALLBACK SETTERS //
    // ////////////////////
    void set_display_callback(boost::function0<void> cb);

    const boost::function0<void>& get_display_callback() const;

    static void set_idle_callback(boost::function0<void> cb);
    void set_reshape_callback(boost::function2<void, int, int> cb);
    void set_keyboard_callback(boost::function3<void, unsigned char, int, int> cb);
    void set_mouse_callback(boost::function4<void, int, int, int, int> cb);
    void set_motion_callback(boost::function2<void, int, int> cb);
    void set_passive_motion_callback(boost::function2<void, int, int> cb);
    void set_special_callback(boost::function3<void, int, int, int> cb);

    

    // /////////////////////
    //  CALLBACK CLEARERS //
    // /////////////////////

    /* Stop handling display events.
     *
     * @note this actually sets a no-op function to handle display
     * events, as setting no display callback will cause glut to
     * crash in most implementations.
     * @warning Not thread safe
     */
    void clear_display_callback() ;

    static void clear_idle_callback();

    void clear_reshape_callback();

    void clear_keyboard_callback();

    void clear_mouse_callback();

    void clear_motion_callback();

    void clear_passive_motion_callback();

    void clear_special_callback();

    void clear_callbacks();

    void init();

private:
    // prevent copying
    Glut_window(const Glut_window&){}
    Glut_window& operator=(const Glut_window&) { return *this; }


    // /////////////
    //  CALLBACKs //
    // //////////////////////////////////////////////////////////////
    //  These are intentionally not virtual, to encourage users to 
    //  pass their callback functions into this object using the 
    //  set_<callback>() methods, and to discourage
    //  subclassing Glut_window, which should be unnecessary.
    //
    //  If the no-subclassing rule is too much trouble, we can add virtual
    //  to these later.
    //
    //  Also, these are not callable directly, because only glut should
    //  be calling these, by way of the glut_window_<callback>_callback()
    //  global functions, which are friends.  
    //
    //  You can change these to be public if needed, but think twice 
    //  before changing them and ask if you really need to call these 
    //  directly, or if you should redesign your code to keep event 
    //  handlers separate from functions that do work.
    // //////////////////////////////////////////////////////////////

    void display_callback()  const;

    void reshape_callback(int w, int h);

    void keyboard_callback(unsigned char k, int x, int y)  const;

    void mouse_callback(int button, int state, int x, int y)  const;

    void motion_callback(int x, int y)  const;

    void passive_motion_callback(int x, int y)  const;

    void special_callback(int k, int x, int y)  const;

    // ////////////////////////////////
    //  CALLBACK FRIEND DECLARATIONS //
    // ////////////////////////////////
    friend void glut_window_display_callback();
    friend void glut_window_reshape_callback(int, int);
    friend void glut_window_keyboard_callback(unsigned char, int, int);
    friend void glut_window_mouse_callback(int, int, int, int);
    friend void glut_window_motion_callback(int, int);
    friend void glut_window_passive_motion_callback(int, int);
    friend void glut_window_special_callback(int, int, int);

private:
    std::string title_;
    mutable int width_;
    mutable int height_;
    int x_;
    int y_;
    int handle_;


    boost::function0<void>* display_callback_;
    boost::function2<void, int, int>* reshape_callback_;
    boost::function3<void, unsigned char, int, int>* keyboard_callback_;
    boost::function4<void, int, int, int, int>* mouse_callback_;
    boost::function2<void, int, int>* motion_callback_;
    boost::function2<void, int, int>* passive_motion_callback_;
    boost::function3<void, int, int, int>* special_callback_;

    static const char* DEFAULT_WINDOW_TITLE;
};


} // opengl
} // kjb
#endif /* KJB_HAVE_GLUT */

#endif