Menu.h

Go to the documentation of this file.

// -*- C++ -*-
/* GG is a GUI for SDL and OpenGL.
   Copyright (C) 2003 T. Zachary Laine

   This library 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 2.1
   of the License, or (at your option) any later version.
   
   This library 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 this library; if not, write to the Free
   Software Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
   02111-1307 USA

   If you do not wish to comply with the terms of the LGPL please
   contact the author as other terms are available for a fee.
    
   Zach Laine
   whatwasthataddress@hotmail.com */

#ifndef _GG_Menu_h_
#define _GG_Menu_h_

#include <GG/Control.h>


namespace GG {

class Font;
class TextControl;

struct GG_API MenuItem
{ 
    typedef boost::signal<void (int)> SelectedIDSignalType; 
    typedef boost::signal<void ()>    SelectedSignalType;   

 
    typedef SelectedIDSignalType::slot_type SelectedIDSlotType; 
    typedef SelectedSignalType::slot_type   SelectedSlotType;   

 
    MenuItem(); 
    MenuItem(const std::string& str, int id, bool disable, bool check); 

    MenuItem(const std::string& str, int id, bool disable, bool check, const SelectedIDSlotType& slot);

    MenuItem(const std::string& str, int id, bool disable, bool check, const SelectedSlotType& slot);

    template <class T1, class T2>
    MenuItem(const std::string& str, int id, bool disable, bool check, void (T1::* slot)(int), T2* obj);

    template <class T1, class T2>
    MenuItem(const std::string& str, int id, bool disable, bool check, void (T1::* slot)(), T2* obj);

    virtual ~MenuItem(); 

 
    mutable boost::shared_ptr<SelectedIDSignalType> SelectedIDSignal; 
    mutable boost::shared_ptr<SelectedSignalType>   SelectedSignal;   


    std::string           label;      
    int                   item_ID;    
    bool                  disabled;   
    bool                  checked;    
    std::vector<MenuItem> next_level; 

private:
    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};


struct SetFontAction;
struct SetTextColorAction;

class GG_API MenuBar : public Control
{
public: 
    typedef boost::signal<void (int)> BrowsedSignalType; 

 
    typedef BrowsedSignalType::slot_type  BrowsedSlotType;   

 

    MenuBar(int x, int y, int w, const boost::shared_ptr<Font>& font, Clr text_color = CLR_WHITE, Clr color = CLR_BLACK, Clr interior = CLR_SHADOW); 
    MenuBar(int x, int y, int w, const boost::shared_ptr<Font>& font, const MenuItem& m, Clr text_color = CLR_WHITE, Clr color = CLR_BLACK, Clr interior = CLR_SHADOW); 

 
    virtual Pt        MinUsableSize() const;

    const MenuItem&   AllMenus() const;                           
    bool              ContainsMenu(const std::string& str) const; 
    int               NumMenus() const;                           

    const MenuItem&   GetMenu(const std::string& str) const;

    const MenuItem&   GetMenu(int n) const;      

    Clr               BorderColor() const;       
    Clr               InteriorColor() const;     
    Clr               TextColor() const;         
    Clr               HiliteColor() const;       
    Clr               SelectedTextColor() const; 

