Widget.h

Go to the documentation of this file.

/* This file is part of the Zenipex Library (zenilib).
 * Copyright (C) 2011 Mitchell Keith Bloch (bazald).
 *
 * zenilib is free software: you can redistribute it and/or modify
 * it under the terms of the GNU Lesser General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * zenilib is distributed in the hope that it will be useful,
 * but WITHOUT ANY WARRANTY; without even the implied warranty of
 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 * GNU Lesser General Public License for more details.
 *
 * You should have received a copy of the GNU Lesser General Public License
 * along with zenilib.  If not, see <http://www.gnu.org/licenses/>.
 */

#ifndef ZENI_WIDGET_H
#define ZENI_WIDGET_H

#include <Zeni/Collision.h>
#include <Zeni/Coordinate.h>
#include <Zeni/Font.h>
#include <Zeni/Line_Segment.h>
#include <Zeni/Projector.h>
#include <Zeni/String.h>
#include <Zeni/Texture.h>
#include <Zeni/Timer.h>
#include <Zeni/Quadrilateral.h>
#include <Zeni/Vertex2f.h>
#include <Zeni/Video.h>

#include <vector>
#include <set>

#include <Zeni/Define.h>

namespace Zeni {

  class Widget_Render_Function;

  class ZENI_REST_DLL Widget {
    Widget(const Widget &);
    Widget & operator=(const Widget &);

  public:
    inline Widget();
    virtual ~Widget();

