Dimensions.h

/***********************************************************************
    created:    Mon Jun 13 2005
    author:     Paul D Turner <paul@cegui.org.uk>
*************************************************************************/
/***************************************************************************
 *   Copyright (C) 2004 - 2012 Paul D Turner & The CEGUI Development Team
 *
 *   Permission is hereby granted, free of charge, to any person obtaining
 *   a copy of this software and associated documentation files (the
 *   "Software"), to deal in the Software without restriction, including
 *   without limitation the rights to use, copy, modify, merge, publish,
 *   distribute, sublicense, and/or sell copies of the Software, and to
 *   permit persons to whom the Software is furnished to do so, subject to
 *   the following conditions:
 *
 *   The above copyright notice and this permission notice shall be
 *   included in all copies or substantial portions of the Software.
 *
 *   THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
 *   EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
 *   MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
 *   IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
 *   OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE,
 *   ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR
 *   OTHER DEALINGS IN THE SOFTWARE.
 ***************************************************************************/
#ifndef _CEGUIFalDimensions_h_
#define _CEGUIFalDimensions_h_

#include "./Enums.h"
#include "../String.h"
#include "../UDim.h"
#include "../Rect.h"
#include "../XMLSerializer.h"

// Start of CEGUI namespace section
namespace CEGUI
{
class CEGUIEXPORT BaseDim :
    public AllocatedObject<BaseDim>
{
public:
    BaseDim();

    virtual ~BaseDim();

    virtual float getValue(const Window& wnd) const = 0;

    virtual float getValue(const Window& wnd, const Rectf& container) const = 0;

    virtual BaseDim* clone() const = 0;

    virtual void writeXMLToStream(XMLSerializer& xml_stream) const;

    virtual bool handleFontRenderSizeChange(Window& window,
                                            const Font* font) const;
protected:
    virtual void writeXMLElementName_impl(XMLSerializer& xml_stream) const = 0;

    virtual void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const = 0;
};

class CEGUIEXPORT OperatorDim : public BaseDim
{
public:
    OperatorDim();
    OperatorDim(DimensionOperator op);
    OperatorDim(DimensionOperator op, BaseDim* left, BaseDim* right);
    ~OperatorDim();

    void setLeftOperand(const BaseDim* operand);

    BaseDim* getLeftOperand() const;

    void setRightOperand(const BaseDim* operand);

    BaseDim* getRightOperand() const;

    void setOperator(DimensionOperator op);

    DimensionOperator getOperator() const;

    void setNextOperand(const BaseDim* operand);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    float getValueImpl(const float lval, const float rval) const;
    // Implementation of the base class interface
    void writeXMLToStream(XMLSerializer& xml_stream) const;
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

    BaseDim* d_left;
    BaseDim* d_right;
    DimensionOperator d_op;
};

class CEGUIEXPORT AbsoluteDim : public BaseDim
{
public:
    AbsoluteDim() {};
    AbsoluteDim(float val);

    float getBaseValue() const;

    void setBaseValue(float val);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    // Implementation of the base class interface
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

private:
    float d_val;
};

class CEGUIEXPORT ImageDimBase : public BaseDim
{
public:
    ImageDimBase() {};

    ImageDimBase(DimensionType dim);

    DimensionType getSourceDimension() const;

    void setSourceDimension(DimensionType dim);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;

protected:
    virtual const Image* getSourceImage(const Window& wnd) const = 0;

    // Implementation of the base class interface
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

    DimensionType d_what;
};

class CEGUIEXPORT ImageDim : public ImageDimBase
{
public:
    ImageDim() {};
    ImageDim(const String& image_name, DimensionType dim);

    const String& getSourceImage() const;
    void setSourceImage(const String& image_name);

    // Implementation of the base class interface
    BaseDim* clone() const;

protected:
    // Implementation / overrides of functions in superclasses
    const Image* getSourceImage(const Window& wnd) const;
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

    String d_imageName;
};

class CEGUIEXPORT ImagePropertyDim : public ImageDimBase
{
public:
    ImagePropertyDim() {};

    ImagePropertyDim(const String& property_name, DimensionType dim);

    const String& getSourceProperty() const;
    void setSourceProperty(const String& property_name);

    // Implementation of the base class interface
    BaseDim* clone() const;

protected:
    // Implementation / overrides of functions in superclasses
    const Image* getSourceImage(const Window& wnd) const;
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

