GUI.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_GUI_h_
#define _GG_GUI_h_

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


namespace boost { namespace archive {
    class xml_oarchive;
    class xml_iarchive;
} }

namespace GG {

class Cursor;
class Wnd;
class EventPumpBase;
class ModalEventPump;
class PluginInterface;
class StyleFactory;
class Texture;
class Timer;
struct GUIImpl;

class GG_API GUI
{
private:
    struct OrCombiner 
    {
        typedef bool result_type; 
        template<class InIt> bool operator()(InIt first, InIt last) const;
    };

public: 

    typedef boost::signal<bool (), OrCombiner> AcceleratorSignalType;
 
    typedef AcceleratorSignalType::slot_type   AcceleratorSlotType; 


    enum EventType {
        IDLE,        
        KEYPRESS,    
        KEYRELEASE,  
        LPRESS,      
        MPRESS,      
        RPRESS,      
        LRELEASE,    
        MRELEASE,    
        RRELEASE,    
        MOUSEMOVE,   
        MOUSEWHEEL   
    };

    typedef std::set<std::pair<Key, Flags<ModKey> > >::const_iterator const_accel_iterator; 

    typedef void (*SaveWndFn)(const Wnd* wnd, const std::string& name, boost::archive::xml_oarchive& ar);

    typedef void (*LoadWndFn)(Wnd*& wnd, const std::string& name, boost::archive::xml_iarchive& ar);
 
    virtual ~GUI(); 

 
    const std::string&
                   AppName() const;                    
    Wnd*           FocusWnd() const;                   
    Wnd*           GetWindowUnder(const Pt& pt) const; 
    int            DeltaT() const;                     
    virtual int    Ticks() const = 0;                  
    bool           RenderingDragDropWnds() const;      
    bool           FPSEnabled() const;                 
    double         FPS() const;                        
    std::string    FPSString() const;                  
    double         MaxFPS() const;                     
    virtual int    AppWidth() const = 0;               
    virtual int    AppHeight() const = 0;              
    int            ButtonDownRepeatDelay() const;      
    int            ButtonDownRepeatInterval() const;   
    int            DoubleClickInterval() const;        
    int            MinDragTime() const;                
    int            MinDragDistance() const;            
    bool           DragDropWnd(const Wnd* wnd) const;  
    bool           MouseButtonDown(int bn) const;      
    Pt             MousePosition() const;              
    Pt             MouseMovement() const;              
    Flags<ModKey>  ModKeys() const;                    

    virtual std::set<std::pair<int, int> > FindWords(const std::string& str) const;

    const boost::shared_ptr<StyleFactory>& GetStyleFactory() const; 

    bool                                   RenderCursor() const; 
    const boost::shared_ptr<Cursor>&       GetCursor() const; 

    const_accel_iterator accel_begin() const;    
    const_accel_iterator accel_end() const;      

    AcceleratorSignalType& AcceleratorSignal(Key key, Flags<ModKey> mod_keys = MOD_KEY_NONE) const;
 
    void           operator()();                 
    virtual void   Exit(int code) = 0;           

    virtual void   HandleSystemEvents() = 0;
    void           HandleGGEvent(EventType event, Key key, Flags<ModKey> mod_keys, const Pt& pos, const Pt& rel); 

    void           SetFocusWnd(Wnd* wnd);        
    virtual void   Wait(int ms);                 
    void           Register(Wnd* wnd);           
    void           RegisterModal(Wnd* wnd);      
    void           Remove(Wnd* wnd);             
    void           WndDying(Wnd* wnd);           
    void           MoveUp(Wnd* wnd);             
    void           MoveDown(Wnd* wnd);           

    virtual boost::shared_ptr<ModalEventPump>
                   CreateModalEventPump(bool& done); 

    void           RegisterDragDropWnd(Wnd* wnd, const Pt& offset, Wnd* originating_wnd);
    void           CancelDragDrop();             

