Button.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_Button_h_
#define _GG_Button_h_

#include <GG/TextControl.h>

#include <boost/serialization/version.hpp>


namespace GG {

class GG_API Button : public TextControl
{
public:
    enum ButtonState {
        BN_PRESSED,    
        BN_UNPRESSED,  
        BN_ROLLOVER    
    };
 
    typedef boost::signal<void ()> ClickedSignalType; 

 
    typedef ClickedSignalType::slot_type ClickedSlotType; 

 
    Button(int x, int y, int w, int h, const std::string& str, const boost::shared_ptr<Font>& font, Clr color,
           Clr text_color = CLR_BLACK, Flags<WndFlag> flags = CLICKABLE); 

 

    ButtonState       State() const;

    const SubTexture& UnpressedGraphic() const; 
    const SubTexture& PressedGraphic() const;   
    const SubTexture& RolloverGraphic() const;  

    mutable ClickedSignalType ClickedSignal; 

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

    virtual void   SetColor(Clr c); 

    void           SetState(ButtonState state);

    void           SetUnpressedGraphic(const SubTexture& st); 
    void           SetPressedGraphic(const SubTexture& st);   
    void           SetRolloverGraphic(const SubTexture& st);  

    virtual void   DefineAttributes(WndEditor* editor);

protected: 
    Button(); 

 
    virtual void   RenderUnpressed();   
    virtual void   RenderPressed();     
    virtual void   RenderRollover();    


private:
    void           RenderDefault();     

    ButtonState    m_state;             

    SubTexture     m_unpressed_graphic; 
    SubTexture     m_pressed_graphic;   
    SubTexture     m_rollover_graphic;  

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

// define EnumMap and stream operators for Button::ButtonState
GG_ENUM_MAP_BEGIN(Button::ButtonState)
    GG_ENUM_MAP_INSERT(Button::BN_PRESSED)
    GG_ENUM_MAP_INSERT(Button::BN_UNPRESSED)
    GG_ENUM_MAP_INSERT(Button::BN_ROLLOVER)
GG_ENUM_MAP_END

GG_ENUM_STREAM_IN(Button::ButtonState)
GG_ENUM_STREAM_OUT(Button::ButtonState)


class GG_API StateButton : public TextControl
{
public: 
    typedef boost::signal<void (bool)> CheckedSignalType; 

 
    typedef CheckedSignalType::slot_type CheckedSlotType; 

 
    StateButton(int x, int y, int w, int h, const std::string& str, const boost::shared_ptr<Font>& font, Flags<TextFormat> format, 
                Clr color, Clr text_color = CLR_BLACK, Clr interior = CLR_ZERO, StateButtonStyle style = SBSTYLE_3D_XBOX,
                Flags<WndFlag> flags = CLICKABLE); 

 
    virtual Pt       MinUsableSize() const;

    bool             Checked() const;       
    Clr              InteriorColor() const; 

    StateButtonStyle Style() const;

    mutable CheckedSignalType CheckedSignal; 

 
    virtual void     Render();
    virtual void     LClick(const Pt& pt, Flags<ModKey> mod_keys);
    virtual void     SizeMove(const Pt& ul, const Pt& lr);

    void             Reset();                 
    void             SetCheck(bool b = true); 
    void             SetButtonPosition(const Pt& ul, const Pt& lr); 
    void             SetDefaultButtonPosition(); 
    virtual void     SetColor(Clr c);         
    void             SetInteriorColor(Clr c); 

    void             SetStyle(StateButtonStyle bs);

    virtual void     DefineAttributes(WndEditor* editor);

protected: 
    StateButton(); 

 
    Pt  ButtonUpperLeft() const;  
    Pt  ButtonLowerRight() const; 
    Pt  TextUpperLeft() const;    

 
    void RepositionButton();      


private:
    bool              m_checked;     
    Clr               m_int_color;   
    StateButtonStyle  m_style;       

    Pt                m_button_ul;
    Pt                m_button_lr;
    Pt                m_text_ul;

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


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

 
    typedef ButtonChangedSignalType::slot_type ButtonChangedSlotType; 

 
    RadioButtonGroup(int x, int y, int w, int h, Orientation orientation); 

 
    virtual Pt       MinUsableSize() const;

    Orientation      GetOrientation() const;

    int              NumButtons() const;

    int              CheckedButton() const;

    bool             ExpandButtons() const;

    bool             ExpandButtonsProportionally() const;

    bool             RenderOutline() const;

    mutable ButtonChangedSignalType ButtonChangedSignal; 

 
    virtual void Render();

