TextControl.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_TextControl_h_
#define _GG_TextControl_h_

#include <GG/Control.h>
#include <GG/Font.h>

#include <boost/lexical_cast.hpp>


namespace GG {

class GG_API TextControl : public Control
{
public:
    using Wnd::SetMinSize;
 
    TextControl(int x, int y, int w, int h, const std::string& str, const boost::shared_ptr<Font>& font, Clr color = CLR_BLACK, Flags<TextFormat> format = FORMAT_NONE, Flags<WndFlag> flags = Flags<WndFlag>()); 

    TextControl(int x, int y, const std::string& str, const boost::shared_ptr<Font>& font, Clr color = CLR_BLACK, Flags<TextFormat> format = FORMAT_NONE, Flags<WndFlag> flags = Flags<WndFlag>());
 
    virtual Pt        MinUsableSize() const;

    Flags<TextFormat> GetTextFormat() const;

    Clr               TextColor() const;

    bool              ClipText() const;

    bool              SetMinSize() const;

    template <class T> void operator>>(T& t) const;

    template <class T> T GetValue() const;

    operator const std::string&() const; 

    bool  Empty() const;   
    int   Length() const;  

    Pt    TextUpperLeft() const;

    Pt    TextLowerRight() const;
 
    virtual void Render();

    virtual void   SetText(const std::string& str);
    virtual void   SetText(const char* str);
    virtual void   SizeMove(const Pt& ul, const Pt& lr);
    void           SetTextFormat(Flags<TextFormat> format); 
    void           SetTextColor(Clr color);      
    virtual void   SetColor(Clr c);              
    void           ClipText(bool b);             
    void           SetMinSize(bool b);           

    template <class T> void operator<<(T t);

    void  operator+=(const std::string& str); 
    void  operator+=(const char* str);        
    void  operator+=(char ch);                
    void  Clear();                            
    void  Insert(int pos, char ch);           
    void  Erase(int pos, int num = 1);        

    virtual void DefineAttributes(WndEditor* editor);

protected: 
    TextControl(); 

 
    const std::vector<Font::LineData>&  GetLineData() const;
    const boost::shared_ptr<Font>&      GetFont() const;
    bool                                FitToText() const;
    bool                                DirtyLoad() const;

private:
    void ValidateFormat();      
    void AdjustMinimumSize();
    void RecomputeTextBounds(); 

    Flags<TextFormat>           m_format;      
    Clr                         m_text_color;  
    bool                        m_clip_text;
    bool                        m_set_min_size;
    std::vector<Font::LineData> m_line_data;
    boost::shared_ptr<Font>     m_font;
    bool                        m_fit_to_text; 
    Pt                          m_text_ul;     
    Pt                          m_text_lr;     

    friend class boost::serialization::access;
    template <class Archive>
    void serialize(Archive& ar, const unsigned int version);
    // true iff the object has just been loaded from a serialized form, meaning changes may have been made that leave
    // the control in an inconsistent state; this must be remedied the next time Render() is called
    bool m_dirty_load;
};

} // namespace GG

// template implementations
template <class T>
void GG::TextControl::operator>>(T& t) const
{
    try {
        t = boost::lexical_cast<T>(Control::m_text);
    } catch (boost::bad_lexical_cast) {
        t = T();
    }
}

template <class T>
T GG::TextControl::GetValue() const
{
    return boost::lexical_cast<T, std::string>(Control::m_text);
}

template <class T>
void GG::TextControl::operator<<(T t)
{
    SetText(boost::lexical_cast<std::string>(t));
}

template <class Archive>
void GG::TextControl::serialize(Archive& ar, const unsigned int version)
{
    ar  & BOOST_SERIALIZATION_BASE_OBJECT_NVP(Control)
        & BOOST_SERIALIZATION_NVP(m_format)
        & BOOST_SERIALIZATION_NVP(m_text_color)
        & BOOST_SERIALIZATION_NVP(m_clip_text)
        & BOOST_SERIALIZATION_NVP(m_set_min_size)
        & BOOST_SERIALIZATION_NVP(m_line_data)
        & BOOST_SERIALIZATION_NVP(m_font)
        & BOOST_SERIALIZATION_NVP(m_fit_to_text)
        & BOOST_SERIALIZATION_NVP(m_text_ul)
        & BOOST_SERIALIZATION_NVP(m_text_lr);

    if (Archive::is_loading::value) {
        ValidateFormat();
        m_dirty_load = true;
    }
}

#endif // _GG_TextControl_h_

---