ColorDlg.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_ColorDlg_h_
#define _GG_ColorDlg_h_

#include <GG/Button.h>


namespace GG {

class Font;
class Slider;
    
struct GG_API HSVClr
{
    HSVClr(); 
    HSVClr(double h_, double s_, double v_, GLubyte a_ = 255); 
    double  h;   
    double  s;   
    double  v;   
    GLubyte a;   

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

class GG_API HueSaturationPicker : public Control
{
public: 
    typedef boost::signal<void (double, double)> ChangedSignalType; 

 
    typedef ChangedSignalType::slot_type         ChangedSlotType;   

 
    HueSaturationPicker(int x, int y, int w, int h); 

 
    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);

    void SetHueSaturation(double hue, double saturation); 


    mutable ChangedSignalType ChangedSignal; 

protected: 
    HueSaturationPicker(); 


private:
    void SetHueSaturationFromPt(Pt pt);

    double m_hue;
    double m_saturation;
    std::vector<std::vector<std::pair<double, double> > >  m_vertices;
    std::vector<std::vector<Clr> > m_colors;

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


class GG_API ValuePicker : public Control
{
public: 
    typedef boost::signal<void (double)> ChangedSignalType; 

 
    typedef ChangedSignalType::slot_type ChangedSlotType;   

 
    ValuePicker(int x, int y, int w, int h, Clr arrow_color); 

 
    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);

    void SetHueSaturation(double hue, double saturation);
    void SetValue(double value); 


    mutable ChangedSignalType ChangedSignal; 

protected: 
    ValuePicker(); 


private:
    void SetValueFromPt(Pt pt);

    double  m_hue;
    double  m_saturation;
    double  m_value;

    Clr m_arrow_color;

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


class GG_API ColorDlg : public Wnd
{
public:
    class GG_API ColorButton : public Button
    {
    public: 
        ColorButton(const Clr& color);
 

        Clr RepresentedColor() const;
 

        void SetRepresentedColor(const Clr& color);

    protected: 
        ColorButton(); 

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

    private:
        Clr m_represented_color;

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

    class GG_API ColorDisplay : public Control
    {
    public: 
        ColorDisplay(Clr color); 

 
        virtual void Render();

    protected: 
        ColorDisplay(); 


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

    ColorDlg(int x, int y, const boost::shared_ptr<Font>& font,
             Clr dialog_color, Clr border_color, Clr text_color = CLR_BLACK);

    ColorDlg(int x, int y, Clr original_color, const boost::shared_ptr<Font>& font,
             Clr dialog_color, Clr border_color, Clr text_color = CLR_BLACK);
 

    bool ColorWasSelected() const;

    Clr Result() const;

    const std::string& NewString(const std::string& str) const;        
    const std::string& OldString(const std::string& str) const;        
    const std::string& RedString(const std::string& str) const;        
    const std::string& GreenString(const std::string& str) const;      
    const std::string& BlueString(const std::string& str) const;       
    const std::string& HueString(const std::string& str) const;        
    const std::string& SaturationString(const std::string& str) const; 
    const std::string& ValueString(const std::string& str) const;      
    const std::string& AlphaString(const std::string& str) const;      
    const std::string& OkString(const std::string& str) const;         
    const std::string& CancelString(const std::string& str) const;     

 
    void SetNewString(const std::string& str);        
    void SetOldString(const std::string& str);        
    void SetRedString(const std::string& str);        
    void SetGreenString(const std::string& str);      
    void SetBlueString(const std::string& str);       
    void SetHueString(const std::string& str);        
    void SetSaturationString(const std::string& str); 
    void SetValueString(const std::string& str);      
    void SetAlphaString(const std::string& str);      
    void SetOkString(const std::string& str);         
    void SetCancelString(const std::string& str);     

    virtual void Render();
    virtual void KeyPress(Key key, Flags<ModKey> mod_keys);

protected: 
    ColorDlg(); 


private:
    struct ColorButtonClickFunctor
    {
        ColorButtonClickFunctor(int id, ColorDlg* picker_);
        void operator()();
        const int button_id;
        ColorDlg* picker;
    };

    enum {R, G, B, A, H, S, V};

    void Init(const boost::shared_ptr<Font>& font);
    void ConnectSignals();
    void ColorChanged(HSVClr color);
    void HueSaturationPickerChanged(double hue, double saturation);
    void ValuePickerChanged(double value);
    void UpdateRGBSliders();
    void UpdateHSVSliders();
    void ColorChangeFromRGBSlider();
    void ColorButtonClicked(int i);
    void RedSliderChanged(int value, int low, int high);
    void GreenSliderChanged(int value, int low, int high);
    void BlueSliderChanged(int value, int low, int high);
    void AlphaSliderChanged(int value, int low, int high);
    void HueSliderChanged(int value, int low, int high);
    void SaturationSliderChanged(int value, int low, int high);
    void ValueSliderChanged(int value, int low, int high);
    void OkClicked();
    void CancelClicked();

    HSVClr                    m_current_color;
    Clr                       m_original_color;
    bool                      m_original_color_specified;
    bool                      m_color_was_picked;