    String d_propertyName;
};

class CEGUIEXPORT WidgetDim : public BaseDim
{
public:
    WidgetDim() {};
    WidgetDim(const String& name, DimensionType dim);

    const String& getWidgetName() const;

    void setWidgetName(const String& name);

    DimensionType getSourceDimension() const;

    void setSourceDimension(DimensionType dim);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    // Implementation of the base class interface
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

private:
    String d_widgetName;
    DimensionType d_what;
};

class CEGUIEXPORT UnifiedDim : public BaseDim
{
public:
    UnifiedDim(){};
    UnifiedDim(const UDim& value, DimensionType dim);

    const UDim& getBaseValue() const;

    void setBaseValue(const UDim& val);

    DimensionType getSourceDimension() const;

    void setSourceDimension(DimensionType dim);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    // Implementation of the base class interface
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

private:
    UDim d_value;
    DimensionType d_what;
};

class CEGUIEXPORT FontDim : public BaseDim
{
public:
    FontDim() {};
    FontDim(const String& name, const String& font, const String& text,
            FontMetricType metric, float padding = 0);

    const String& getName() const;

    void setName(const String& name);

    const String& getFont() const;

    void setFont(const String& font);

    const String& getText() const;

    void setText(const String& text);

    FontMetricType getMetric() const;

    void setMetric(FontMetricType metric);

    float getPadding() const;

    void setPadding(float padding);

    // overridden from BaseDim.
    bool handleFontRenderSizeChange(Window& window,
                                    const Font* font) const;

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    // Implementation of the base class interface
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

    const Font* getFontObject(const Window& window) const;

private:
    String d_font;
    String d_text;
    String d_childName;
    FontMetricType d_metric;
    float d_padding;
};

class CEGUIEXPORT PropertyDim : public BaseDim
{
public:
    PropertyDim() {};
    PropertyDim(const String& name, const String& property, DimensionType type);
    const String& getWidgetName() const;

    void setWidgetName(const String& name);

    const String& getPropertyName() const;

    void setPropertyName(const String& property);

    DimensionType getSourceDimension() const;

    void setSourceDimension(DimensionType dim);

    // Implementation of the base class interface
    float getValue(const Window& wnd) const;
    float getValue(const Window& wnd, const Rectf& container) const;
    BaseDim* clone() const;

protected:
    // Implementation of the base class interface
    void writeXMLElementName_impl(XMLSerializer& xml_stream) const;
    void writeXMLElementAttributes_impl(XMLSerializer& xml_stream) const;

private:
    String d_property;
    String d_childName;
    DimensionType d_type;
};

class CEGUIEXPORT Dimension :
    public AllocatedObject<Dimension>
{
public:
    Dimension();
    ~Dimension();
    Dimension(const Dimension& other);
    Dimension& operator=(const Dimension& other);

    Dimension(const BaseDim& dim, DimensionType type);

    const BaseDim& getBaseDimension() const;

    void setBaseDimension(const BaseDim& dim);

    DimensionType getDimensionType() const;

    void setDimensionType(DimensionType type);

    void writeXMLToStream(XMLSerializer& xml_stream) const;

    bool handleFontRenderSizeChange(Window& window,
                                    const Font* font) const;

private:
    BaseDim* d_value;
    DimensionType d_type;
};

class CEGUIEXPORT ComponentArea :
    public AllocatedObject<ComponentArea>
{
public:
    ComponentArea();

    Rectf getPixelRect(const Window& wnd) const;

    Rectf getPixelRect(const Window& wnd, const Rectf& container) const;

    void writeXMLToStream(XMLSerializer& xml_stream) const;

    bool isAreaFetchedFromProperty() const;

    const String& getAreaPropertySource() const;

    void setAreaPropertySource(const String& property);

    const String& getNamedAreaSourceLook() const;

    void setNamedAreaSouce(const String& widget_look, const String& area_name);

    bool isAreaFetchedFromNamedArea() const;

    bool handleFontRenderSizeChange(Window& window, const Font* font) const;

    Dimension d_left;
    Dimension d_top;
    Dimension d_right_or_width;
    Dimension d_bottom_or_height;

private:
    String d_namedSource;
    String d_namedAreaSourceLook;
};

} // End of  CEGUI namespace section


#endif  // end of guard _CEGUIFalDimensions_h_