sgl.h

#ifndef SGL_H_
#define SGL_H_

#ifdef _MSC_VER
    #pragma warning(disable:4251)
    #pragma warning(disable:4224)
#endif

#include <iostream>
#include <vector>
//#include <list>
#include <string>
#include <ctime>
#include <fstream>
#include <functional>


namespace sgl {

struct Point {
    double x;

    double y;

    Point(double x, double y): x(x), y(y) {}

    Point(): x(0.0), y(0.0) {}
};

class Color {
public:
    double red;
    double green;
    double blue;

    Color(double r, double g, double b): 
               red(r < 0.0 ? 0.0 : (r > 1.0) ? 1.0 : r), 
               green(g < 0.0 ? 0.0 : (g > 1.0) ? 1.0 : g), 
               blue(b < 0.0 ? 0.0 : (b > 1.0) ? 1.0 : b) {};
};

//  These are duplicates of the GLUT constants.  This hack allows
//  clients to use the SGL library without exposing GLUT directly.
//  If the GLUT constants values are changed (unlikely), these
//  values would need to be changed to match.
//  The implementation code could have wrapped the GLUT constants, 
//  but then each client access of a SGL constant would require a 
//  conversion to the corresponding GLUT equivalent.  This hack 
//  avoids that processing overhead.

/*  Add MouseEvent and KeyEvent classes?  */

enum class MouseButton { 
    Left = 0, 
    Right = 2, 
    Unknown = -1 
};

enum SpecialKey { 
    F1_KEY = 10001, 
    F2_KEY, 
    F3_KEY, 
    F4_KEY, 
    F5_KEY, 
    F6_KEY, 
    F7_KEY, 
    F8_KEY, 
    F9_KEY, 
    F10_KEY, 
    F11_KEY, 
    F12_KEY,
    LEFT_KEY = 10100, 
    UP_KEY, 
    RIGHT_KEY, 
    DOWN_KEY, 
    PAGE_UP_KEY, 
    PAGE_DOWN_KEY, 
    HOME_KEY, 
    END_KEY, 
    INSERT_KEY 
};

enum class CursorShape { 
    Right_arrow = 0,
    Left_arrow,
    /* Symbolic cursor shapes. */
    Info,
    Destroy,
    Help,
    Cycle,
    Spray,
    Wait,
    Text,
    Crosshair,
    /* Directional cursors. */
    Up_down,
    Left_right,
    /* Sizing cursors. */
    Top_side,
    Bottom_side,
    Left_side,
    Right_side,
    Top_left_corner,
    Top_right_corner,
    Bottom_right_corner,
    Bottom_left_corner,
    /* Inherit from parent window. */
    Inherit = 100,
    /* Blank cursor. */
    None,
    /* Fullscreen crosshair (if available). */
    Full_crosshair
};

enum class KeyModifier { 
    NO_KEY = 0, 
    SHIFT_KEY = 1, 
    CTRL_KEY = 2, 
    ALT_KEY = 4 
};

class Window;        //  Forward reference
class ObjectWindow;  //  Forward reference


class GraphicalObject {
private:
    static unsigned id_source;

protected:
    ObjectWindow *window;

    double x_hit_offset;
    
    double y_hit_offset;

    double left;
    
    double bottom;

    double width;
    
    double height;

    CursorShape cursor;

     bool mouse_over;


public:
    const unsigned id;

    GraphicalObject(double left, double bottom, double width, 
                    double height);

    GraphicalObject(const GraphicalObject& other);

    GraphicalObject& operator=(const GraphicalObject& other);

    virtual ~GraphicalObject();

    virtual double get_left() const;

    virtual double get_bottom() const;

    virtual double get_width() const;

    virtual double get_height() const;

    virtual void set(double x, double y, double width, double height);


    virtual void paint() const = 0;


    virtual void move_to(double left, double bottom);

    virtual void mouse_pressed(double x, double y, MouseButton button);

    virtual void mouse_released(double x, double y, MouseButton button);

    virtual void mouse_moved(double x, double y);

    virtual void mouse_dragged(double x, double y);

    virtual void key_pressed(int k, double x, double y);



    virtual bool hit(double x, double y);

    virtual Window *set_window(ObjectWindow *win);

    virtual Window *get_window() const;

    virtual void set_mouse_over(bool flag);

    virtual CursorShape set_cursor(CursorShape cursor);

    virtual CursorShape get_cursor();
};



extern const Color BLACK, RED, GREEN, BLUE, YELLOW, MAGENTA, CYAN, WHITE,
                   DARK_RED, DARK_GREEN, DARK_BLUE, LIGHT_RED, LIGHT_GREEN,
                   LIGHT_BLUE, GRAY, LIGHT_GRAY, DARK_GRAY;

class Window {
protected:
    //  Extents of window in viewport coordinates
    double min_x;