    inline const bool & is_busy() const;
    inline const bool & is_editable() const;
    inline const float & get_layer() const;
    inline void set_busy(const bool &busy_);
    virtual void set_editable(const bool &editable_);
    inline void set_layer(const float &layer_ = 0.0f);

#ifndef ANDROID
    inline void on_event(const SDL_KeyboardEvent &event);
    inline void on_event(const SDL_MouseButtonEvent &event);
    inline void on_event(const SDL_MouseButtonEvent &event, const Projector2D &projector);
    inline void on_event(const SDL_MouseMotionEvent &event);
    inline void on_event(const SDL_MouseMotionEvent &event, const Projector2D &projector);
#if SDL_VERSION_ATLEAST(2,0,0)
    inline void on_event(const SDL_MouseWheelEvent &event);
    inline void on_event(const SDL_MouseWheelEvent &event, const Projector2D &projector);
#endif
#endif

#ifndef ANDROID
    virtual void on_key(const SDL_Keysym & /*keysym*/, const bool & /*down*/) {}
#endif
    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button) = 0;
    virtual void on_mouse_motion(const Point2i &pos) = 0;
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up) = 0;
#endif

    virtual void perform_logic() {}

    inline void render() const;

    inline const Widget_Render_Function * get_Renderer() const; 
    inline void give_Renderer(Widget_Render_Function * const &renderer); 
    inline void lend_Renderer(const Widget_Render_Function * const &renderer); 
    inline void fax_Renderer(const Widget_Render_Function * const &renderer); 

    virtual void render_impl() const;

  private:
    float m_layer;
    bool m_busy;
    bool m_editable;

    Widget_Render_Function * m_renderer;
    bool delete_m_renderer;
  };

  class ZENI_REST_DLL Widget_Render_Function {
  public:
    virtual ~Widget_Render_Function() {}

    virtual void render_to(const Widget &widget) = 0;

    virtual Widget_Render_Function * get_duplicate() const = 0;
  };

  template <typename T1, typename T2>
  class Widget_Renderer_Pair : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Pair(const T1 * const &first_, const bool &delete_first_,
                                const T2 * const &second_, const bool &delete_second_);
    virtual ~Widget_Renderer_Pair();

    inline const T1 * const & first() const;
    inline const T2 * const & second() const;
    inline T1 * const & first();
    inline T2 * const & second();

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Pair<T1, T2> * get_duplicate() const;

  private:
    T1 * m_first;
    bool delete_m_first;

    T2 * m_second;
    bool delete_m_second;
  };

  template <typename T1, typename T2>
  Widget_Renderer_Pair<T1, T2> * make_Widget_Renderer_Pair(const T1 * const &first_, const bool &delete_first_,
                                                           const T2 * const &second_, const bool &delete_second_);

  class ZENI_REST_DLL Widget_Renderer_Text : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Text(const String &font_name_, const String &text_, const Color &color_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Text * get_duplicate() const;

    String font_name;
    String text;
    Color color;
  };

  class ZENI_REST_DLL Widget_Renderer_Color : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Color(const Color &color_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Color * get_duplicate() const;

    Color color;
  };

  class ZENI_REST_DLL Widget_Renderer_Texture : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Texture(const String &texture_);
    inline Widget_Renderer_Texture(const String &texture_,
                                   const Point2f &tex_coord_ul_,
                                   const Point2f &tex_coord_ll_,
                                   const Point2f &tex_coord_lr_,
                                   const Point2f &tex_coord_ur_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Texture * get_duplicate() const;

    String texture;
    Point2f tex_coord_ul;
    Point2f tex_coord_ll;
    Point2f tex_coord_lr;
    Point2f tex_coord_ur;
  };

  class ZENI_REST_DLL Widget_Renderer_Tricolor : public Widget_Renderer_Color {
  public:
    inline Widget_Renderer_Tricolor();
    inline Widget_Renderer_Tricolor(const Color &bg_normal_, const Color &bg_clicked_, const Color &bg_hovered_strayed_,
                                    const Color &text_normal_, const Color &text_clicked_, const Color &text_hovered_strayed_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Tricolor * get_duplicate() const;

    Color bg_normal;
    Color bg_clicked;
    Color bg_hovered_strayed;
    Color text_normal;
    Color text_clicked;
    Color text_hovered_strayed;
  };

  class ZENI_REST_DLL Widget_Renderer_Check_Box : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Check_Box();
    inline Widget_Renderer_Check_Box(const Color &border_color_, const Color &check_color_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Check_Box * get_duplicate() const;

    Color border_color;
    Color check_color;
  };

  class ZENI_REST_DLL Widget_Renderer_Slider : public Widget_Render_Function {
  public:
    inline Widget_Renderer_Slider();
    inline Widget_Renderer_Slider(const Color &line_color_, const Color &slider_color_);

    virtual void render_to(const Widget &widget);

    virtual Widget_Renderer_Slider * get_duplicate() const;

    Color line_color;
    Color slider_color;
  };

  class ZENI_REST_DLL Widget_Rectangle {
  public:
    inline Widget_Rectangle(const Point2f &upper_left_, const Point2f &lower_right_);
    virtual ~Widget_Rectangle() {}
 
    inline const Point2f & get_upper_left() const;
    inline Point2f get_lower_left() const;
    inline const Point2f & get_lower_right() const;
    inline Point2f get_upper_right() const;
 
    virtual void set_upper_left(const Point2f &upper_left_);
    virtual void set_lower_right(const Point2f &lower_right_);

    inline float get_height() const;
    inline float get_width() const;
    inline Point2f get_center() const;

    inline bool is_inside(const Point2i &pos) const;

  private:
    Point2f m_upper_left;
    Point2f m_lower_right;
  };

  class ZENI_REST_DLL Widget_Button : public Widget, public Widget_Rectangle {
    Widget_Button(const Widget_Button &);
    Widget_Button & operator=(const Widget_Button &);

  public:
    enum State {NORMAL, CLICKED, HOVERED, STRAYED, UNACTIONABLE};

    inline Widget_Button(const Point2f &upper_left_, const Point2f &lower_right_);

    inline const State & get_State() const; 

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up);
#endif

    virtual void on_hover() {}
    virtual void on_unhover() {}

    virtual void on_click() {}
    virtual void on_stray() {}
    virtual void on_unstray() {}

    virtual void on_accept() {}
    virtual void on_reject() {}

  private:
    State m_state;
  };

  class ZENI_REST_DLL Text_Button : public Widget_Button, public Widget_Renderer_Text {
    Text_Button(const Text_Button &);
    Text_Button & operator=(const Text_Button &);

  public:
    inline Text_Button(const Point2f &upper_left_, const Point2f &lower_right_,
                       const String &font_name_, const String &text_);
  };

  class ZENI_REST_DLL Check_Box : public Widget_Button {
    Check_Box(const Check_Box &);
    Check_Box & operator=(const Check_Box &);

  public:
    inline Check_Box(const Point2f &upper_left_, const Point2f &lower_right_,
                     const bool &checked_ = false, const bool &toggleable_ = true);

    inline const bool & is_checked() const;
    inline void set_checked(const bool &checked_);
    inline const bool & is_toggling() const;

    virtual void on_accept();

    virtual void on_click();
    virtual void on_unstray();

    virtual void on_reject();
    virtual void on_stray();

  private:
    bool m_checked;
    bool m_toggling;
  };

  class ZENI_REST_DLL Radio_Button;
  class ZENI_REST_DLL Radio_Button_Set : public Widget {
    Radio_Button_Set(const Radio_Button_Set &);
    Radio_Button_Set & operator=(const Radio_Button_Set &);

    friend class Radio_Button;

  public:
    Radio_Button_Set() {}

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);

    inline void accept(Radio_Button &radio_button);
    inline void clear();

    virtual void render_impl() const;

  private:
    inline void lend_Radio_Button(Radio_Button &radio_button);
    inline void unlend_Radio_Button(Radio_Button &radio_button);