    std::string               m_new_str;
    std::string               m_old_str;
    std::string               m_red_str;
    std::string               m_green_str;
    std::string               m_blue_str;
    std::string               m_hue_str;
    std::string               m_saturation_str;
    std::string               m_value_str;
    std::string               m_alpha_str;
    std::string               m_ok_str;
    std::string               m_cancel_str;

    HueSaturationPicker*      m_hue_saturation_picker;
    ValuePicker*              m_value_picker;
    Layout*                   m_pickers_layout;
    ColorDisplay*             m_new_color_square;
    ColorDisplay*             m_old_color_square;
    TextControl*              m_new_color_square_text;
    TextControl*              m_old_color_square_text;
    Layout*                   m_color_squares_layout;
    std::vector<ColorButton*> m_color_buttons;
    Layout*                   m_color_buttons_layout;
    int                       m_current_color_button;
    std::vector<TextControl*> m_slider_labels;
    std::vector<TextControl*> m_slider_values;
    std::vector<Slider*>      m_sliders;
    bool                      m_ignore_sliders;
    Button*                   m_ok;
    Button*                   m_cancel;
    Layout*                   m_sliders_ok_cancel_layout;

    Clr                       m_color;
    Clr                       m_border_color;
    Clr                       m_text_color;

    static std::vector<Clr>   s_custom_colors;

    friend struct ColorButtonClickFunctor;

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

} // namespace GG

// template implementations
template <class Archive>
void GG::HSVClr::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_NVP(h)
        & BOOST_SERIALIZATION_NVP(s)
        & BOOST_SERIALIZATION_NVP(v)
        & BOOST_SERIALIZATION_NVP(a);
}

template <class Archive>
void GG::HueSaturationPicker::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & BOOST_SERIALIZATION_NVP(m_hue)
        & BOOST_SERIALIZATION_NVP(m_saturation)
        & BOOST_SERIALIZATION_NVP(m_vertices)
        & BOOST_SERIALIZATION_NVP(m_colors);
}

template <class Archive>
void GG::ValuePicker::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & BOOST_SERIALIZATION_NVP(m_hue)
        & BOOST_SERIALIZATION_NVP(m_saturation)
        & BOOST_SERIALIZATION_NVP(m_value)
        & BOOST_SERIALIZATION_NVP(m_arrow_color);
}

template <class Archive>
void GG::ColorDlg::ColorButton::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Button)
        & BOOST_SERIALIZATION_NVP(m_represented_color);
}

template <class Archive>
void GG::ColorDlg::ColorDisplay::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control);
}

template <class Archive>
void GG::ColorDlg::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Wnd)
        & BOOST_SERIALIZATION_NVP(m_current_color)
        & BOOST_SERIALIZATION_NVP(m_original_color)
        & BOOST_SERIALIZATION_NVP(m_original_color_specified)
        & BOOST_SERIALIZATION_NVP(m_color_was_picked)
        & BOOST_SERIALIZATION_NVP(m_new_str)
        & BOOST_SERIALIZATION_NVP(m_old_str)
        & BOOST_SERIALIZATION_NVP(m_red_str)
        & BOOST_SERIALIZATION_NVP(m_green_str)
        & BOOST_SERIALIZATION_NVP(m_blue_str)
        & BOOST_SERIALIZATION_NVP(m_hue_str)
        & BOOST_SERIALIZATION_NVP(m_saturation_str)
        & BOOST_SERIALIZATION_NVP(m_value_str)
        & BOOST_SERIALIZATION_NVP(m_alpha_str)
        & BOOST_SERIALIZATION_NVP(m_ok_str)
        & BOOST_SERIALIZATION_NVP(m_cancel_str)
        & BOOST_SERIALIZATION_NVP(m_hue_saturation_picker)
        & BOOST_SERIALIZATION_NVP(m_value_picker)
        & BOOST_SERIALIZATION_NVP(m_pickers_layout)
        & BOOST_SERIALIZATION_NVP(m_new_color_square)
        & BOOST_SERIALIZATION_NVP(m_old_color_square)
        & BOOST_SERIALIZATION_NVP(m_new_color_square_text)
        & BOOST_SERIALIZATION_NVP(m_old_color_square_text)
        & BOOST_SERIALIZATION_NVP(m_color_squares_layout)
        & BOOST_SERIALIZATION_NVP(m_color_buttons)
        & BOOST_SERIALIZATION_NVP(m_color_buttons_layout)
        & BOOST_SERIALIZATION_NVP(m_current_color_button)
        & BOOST_SERIALIZATION_NVP(m_slider_labels)
        & BOOST_SERIALIZATION_NVP(m_slider_values)
        & BOOST_SERIALIZATION_NVP(m_sliders)
        & BOOST_SERIALIZATION_NVP(m_ignore_sliders)
        & BOOST_SERIALIZATION_NVP(m_ok)
        & BOOST_SERIALIZATION_NVP(m_cancel)
        & BOOST_SERIALIZATION_NVP(m_sliders_ok_cancel_layout)
        & BOOST_SERIALIZATION_NVP(m_color)
        & BOOST_SERIALIZATION_NVP(m_border_color)
        & BOOST_SERIALIZATION_NVP(m_text_color);

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

#endif // _GG_ColorDlg_h_

---