    double max_x;

    double min_y;

    double max_y;

    CursorShape normal_cursor;

    KeyModifier key_mods;

    void initialize(const std::string& title, int left, int top, int width, int height, 
                    double min_x, double max_x, double min_y, double max_y);

public:


    Window(const std::string& title, int left, int top, int width, int height, 
           double min_x, double max_x, double min_y, double max_y);

    Window(const std::string&  title, int width, int height);


    Window(const std::string& title, double min_x, double max_x, double min_y, double max_y);

    Window();

    virtual ~Window();

    virtual void clear();


    virtual void set_title(const std::string& str);

    virtual void set_background_color(const Color &color);

    virtual void set_position(int x, int y);

    virtual void set_size(int width, int height);

    virtual void set_viewport(double left, double right, 
                              double bottom, double top);

    virtual void set_visible(bool visible);

    virtual CursorShape set_cursor(CursorShape cursor);

    virtual CursorShape get_cursor();

    /*
     *  Start the graphics event loop.  Control is passed to the 
     *  event manager and the event manager maintains control for the
     *  rest of the program's execution.  This method should be
     *  called only once.
     *  @return nothing
     */
    virtual void run();

    virtual void repaint();

    virtual void prepaint();

    virtual void postpaint();

    virtual void paint() = 0;

    virtual void paint_all();

    virtual int get_x() const;

    virtual int get_y() const;

    virtual int get_width() const;

    virtual int get_height() const;

    virtual void set_window_size(int w, int h);

    virtual void resized(int w, int h);

    virtual double get_min_x() const;

    virtual double get_max_x() const;

    virtual double get_min_y() const;

    virtual double get_max_y() const;

    virtual void draw_axes(double x_inc, double y_inc) const;

    virtual void mouse_pressed(double x, double y, MouseButton button);

    virtual void mouse_released(double x, double y, MouseButton button);

    virtual void mouse_moved(double x, double y);

    virtual void mouse_dragged(double x, double y);

    virtual void mouse_entered();

    virtual void mouse_exited();


    virtual void key_pressed(int k, double x, double y);

    KeyModifier get_key_modifiers() const;

    void set_key_modifiers(KeyModifier mod);

    virtual void start_timer(int msec);

    virtual void timer_expired();
};

//typedef void (Window::*WindowCallback)();
//using WindowCallback = void (Window::*)();
//using WindowCallback = std::function<void()>;

using MenuItemFunction = std::function<void()>;


class PopupMenu {
protected:
    //Window *window;
    int index;   // The GLUT popup menu index

    struct MenuItem {
        //const char *name;
        std::string name;
        int index;
        //WindowCallback code;
        MenuItemFunction code;
        //MenuItem(const char *name, WindowCallback code):
        //MenuItem(const std::string& name, WindowCallback code):
        MenuItem(const std::string& name, MenuItemFunction code):
              name(name), code(code) {}
    };
    
    std::vector<MenuItem> items;

    static void process_menu_events(int option);

public:
    
    //PopupMenu(Window *win);
    PopupMenu();

    virtual ~PopupMenu();

    //virtual void _add_menu_item(const char *item, WindowCallback func);
    //virtual void internal_add_menu_item(const std::string& item, WindowCallback func);
    //virtual void internal_add_menu_item(const std::string& item, MenuItemFunction func);
    virtual void add_menu_item(const std::string& item, MenuItemFunction func);

    //virtual void internal_replace_menu_item(const std::string& old_name, 
    virtual void replace_menu_item(const std::string& old_name, 
                                            const std::string& new_name, 
                                            MenuItemFunction func);

    //virtual void remove_menu_item(const char *item);
    virtual void remove_menu_item(const std::string& item);

    virtual void execute_handler(int n);

    virtual void activate();
};

class ObjectWindow: public Window {
protected:
    std::vector<GraphicalObject *> object_list;
    GraphicalObject *active_object;

public:
    ObjectWindow(const std::string& title, int left, int top, int width, 
                 int height, double min_x, double max_x, 
                 double min_y, double max_y);

    ObjectWindow(const std::string& title, int width, int height);


    ObjectWindow(const std::string& title, double min_x, double max_x, 
                 double min_y, double max_y);

    ObjectWindow();

    ~ObjectWindow();

    void prepaint() override;

    void postpaint() override;

    void mouse_pressed(double x, double y, MouseButton button) override;