    void SetCheck(int index);

    void DisableButton(int index, bool b = true); 

    void AddButton(StateButton* bn);

    void AddButton(const std::string& text, const boost::shared_ptr<Font>& font, Flags<TextFormat> format,
                   Clr color, Clr text_color = CLR_BLACK, Clr interior = CLR_ZERO,
                   StateButtonStyle style = SBSTYLE_3D_RADIO);

    void InsertButton(int index, StateButton* bn);

    void InsertButton(int index, const std::string& text, const boost::shared_ptr<Font>& font, Flags<TextFormat> format,
                      Clr color, Clr text_color = CLR_BLACK, Clr interior = CLR_ZERO,
                      StateButtonStyle style = SBSTYLE_3D_RADIO);

    void RemoveButton(StateButton* button);

    void ExpandButtons(bool expand);

    void ExpandButtonsProportionally(bool proportional);

    void RenderOutline(bool render_outline);

    void RaiseCheckedButton();

    virtual void DefineAttributes(WndEditor* editor);

    static const int NO_BUTTON;

protected:
    struct GG_API ButtonSlot
    {
        ButtonSlot();
        ButtonSlot(StateButton* button_);
        StateButton*               button;
        boost::signals::connection connection;

        template <class Archive>
        void serialize(Archive& ar, const unsigned int version);
    };
 
    RadioButtonGroup(); 

 
    const std::vector<ButtonSlot>& ButtonSlots() const; 


private:
    class ButtonClickedFunctor // for catching button-click signals from the contained buttons
    {
    public:
        ButtonClickedFunctor(RadioButtonGroup* group, StateButton* button, int index);
        void operator()(bool checked);
    private:
        RadioButtonGroup* m_group;
        StateButton*      m_button;
        int               m_index;
        bool              m_ignore_clicks;
    };

    void ConnectSignals();
    void HandleRadioClick(int index, bool set_check);
    void Reconnect();

    const Orientation       m_orientation;
    std::vector<ButtonSlot> m_button_slots;
    int                     m_checked_button; 
    bool                    m_expand_buttons;
    bool                    m_expand_buttons_proportionally;
    bool                    m_render_outline;

    friend class ButtonClickedFunctor;

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

} // namespace GG

BOOST_CLASS_VERSION(GG::RadioButtonGroup, 1)

// template implementations
template <class Archive>
void GG::Button::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(TextControl)
        & BOOST_SERIALIZATION_NVP(m_state)
        & BOOST_SERIALIZATION_NVP(m_unpressed_graphic)
        & BOOST_SERIALIZATION_NVP(m_pressed_graphic)
        & BOOST_SERIALIZATION_NVP(m_rollover_graphic);
}

template <class Archive>
void GG::StateButton::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(TextControl)
        & BOOST_SERIALIZATION_NVP(m_checked)
        & BOOST_SERIALIZATION_NVP(m_int_color)
        & BOOST_SERIALIZATION_NVP(m_style)
        & BOOST_SERIALIZATION_NVP(m_button_ul)
        & BOOST_SERIALIZATION_NVP(m_button_lr)
        & BOOST_SERIALIZATION_NVP(m_text_ul);
}

template <class Archive>
void GG::RadioButtonGroup::ButtonSlot::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(button);
}

template <class Archive>
void GG::RadioButtonGroup::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & boost::serialization::make_nvp("m_orientation", const_cast<Orientation&>(m_orientation));

    if (version == 0) {
        std::vector<StateButton*> m_buttons;
        if (Archive::is_saving::value) {
            m_buttons.resize(m_button_slots.size());
            for (unsigned int i = 0; i < m_button_slots.size(); ++i) {
                m_buttons[i] = m_button_slots[i].button;
            }
        }
        ar  & BOOST_SERIALIZATION_NVP(m_buttons);
        if (Archive::is_loading::value) {
            m_button_slots.resize(m_buttons.size());
            for (unsigned int i = 0; i < m_buttons.size(); ++i) {
                m_button_slots[i].button = m_buttons[i];
            }
        }
    } else {
        ar  & BOOST_SERIALIZATION_NVP(m_button_slots)
            & BOOST_SERIALIZATION_NVP(m_expand_buttons)
            & BOOST_SERIALIZATION_NVP(m_expand_buttons_proportionally);
    }

    ar  & BOOST_SERIALIZATION_NVP(m_checked_button)
        & BOOST_SERIALIZATION_NVP(m_render_outline);

    if (Archive::is_loading::value)
        ConnectSignals();
}

#endif // _GG_Button_h_

---