    mutable BrowsedSignalType BrowsedSignal; 

 
    virtual void   Render();
    virtual void   LButtonDown(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   MouseHere(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   MouseLeave();

    virtual void   SizeMove(const Pt& ul, const Pt& lr);

    MenuItem&      AllMenus();                    

    MenuItem&      GetMenu(const std::string& str);

    MenuItem&      GetMenu(int n);                
    void           AddMenu(const MenuItem& menu); 

    void           SetBorderColor(Clr clr);       
    void           SetInteriorColor(Clr clr);     
    void           SetTextColor(Clr clr);         
    void           SetHiliteColor(Clr clr);       
    void           SetSelectedTextColor(Clr clr); 

    virtual void   DefineAttributes(WndEditor* editor);

protected: 
    MenuBar(); 

 
    const boost::shared_ptr<Font>&   GetFont() const;    
    const std::vector<TextControl*>& MenuLabels() const; 
    int                              Caret() const;      


private:
    void AdjustLayout(bool reset = false);

    void BrowsedSlot(int n); 

    boost::shared_ptr<Font>   m_font;           
    Clr                       m_border_color;   
    Clr                       m_int_color;      
    Clr                       m_text_color;     
    Clr                       m_hilite_color;   
    Clr                       m_sel_text_color; 

    MenuItem                  m_menu_data;      
    std::vector<TextControl*> m_menu_labels;    
    int                       m_caret;          

    friend struct SetFontAction;
    friend struct SetTextColorAction;

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
};


class GG_API PopupMenu : public Wnd
{
public: 
    typedef boost::signal<void (int)> BrowsedSignalType; 

 
    typedef BrowsedSignalType::slot_type  BrowsedSlotType;   

 

    PopupMenu(int x, int y, const boost::shared_ptr<Font>& font, const MenuItem& m, Clr text_color = CLR_WHITE, Clr color = CLR_BLACK, Clr interior = CLR_SHADOW);
 
    virtual Pt  ClientUpperLeft() const;

    int         MenuID() const;            
    Clr         BorderColor() const;       
    Clr         InteriorColor() const;     
    Clr         TextColor() const;         
    Clr         HiliteColor() const;       
    Clr         SelectedTextColor() const; 

    mutable BrowsedSignalType BrowsedSignal; 

 
    virtual void   Render();
    virtual void   LButtonUp(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   LClick(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   LDrag(const Pt& pt, const Pt& move, Flags<ModKey> mod_keys);
    virtual void   RButtonUp(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   RClick(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void   MouseHere(const Pt& pt, Flags<ModKey> mod_keys);

    virtual int    Run();

    void           SetBorderColor(Clr clr);       
    void           SetInteriorColor(Clr clr);     
    void           SetTextColor(Clr clr);         
    void           SetHiliteColor(Clr clr);       
    void           SetSelectedTextColor(Clr clr); 


protected: 
    const boost::shared_ptr<Font>&
                             GetFont() const;      
    const MenuItem&          MenuData() const;     
    const std::vector<Rect>& OpenLevels() const;   
    const std::vector<int>&  Caret() const;        
    const MenuItem*          ItemSelected() const; 


private:
    boost::shared_ptr<Font>
                      m_font;           
    Clr               m_border_color;   
    Clr               m_int_color;      
    Clr               m_text_color;     
    Clr               m_hilite_color;   
    Clr               m_sel_text_color; 

    MenuItem          m_menu_data;   

    std::vector<Rect> m_open_levels; 
    std::vector<int>  m_caret;       

    const Pt          m_origin;         
    MenuItem*         m_item_selected;  
};

} // namespace GG

// template implemetations
template <class T1, class T2>
GG::MenuItem::MenuItem(const std::string& str, int id, bool disable, bool check, void (T1::* slot)(int), T2* obj) :
    SelectedIDSignal(new SelectedIDSignalType()),
    SelectedSignal(new SelectedSignalType()),
    label(str), 
    item_ID(id), 
    disabled(disable), 
    checked(check)
{
    SelectedIDSignal->connect(boost::bind(slot, obj, _1));
}

template <class T1, class T2>
GG::MenuItem::MenuItem(const std::string& str, int id, bool disable, bool check, void (T1::* slot)(), T2* obj) :
    SelectedIDSignal(new SelectedIDSignalType()),
    SelectedSignal(new SelectedSignalType()),
    label(str), 
    item_ID(id), 
    disabled(disable), 
    checked(check)
{
    SelectedSignal->connect(boost::bind(slot, obj));
}

template <class Archive>
void GG::MenuItem::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(label)
        & BOOST_SERIALIZATION_NVP(item_ID)
        & BOOST_SERIALIZATION_NVP(disabled)
        & BOOST_SERIALIZATION_NVP(checked)
        & BOOST_SERIALIZATION_NVP(next_level);
}

template <class Archive>
void GG::MenuBar::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & BOOST_SERIALIZATION_NVP(m_font)
        & BOOST_SERIALIZATION_NVP(m_border_color)
        & BOOST_SERIALIZATION_NVP(m_int_color)
        & BOOST_SERIALIZATION_NVP(m_text_color)
        & BOOST_SERIALIZATION_NVP(m_hilite_color)
        & BOOST_SERIALIZATION_NVP(m_sel_text_color)
        & BOOST_SERIALIZATION_NVP(m_menu_data)
        & BOOST_SERIALIZATION_NVP(m_menu_labels)
        & BOOST_SERIALIZATION_NVP(m_caret);
}

#endif // _GG_Menu_h_

---