    void mouse_released(double x, double y, MouseButton button) override;

    void mouse_moved(double x, double y) override;

    void mouse_dragged(double x, double y) override;

    void key_pressed(int k, double x, double y) override;

    void internal_add(GraphicalObject *obj);

    //template <typename T, typename... Args>
    //inline T *add(Args&&... args);

    template <typename T, typename... Args>
    inline T *add(Args&&... args) {
        // The window owns the pointer to the graphical object
        T *obj = new T(args...);
        internal_add(obj);
        return obj;
    }


    void remove(GraphicalObject *obj);

    void remove_all();

    GraphicalObject *hit(double x, double y) const;

    std::vector<GraphicalObject *>::iterator begin();

    std::vector<GraphicalObject *>::iterator end();
};


class CompositeObject: public GraphicalObject {
protected:
    std::vector<GraphicalObject *> objects;
public:
    CompositeObject();

    /*
     * The destructor frees up all contained objects.
     */
    ~CompositeObject();

    void paint() const override;

    void move_to(double x, double y) override;

    void internal_add(GraphicalObject *obj);

    template <typename T, typename... Args>
    inline T *add(Args&&... args) {
        // The window owns the pointer to the graphical object
        T *obj = new T(args...);
        internal_add(obj);
        return obj;
    }
};


class Pixmap {
    //  Local type represents a color triple, each with 256 
    //  possible intensities
    struct RGB {
        unsigned char red, green, blue;
    };

    static unsigned short get_short(std::ifstream& fin);

    static unsigned long get_long(std::ifstream& fin);

    static bool power_of_2(int n);
public : 
    // dimensions of the pixmap
    int nRows, nCols;

    // array of pixels
    RGB* pixel;

    bool read_BMP_file(const char *fname);

    bool make_checkerboard();

    // 
    //void set_texture(GLuint textureName);
    void set_texture(unsigned int textureName);
};



class BitmapObject: public GraphicalObject {
    Pixmap pix;
    unsigned int texture_id;
public:
    BitmapObject(const char *filename, double x, double y, 
           double width, double height);

    void paint() const;
};





class OGLWindow: public Window {
public:
    //OGLWindow(const char *title, int left, int top, int width, int height);
    OGLWindow(const std::string& title, int left, int top, int width, int height);

    //OGLWindow(const char *title);
    OGLWindow(const std::string& title);

    // TODO add deleted copy ctor, assignment, etc.

    ~OGLWindow();

    void prepaint() override;

    void postpaint() override;

};


/******************************************
 *  Classes for seven segment digit displays
 ******************************************/

class SevenSegmentDigit {
protected:
    int current_value;

    Color color;

    double x, y;    

    double height;  
    
    //  Draw the segments:
    //        +--- a ---+
    //        |         |
    //        f         b
    //        |         |
    //        +--- g ---+
    //        |         |
    //        e         c
    //        |         |
    //        +--- d ---+

    Point segment_a[4],
          segment_b[4],
          segment_c[4],
          segment_d[4],
          segment_e[4],
          segment_f[4],
          segment_g[6];

   
    void update_segment_locations();
    
public:
    SevenSegmentDigit(Color color, double x, double y, double height);

    double get_x() const;

    double get_y() const;

    double get_height() const;

    void paint() const;

    void set_value(int value);

    int get_value() const;

    void increment();

    void decrement();

    void resize(double inc);

    void move_to(double x, double y);
};


class DisplayDigit: public GraphicalObject {
protected:
    SevenSegmentDigit led;
    
public:
    DisplayDigit(Color color, double x, double y, double height);

    void paint() const override;

    void set_value(int value);

    int get_value() const;


    void increment();

    void decrement();

    void resize(double inc);

    void mouse_dragged(double x, double y) override;
};



class DoubleDigit: public GraphicalObject {
protected:
    SevenSegmentDigit tens;

    SevenSegmentDigit ones;

    bool leading_zero;

    bool visible;
    
public:
    DoubleDigit(Color color, double x, double y, double height);

    void paint() const override;

    void set_value(int value);

    int get_value() const;

    void increment();

    void decrement();

    void resize(double inc);

    void mouse_dragged(double x, double y) override;

    void set_leading_zero(bool flag);

    void set_visible(bool flag);
};


class Multidigit: public GraphicalObject {
protected:
    std::vector<SevenSegmentDigit> digits;

    // /** Dynamic array of seven segment digits  */
    // SevenSegmentDigit *digits;

    bool leading_zeros;

    bool visible;
    
    void increment_helper(int n);

    void decrement_helper(int n);

public:
    Multidigit(int n, Color color, double x, double y, double height);