#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    std::set<Radio_Button *> m_radio_buttons;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
  };

  class ZENI_REST_DLL Radio_Button : public Check_Box {
    Radio_Button(const Radio_Button &);
    Radio_Button & operator=(const Radio_Button &);

    friend class Radio_Button_Set;

  public:
    inline Radio_Button(Radio_Button_Set &radio_button_set_,
                        const Point2f &upper_left_, const Point2f &lower_right_,
                        const bool &checked_ = false, const bool &toggleable_ = true);
    inline ~Radio_Button();

    virtual void on_accept();

  private:
    Radio_Button_Set * m_radio_button_set;
  };

  class ZENI_REST_DLL Slider : public Widget {
    Slider(const Slider &);
    Slider & operator=(const Slider &);

  public:
    Slider(const Point2f &end_point_a_, const Point2f &end_point_b_,
           const float &slider_radius_,
           const float &slider_position_ = ZENI_DEFAULT_SLIDER_POSITION);

    inline Point2f get_end_point_a() const;
    inline Point2f get_end_point_b() const;
    inline const float & get_slider_radius() const;
    inline const float & get_slider_position() const;

    inline void set_end_points(const Point2f &end_point_a_, const Point2f &end_point_b_);
    inline void set_slider_radius(const float &radius_);
    inline void set_slider_position(const float &slider_position_);

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up);
#endif

    virtual void on_slide();
    virtual void on_accept();

    inline const bool & is_mouse_wheel_inverted() const;
    inline void invert_mouse_wheel(const bool &invert);

    inline const float & get_mouse_wheel_continuous_rate() const;
    inline void set_mouse_wheel_continuous_rate(const float &mouse_wheel_continuous_rate);

  protected:
    inline const Collision::Line_Segment & get_line_segment() const;

  private:
    Collision::Line_Segment m_line_segment;
    float m_slider_radius;

    bool m_mouse_wheel_inverted;
    float m_mouse_wheel_continuous_rate;

    float m_slider_position;
    float m_backup_position;
    bool m_down;
  };

  class ZENI_REST_DLL Slider_Int : public Slider {
    Slider_Int(const Slider_Int &);
    Slider_Int & operator=(const Slider_Int &);

  public:
    typedef std::pair<int, int> Range;

    Slider_Int(const Range &range,
               const Point2f &end_point_a_, const Point2f &end_point_b_,
               const float &slider_radius_,
               const float &slider_position_ = ZENI_DEFAULT_SLIDER_POSITION);

    inline const Range & get_range() const;
    inline void set_range(const Range &range_);

    inline int get_value() const;
    inline void set_value(const int &value);

    virtual void on_slide();
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up);
#else
    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