    void           RegisterTimer(Timer& timer);  
    void           RemoveTimer(Timer& timer);    

    virtual void   Enter2DMode() = 0;            
    virtual void   Exit2DMode() = 0;             
    void           EnableFPS(bool b = true);     
    void           SetMaxFPS(double max);        
    void           EnableMouseButtonDownRepeat(int delay, int interval); 
    void           SetDoubleClickInterval(int interval); 
    void           SetMinDragTime(int time);     
    void           SetMinDragDistance(int distance); 

    void           SetAccelerator(Key key, Flags<ModKey> mod_keys = MOD_KEY_NONE);

    void           RemoveAccelerator(Key key, Flags<ModKey> mod_keys = MOD_KEY_NONE);

    boost::shared_ptr<Font>    GetFont(const std::string& font_filename, int pts, unsigned int range = Font::ALL_CHARS); 
    void                       FreeFont(const std::string& font_filename, int pts); 

    boost::shared_ptr<Texture> StoreTexture(Texture* texture, const std::string& texture_name);

    boost::shared_ptr<Texture> StoreTexture(const boost::shared_ptr<Texture> &texture, const std::string& texture_name); 
    boost::shared_ptr<Texture> GetTexture(const std::string& name, bool mipmap = false); 
    void                       FreeTexture(const std::string& name); 

    void SetStyleFactory(const boost::shared_ptr<StyleFactory>& factory); 

    void RenderCursor(bool render); 
    void SetCursor(const boost::shared_ptr<Cursor>& cursor); 

    void SaveWnd(const Wnd* wnd, const std::string& name, boost::archive::xml_oarchive& ar);

    void LoadWnd(Wnd*& wnd, const std::string& name, boost::archive::xml_iarchive& ar);

    template <class T>
    void LoadWnd(T*& wnd, const std::string& name, boost::archive::xml_iarchive& ar);

    void SetSaveWndFunction(SaveWndFn fn); 
    void SetLoadWndFunction(LoadWndFn fn); 

    void SetSaveLoadFunctions(const PluginInterface& interface);

    static GUI*  GetGUI();                
    static void  RenderWindow(Wnd* wnd);  
 

    GG_ABSTRACT_EXCEPTION(Exception);

    GG_CONCRETE_EXCEPTION(BadFunctionPointer, GG::GUI, Exception);

protected: 
    GUI(const std::string& app_name); 

 
    void           ProcessBrowseInfo();    
    virtual void   RenderBegin() = 0;      
    virtual void   Render();               
    virtual void   RenderEnd() = 0;        

    // EventPumpBase interface
    void SetFPS(double FPS);               
    void SetDeltaT(int delta_t);           


    virtual void   Run() = 0;              

private:
    bool           ProcessBrowseInfoImpl(Wnd* wnd);
    Wnd*           ModalWindow() const;    // returns the current modal window, if any

    // returns the window under \a pt, sending Mouse{Enter|Leave} or DragDrop{Enter|Leave} as appropriate
    Wnd*           CheckedGetWindowUnder(const Pt& pt, Flags<ModKey> mod_keys);

    static GUI*                       s_gui;
    static boost::shared_ptr<GUIImpl> s_impl;

    friend class EventPumpBase; 
    friend struct GUIImpl;
};


GG_API bool MatchesOrContains(const Wnd* lwnd, const Wnd* rwnd);


// template implementations
template<class InIt> 
bool GUI::OrCombiner::operator()(InIt first, InIt last) const
{
    bool retval = false;
    while (first != last)
        retval |= static_cast<bool>(*first++);
    return retval;
}

template <class T>
void GUI::LoadWnd(T*& wnd, const std::string& name, boost::archive::xml_iarchive& ar)
{
    Wnd* wnd_as_base = wnd;
    LoadWnd(wnd_as_base, name, ar);
    wnd = dynamic_cast<T*>(wnd_as_base);
    assert(wnd || !wnd_as_base);
}

} // namespace GG

#endif // _GG_GUI_h_

---