    void paint() const override;

    void set_value(int value);

    int get_value() const;

    void increment();

    void decrement();

    void resize(double inc);

    void mouse_dragged(double x, double y) override;

    virtual void move_to(double left, double bottom) override;

    void set_leading_zeros(bool flag);

    void set_visible(bool flag);
};


class TimeDisplay: public GraphicalObject {
protected:
    SevenSegmentDigit hours_tens;

    SevenSegmentDigit hours_ones;

    SevenSegmentDigit minutes_tens;

    SevenSegmentDigit minutes_ones;

    SevenSegmentDigit seconds_tens;

    SevenSegmentDigit seconds_ones;

    int seconds;

    bool leading_units;

    bool visible;

    void draw_separator(const SevenSegmentDigit& left_ones, const SevenSegmentDigit& right_tens) const;

    void paint_without_leading_units() const;

public:
    TimeDisplay(Color color, double x, double y, int height);

    void paint() const override;

    void set_value(int sec);

    int get_value() const;

    void increment();

    void decrement();

    void resize(double inc);

    void mouse_dragged(double x, double y) override;

    void move_to(double x, double y) override;


    void set_leading_units(bool flag);

    void set_visible(bool flag);
};





/******************************************
 *  Global drawing functions
 ******************************************/


void initialize_graphics(unsigned int mode);

void initialize_graphics();


bool intersect(const GraphicalObject& obj1, 
                          const GraphicalObject& obj2);

void draw_point(double x, double y);

void draw_point(const Point& pt);

void set_point_size(int point_size);


void draw_line(double x0, double y0, double x1, double y1);

void draw_dashed_line(double x0, double y0, double x1, double y1, 
                      int pattern=0x00FF);

void draw_rectangle(double x, double y, double width, double height);

void fill_rectangle(double x, double y, double width, double height);

void draw_circle(double x, double y, double radius);

void fill_circle(double x, double y, double radius);

void draw_polygon(const std::vector<Point>& pts);

void draw_polygon(const Point *pts, int n);

void fill_polygon(const std::vector<Point>& pts);

void fill_polygon(const Point *pts, int n);

//void draw_text(const char *text, double x, double y, int font_size);
void draw_text(const std::string& text, double x, double y, int font_size);

//void draw_text(const char *text, double x, double y, double scale);
void draw_text(const std::string& text, double x, double y, double scale);

//double text_width(const char *text, int font_size);
double text_width(const std::string& text, int font_size);

void draw_function(double (*f)(double), double begin_x, double end_x,
                   double delta);

void set_color(const Color &color);

void set_color(double r, double g, double b);

void set_line_width(double width);


template <typename T, typename... Args>
inline void run(Args&&... args);

template <typename T, typename... Args>
inline T *make_window(Args&&... args);



/****************************************************
 *   Miscellaneous utility functions
 ****************************************************/

int get_screen_width();

int get_screen_height();


/*  Add a random number generator class? */

void set_random_seed(int seed=-1);

int random(int begin, int end);

int random(int n);


class Stopwatch {
protected:
    clock_t start_time;

    clock_t end_time;

    bool running;

public:
    Stopwatch();

    void start(); 

    void stop();

    void reset(); 

    double elapsed() const;  //  Reveal the elapsed time
};

void pause(int msec);



bool equals(double d1, double d2, double delta);

// Modern C++ provides standard functions for these:
// *  Converts an integer to a string so it can be displayed
// *  with draw_text.
// *  @param i the integer to convert
// *  @return the string representation of i
// */
//std::string to_string(int i);
//
// *  Converts a double to a string so it can be displayed
// *  with draw_text.
// *  @param d the double to convert
// *  @return the string representation of d
// */
//std::string to_string(double d);


std::string version();


//------------------------------------------------------------------------------------------
// Procedural interface to the SGL

void create_window(const std::string& title, int x, int y, int width, int height);

void run_window();

void update_window();

void set_paint_function(const std::function<void()>& f);

void set_mouse_pressed_function(const std::function<void(double, double, MouseButton)>& f);

void set_mouse_released_function(const std::function<void(double, double, MouseButton)>& f);

void set_mouse_moved_function(const std::function<void(double, double)>& f);

void set_mouse_dragged_function(const std::function<void(double, double)>& f);

void set_key_pressed_function(const std::function<void(int, double, double)>& f);

void set_window_background(const Color& c);

void set_window_title(const std::string& str);



}  //  End of namespace sgl

//#define add_menu_item(x, y) internal_add_menu_item((x), (y));
//#define replace_menu_item(x, y, z) internal_replace_menu_item((x), (y), (z));


#endif