#endif

  private:
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    Range m_range;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
  };

  class ZENI_REST_DLL Selector : public Widget {
    Selector(const Selector &);
    Selector & operator=(const Selector &);

    class ZENI_REST_DLL Normal_Button : public Text_Button {
      Normal_Button(const Normal_Button &);
      Normal_Button & operator=(const Normal_Button &);

    public:
      Normal_Button(Selector &selector,
                                     const Point2f &upper_left_,
                                     const Point2f &lower_right_);

      void on_accept();

    private:
      Selector * m_selector;
    };

    class ZENI_REST_DLL Selector_Button : public Text_Button {
      Selector_Button(const Selector_Button &);
      Selector_Button & operator=(const Selector_Button &);

    public:
      Selector_Button(Selector &selector,
                                       const String &option,
                                       const Point2f &upper_left_,
                                       const Point2f &lower_right_);

      void on_accept();

    private:
      Selector * m_selector;
    };

    class ZENI_REST_DLL Selector_Slider : public Widget_Rectangle, public Slider_Int {
      Selector_Slider(const Selector_Slider &);
      Selector_Slider & operator=(const Selector_Slider &);

    public:
      Selector_Slider(Selector &selector,
                                       const float &slider_radius_,
                                       const std::pair<float, float> &bg_coordinates_);

      void set_end_points(const Point2f &end_point_a_, const Point2f &end_point_b_);

      void on_slide();

      void render_impl() const;

    private:
      Selector * m_selector;
    };

  public:
    typedef std::vector<String> Options;

    Selector(const Point2f &upper_left_, const Point2f &lower_right_,
                              const Point2f &expanded_upper_left_, const Point2f &expanded_lower_right_,
                              const String &font_);
    ~Selector();

    const Options & get_options() const;

    void add_option(const String &option);
    void remove_option(const String &option);

    String get_selected() const;
    void select_option(const String &option);

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up);
#endif

    virtual void on_accept(const String &option);

    virtual void render_impl() const;

    inline const Widget_Render_Function * get_Text_Button_Renderer() const; 
    inline void give_Text_Button_Renderer(Widget_Render_Function * const &renderer); 
    inline void lend_Text_Button_Renderer(const Widget_Render_Function * const &renderer); 
    inline void fax_Text_Button_Renderer(const Widget_Render_Function * const &renderer); 

    inline const Widget_Render_Function * get_Slider_Renderer() const; 
    inline void give_Slider_Renderer(Widget_Render_Function * const &renderer); 
    inline void lend_Slider_Renderer(const Widget_Render_Function * const &renderer); 
    inline void fax_Slider_Renderer(const Widget_Render_Function * const &renderer); 

    inline const Widget_Render_Function * get_Slider_BG_Renderer() const; 
    inline void give_Slider_BG_Renderer(Widget_Render_Function * const &renderer); 
    inline void lend_Slider_BG_Renderer(const Widget_Render_Function * const &renderer); 
    inline void fax_Slider_BG_Renderer(const Widget_Render_Function * const &renderer); 

    inline const String & get_Font() const; 
    inline void set_font(const String &font_); 

  private:
    const Widget_Render_Function * get_Renderer() const; 
    void give_Renderer(Widget_Render_Function * const &); 
    void lend_Renderer(const Widget_Render_Function * const &); 
    void fax_Renderer(const Widget_Render_Function * const &); 

    float button_height() const;
    float vertical_offset() const;

    void decide_visible(const size_t &centered);

    std::pair<Point2f, Point2f> visible_region() const;

    void add_selector_button(const String &option);

    void build_selector_buttons();

    void clear();

    Widget_Render_Function * m_button_renderer;
    bool delete_m_button_renderer;
    Widget_Render_Function * m_slider_renderer;
    bool delete_m_slider_renderer;
    Widget_Render_Function * m_slider_bg_renderer;
    bool delete_m_slider_bg_renderer;
    String m_font;

    Widget_Rectangle m_expanded;

