src/tron/cockpit/cWidgetBase.h

Go to the documentation of this file.

/*

*************************************************************************

ArmageTron -- Just another Tron Lightcycle Game in 3D.
Copyright (C) 2000  Manuel Moos (manuel@moosnet.de)

**************************************************************************

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 2
of the License, or (at your option) any later version.

This program 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 General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA  02110-1301, USA.

***************************************************************************

*/

#ifndef ARMAGETRON_WIDGET_BASE_H
#define ARMAGETRON_WIDGET_BASE_H

#include "tValue.h"

#ifndef DEDICATED

#include "tString.h"
#include "tXmlParser.h"
#define DONTDOIT
#include "rGradient.h"
#include "rTexture.h"
#include <memory>
#include "tSafePTR.h"

class cCockpit;


namespace cWidget {

class Base : public tReferencable<Base> {
    int m_Cam; 
    bool m_ParsingTemplate;
protected:
    void DisplayError(tXmlParser::node cur); 
    bool m_Render; 
    bool m_RenderDefault; 
    bool m_Sticky; 
    cCockpit *m_Cockpit; 
public:
    Base() : m_ParsingTemplate(false), m_Render(true), m_RenderDefault(true), m_Sticky(true) {}
    virtual ~Base() { }
    virtual void Render() = 0; 
    void SetCam(int Cam); 

    int GetCam(void) { return m_Cam; } 
    virtual bool Process(tXmlParser::node cur); 
    void SetDefaultState (bool state) { m_Render = m_RenderDefault = state; }
    void SetCockpit(cCockpit *cockpit) {m_Cockpit = cockpit;} 
    void SetSticky (bool sticky) { m_Sticky = sticky; }
    bool Active() { return m_Render; } 

    void Toggle(bool state) {
        if(m_Sticky) {
            if(state) {
                m_Render = !m_Render;
            }
        } else {
            m_Render = state;
        }
    }
    virtual void HandleEvent(bool state, int id) { Toggle(state); }
    void ParseTemplate(bool state) {m_ParsingTemplate = state;}
};

typedef std::auto_ptr<Base> Base_ptr; 

class WithCoordinates : virtual public Base {
    tCoord m_originalPosition; 
    tCoord m_originalSize; 
protected:
    tCoord m_position; 
    tCoord m_size; 
public:
    WithCoordinates(); 
    bool Process(tXmlParser::node cur); 
    void SetFactor(float factor); 
};

class WithDataFunctions : virtual public Base {
    tValue::Base *ProcessValue(tXmlParser::node cur); 
    tValue::Base *ProcessMath(tXmlParser::node cur); 
    tValue::Base *ProcessConditionalCore(tXmlParser::node cur); 
    tValue::Base *ProcessConditional(tXmlParser::node cur); 
    tValue::Base *ProcessAtomicData(tXmlParser::node cur); 
    void          ProcessDataTags(tXmlParser::node cur, tValue::Base &data); 
    tValue::Base *ProcessDataSource(tString const &data); 
protected:
    tValue::Set ProcessDataSet(tXmlParser::node cur); 
public:
    bool Process(tXmlParser::node cur);
};

class WithSingleData : virtual public WithDataFunctions {
protected:
    tValue::Set m_data; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithIdData : virtual public WithDataFunctions {
protected:
    std::map<tString, tValue::Set> m_data; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithTable : virtual public WithIdData {
    void ProcessCore(tXmlParser::node cur);  
    void ProcessTable(tXmlParser::node cur); 
    void ProcessRow(tXmlParser::node cur);   
    void ProcessCell(tXmlParser::node cur);  
protected:
    //TODO: make this a real table- oriented structure

    std::deque<std::deque<std::deque<tValue::Set> > > m_table; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithColorFunctions : virtual public Base {
protected:
    rGradient ProcessGradient(tXmlParser::node cur); 
    void ProcessGradientCore(tXmlParser::node cur, rGradient &gradient); 
    void ProcessImage(tXmlParser::node cur, rGradient &gradient, int repeat); 
public:
    bool Process(tXmlParser::node cur); 
};

class WithForeground : virtual public WithColorFunctions {
protected:
    rGradient m_foreground; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithBackground : virtual public WithColorFunctions {
protected:
    rGradient m_background; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithLineColor : virtual public WithColorFunctions {
protected:
    rGradient m_line_color; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithCaption : virtual public Base{
    void ProcessCaption(tXmlParser::node cur); 
    void ProcessCaptionLocation(tXmlParser::node cur); 
protected:
    enum location { 
        top,
        bottom,
        off
    };
    tString m_caption; 
    int m_captionloc; 
    WithCaption() : Base(), m_captionloc(off) {}; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithReverse : virtual public Base{
protected:
    bool m_reverse; 
    WithReverse() : m_reverse(false){}; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithAngles : virtual public Base{
protected:
    float m_angle_min; 
    float m_angle_max; 
    WithAngles() : m_angle_min(0), m_angle_max(M_PI){}; 
public:
    bool Process(tXmlParser::node cur); 
};

class WithShowSettings : virtual public Base{
protected:
    bool m_showmin; 
    bool m_showmax; 
    bool m_showvalue; 
    WithShowSettings() : m_showmin(true), m_showmax(true), m_showvalue(true) {}; 
public:
    bool Process(tXmlParser::node cur); 

};

}

#endif
#endif

---