E:/prg/sdlpp/include/sdlpp_ui.h

#ifndef H_SDLPP_UI
#define H_SDLPP_UI

namespace SDLPP {

struct Highlight
{
  Highlight(Uint32 fg=MapRGB(255,255,255),
            Uint32 bg=MapRGB(0,0,0),
            Uint32 hl_fg=MapRGB(0,255,255),
            Uint32 hl_bg=MapRGB(0,0,128)) : m_FG(fg), m_BG(bg), m_HLFG(hl_fg), m_HLBG(hl_bg) {}
  Uint32 m_FG,m_BG,m_HLFG,m_HLBG;
};

class ScreenMenu
{
  Font&     m_Font;
  Highlight m_HL;
  str_vec   m_Items;
  iVec2     m_Size;
public:
  ScreenMenu(Font& font=get_font("Arial",36), const Highlight& hl=Highlight());
  void add_item(const char* text);
  int  run(Bitmap* background=0, SoundClip* hover=0, SoundClip* select=0);
};

class Component
{
protected:
  Bitmap         m_Image;
  iRect2         m_Rect;
  Component*     m_Parent;

  typedef std::vector<Component> comp_seq;
  comp_seq       m_Children;

  iVec2 get_global_position() const
  {
    iVec2 offset=m_Rect.tl;
    if (m_Parent) offset+=m_Parent->get_global_position();
    return offset;
  }

  iVec2 get_local_position(const iVec2& p) const
  {
    iVec2 global=get_global_position() - m_Rect.tl;
    return p-global;
  }

  void set_bitmap(Bitmap bmp) { m_Image=bmp; }
  void set_position(const iVec2& p) { m_Rect=iRect2(p,p+m_Image.get_size()); }
  void set_parent(Component* parent) { m_Parent=parent; }
  virtual void set_capture(Component* child) { if (m_Parent) m_Parent->set_capture(child); }
public:
  Component(Component* parent=0) : m_Parent(parent), m_Rect(0,0,0,0) {}
  virtual ~Component();

  virtual void draw(Bitmap target) 
  { 
    m_Image.draw(target,get_global_position());
  }

  Component& add_child(const Component& c) { m_Children.push_back(c); return m_Children.back(); }

  virtual void draw() { draw(get_screen()); }

  const iRect2&    get_rect()   const { return m_Rect; }
  const Component* get_parent() const { return m_Parent; }

  // All coordinates here are global position
  bool inside(const iVec2& p) const { return m_Rect.inside(get_local_position(p)); }
  virtual void button_down(int button, const iVec2& position);
  virtual void button_up(int button, const iVec2& position);
  virtual void mouse_move(int button, const iVec2& position);
};

class RootComponent : public Component, public EventListener
{
  Component*     m_Capture;
public:
  RootComponent()
    : m_Capture(0)
  {
    Bitmap scr=get_screen();
    m_Rect=iRect2(0,0,scr.get_width(),scr.get_height());
    EventManager::instance()->register_listener(SDL_MOUSEMOTION,this);
    EventManager::instance()->register_listener(SDL_MOUSEBUTTONDOWN,this);
    EventManager::instance()->register_listener(SDL_MOUSEBUTTONUP,this);
  }

  virtual bool handle_event(const SDL_Event& e)
  {
    switch (e.type)
    {
    case SDL_MOUSEMOTION:     
      {
        int button=0;
        for(int i=1;i<3;++i)
          if (e.motion.state & SDL_BUTTON(i)) button=i;
        mouse_move(button,iVec2(e.motion.x,e.motion.y)); 
        return true; 
      }
    case SDL_MOUSEBUTTONDOWN: button_down(e.button.button,iVec2(e.button.x,e.button.y)); return true; 
    case SDL_MOUSEBUTTONUP:   button_up(e.button.button,iVec2(e.button.x,e.button.y)); return true; 
    }
    return false;
  }

  virtual void button_down(int button, const iVec2& position)
  {
    if (m_Capture) m_Capture->button_down(button,position);
    else Component::button_down(button,position);
  }

  virtual void button_up(int button, const iVec2& position)
  {
    if (m_Capture) m_Capture->button_up(button,position);
    else Component::button_up(button,position);
  }

  virtual void mouse_move(int button, const iVec2& position)
  {
    if (m_Capture) m_Capture->mouse_move(button,position);
    else Component::mouse_move(button,position);
  }


protected:
  virtual void set_capture(Component* child) { m_Capture=child; }
};

class OButton : public Component
{
  Bitmap m_Regular,m_Pressed;
public:
  OButton(const iVec2& size, const xstring& text);
  OButton(const iVec2& size, Bitmap bmp);

  virtual void button_down(int button, const iVec2& position);
  virtual void button_up(int button, const iVec2& position);
  virtual void mouse_move(int button, const iVec2& position);
};


} // namespace SDLPP

#endif // H_SDLPP_UI

---