#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    Options m_options;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
    size_t m_option;

    bool m_selected;

    Normal_Button m_normal_button;
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    std::vector<Selector_Button *> m_selector_buttons;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
    Selector_Slider m_selector_slider;

    size_t view_start;
    size_t view_end;
    size_t view_offset;
    size_t view_hidden;
  };

  class ZENI_REST_DLL Text_Box : public Widget_Button {
    Text_Box(const Text_Box &);
    Text_Box & operator=(const Text_Box &);

  public:
    Text_Box(const Point2f &upper_left_, const Point2f &lower_right_,
                              const String &font_name_, const String &text_, const Color &text_color_,
                              const bool &editable_ = ZENI_DEFAULT_TEXTBOX_EDITABLE,
                              const JUSTIFY &justify_ = ZENI_DEFAULT_JUSTIFY,
                              const int &tab_spaces_ = ZENI_DEFAULT_TAB_SPACES);
    ~Text_Box();

#ifndef ANDROID
    virtual void on_key(const SDL_Keysym &keysym, const bool &down);
#endif

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_accept();

    virtual void on_focus();
    virtual void on_unfocus();
    virtual void on_change();

    inline const String & get_font_name() const;
    inline const Font & get_Font() const;
    inline const String & get_text() const;
    inline const Color & get_text_color() const;
    inline const JUSTIFY & get_justify() const;
    inline size_t get_num_lines() const;
    inline size_t get_max_lines() const;

    virtual void set_editable(const bool &editable_);
    virtual void set_upper_left(const Point2f &upper_left_);
    virtual void set_lower_right(const Point2f &lower_right_);
    inline void set_font_name(const String &font_name_);
    inline void set_text(const String &text_);
    inline void set_text_color(const Color &text_color_);
    inline void set_justify(const JUSTIFY &justify_);
    inline void erase_lines(const unsigned int &begin, const unsigned int &end);

    const int & get_edit_pos() const;
    int get_cursor_pos() const;
    int get_max_seek() const;
    int get_max_cursor_seek() const;

    void seek(const int &edit_pos);
    void seek_cursor(const int &cursor_pos);
    void set_focus(const bool &value);

    virtual void render_impl() const;

    inline const Widget_Render_Function * get_BG_Renderer() const; 
    inline void give_BG_Renderer(Widget_Render_Function * const &renderer); 
    inline void lend_BG_Renderer(const Widget_Render_Function * const &renderer); 
    inline void fax_BG_Renderer(const Widget_Render_Function * const &renderer); 

  private:
    const Widget_Render_Function * get_Renderer() const; 
    void give_Renderer(Widget_Render_Function * const &); 
    void lend_Renderer(const Widget_Render_Function * const &); 
    void fax_Renderer(const Widget_Render_Function * const &); 

    struct ZENI_REST_DLL Word {
      enum Type {NONSENSE = 0x0, WORD = 0x1, SPACE = 0x2};

      Word(const Type &type_ = NONSENSE) : unformatted_glyph_sides(1, 0), type(type_), splittable(false), fpsplit(false) {}

      String unformatted;
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
      std::vector<float> unformatted_glyph_sides;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
      Type type;
      bool splittable;
      bool fpsplit; // indicates it has been split already and a '-' should be appended
    };

    struct ZENI_REST_DLL Line : public Word {
      Line() : glyph_top(0), endled(false) {}

      String formatted;
      float glyph_top;
      bool endled;
    };

    void format();
    void append_word(const Word &word);

    Widget_Render_Function * m_bg_renderer;
    bool delete_m_bg_renderer;
    Widget_Renderer_Text m_text;

    String clean_string(const String &unclean_string) const;
    String untablinebreak(const String &tabbed_text) const;
    float get_text_width(const Font &font, const String &text); 
    float max_line_width() const;

    inline void invalidate_edit_pos();

#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    std::vector<Line> m_lines;
#ifdef _WINDOWS
#pragma warning( pop )
#endif

    int m_edit_pos;
    Time m_last_seek;

    JUSTIFY m_justify;
    int m_tab_spaces;

    Point2i m_cursor_pos;
    Point2i m_cursor_index;

  public:
    static void reformat_all(); 

  private:
#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    static class Reinit : public Event::Handler {
      void operator()() {
        Text_Box::reformat_all();
      }

      Reinit * duplicate() const {
        return new Reinit;
      }

    public:
      Reinit() {}

    private:
      // Undefined
      Reinit(const Reinit &);
      Reinit operator=(const Reinit &);
    } g_reinit;
#ifdef _WINDOWS
#pragma warning( pop )
#endif

    static std::set<Text_Box *> & get_text_boxes();
  };

  class ZENI_REST_DLL Widget_Input_Repeater : public Widget {
    Widget_Input_Repeater(const Widget_Input_Repeater &);
    Widget_Input_Repeater & operator=(const Widget_Input_Repeater &);

  public:
    inline Widget_Input_Repeater(Widget &widget_,
                                 const int &repeat_delay_ = SDL_DEFAULT_REPEAT_DELAY,
                                 const int &repeat_interval_ = SDL_DEFAULT_REPEAT_INTERVAL);

    inline Widget * const & get_widget() const;
    inline const int & get_repeat_delay() const;
    inline const int & get_repeat_interval() const ;

    inline void set_widget(Widget &widget_);
    inline void set_repeat_delay(const int &repeat_delay_ = SDL_DEFAULT_REPEAT_DELAY);
    inline void set_repeat_interval(const int &repeat_interval_ = SDL_DEFAULT_REPEAT_INTERVAL);

#ifndef ANDROID
    virtual void on_key(const SDL_Keysym &keysym, const bool &down);
#endif
    
    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);

    virtual void perform_logic();

    // render is simply passed through
    virtual void render_impl() const;

  private:
    const Widget_Render_Function * get_Renderer() const; 
    void give_Renderer(Widget_Render_Function * const &); 
    void lend_Renderer(const Widget_Render_Function * const &); 
    void fax_Renderer(const Widget_Render_Function * const &); 

    Widget * m_widget;
    int m_repeat_delay;
    int m_repeat_interval;
    
    Time m_last_repeated;
    bool m_active;
    bool m_delay_finished;

#ifndef ANDROID
    SDL_Keysym m_keysym;
#endif
    bool m_down;
  };

  class ZENI_REST_DLL Widgets : public Widget {
    Widgets(const Widgets &);
    Widgets & operator=(const Widgets &);

  public:
    inline Widgets();

    inline void lend_Widget(Widget &widget);
    inline void unlend_Widget(Widget &widget);

#ifndef ANDROID
    virtual void on_key(const SDL_Keysym &keysym, const bool &down);
#endif

    virtual void on_mouse_button(const Point2i &pos, const bool &down, const int &button);
    virtual void on_mouse_motion(const Point2i &pos);
#if SDL_VERSION_ATLEAST(2,0,0)
    virtual void on_mouse_wheel(const Point2i &pos, const int &up);
#endif

    virtual void perform_logic();

    virtual void render_impl() const;

  private:
    const Widget_Render_Function * get_Renderer() const; 
    void give_Renderer(Widget_Render_Function * const &); 
    void lend_Renderer(const Widget_Render_Function * const &); 
    void fax_Renderer(const Widget_Render_Function * const &); 

#ifdef _WINDOWS
#pragma warning( push )
#pragma warning( disable : 4251 )
#endif
    mutable std::vector<Widget *> m_widgets;
#ifdef _WINDOWS
#pragma warning( pop )
#endif
    Widget * m_busy_one;
  };

  class ZENI_REST_DLL Widget_Renderer_Wrong_Type : public Error {
  public:
    Widget_Renderer_Wrong_Type() : Error("Widget_Renderer_Function received an unexpected type") {}
  };

}

#include <Zeni/Undefine.h>

#endif