GDevelop/Extensions/TextObject/TextObject.h

/**

GDevelop - Text Object Extension
Copyright (c) 2008-2014 Florian Rival (Florian.Rival@gmail.com)
This project is released under the MIT License.
*/

#ifndef TEXTOBJECT_H
#define TEXTOBJECT_H

#include <SFML/Graphics/Text.hpp>
#include "GDCpp/Object.h"
#include "GDCpp/RuntimeObject.h"
class ImageManager;
class RuntimeScene;
namespace gd { class Object; }
namespace gd { class ImageManager; }
namespace gd { class InitialInstance; }
#if defined(GD_IDE_ONLY)
class wxBitmap;
namespace gd { class Project; }
class wxWindow;
namespace gd { class MainFrameWrapper; }
namespace gd {class ResourcesMergingHelper;}
#endif

/**
 * Text Object
 */
class GD_EXTENSION_API TextObject : public gd::Object
{
public :

    TextObject(std::string name_);
    virtual ~TextObject();
    virtual gd::Object * Clone() const { return new TextObject(*this); }

    #if defined(GD_IDE_ONLY)
    virtual void DrawInitialInstance(gd::InitialInstance & instance, sf::RenderTarget & renderTarget, gd::Project & project, gd::Layout & layout);
    virtual sf::Vector2f GetInitialInstanceDefaultSize(gd::InitialInstance & instance, gd::Project & project, gd::Layout & layout) const;
    virtual void ExposeResources(gd::ArbitraryResourceWorker & worker);
    virtual bool GenerateThumbnail(const gd::Project & project, wxBitmap & thumbnail) const;
    virtual void EditObject( wxWindow* parent, gd::Project & game_, gd::MainFrameWrapper & mainFrameWrapper_ );
    virtual void LoadResources(gd::Project & project, gd::Layout & layout);
    #endif

    /** \brief Change the text.
     */
    inline void SetString(const std::string & str) { text = str; };

    /** \brief Get the text.
     */
    inline std::string GetString() const { return text; };

    /** \brief Change the character size.
     */
    inline void SetCharacterSize(float size) { characterSize = size; };

    /** \brief Get the character size.
     */
    inline float GetCharacterSize() const { return characterSize; };

    /** \brief Return the font filename.
     */
    inline std::string GetFontFilename() const {return fontName; };

    /** \brief Change the font filename.
     */
    void SetFontFilename(const std::string & fontFilename);

    bool IsBold() const { return bold; };
    void SetBold(bool enable) { bold = enable; };
    bool IsItalic() const { return italic; };
    void SetItalic(bool enable) { italic = enable; };
    bool IsUnderlined() const { return underlined; };
    void SetUnderlined(bool enable) { underlined = enable; };

    void SetSmooth(bool smooth) { smoothed = smooth; };
    bool IsSmoothed() const {return smoothed;};

    void SetColor(unsigned int r, unsigned int g, unsigned int b) { colorR = r; colorG = g; colorB = b; };
    unsigned int GetColorR() const { return colorR; };
    unsigned int GetColorG() const { return colorG; };
    unsigned int GetColorB() const { return colorB; };

private:

    virtual void DoUnserializeFrom(gd::Project & project, const gd::SerializerElement & element);
    #if defined(GD_IDE_ONLY)
    virtual void DoSerializeTo(gd::SerializerElement & element) const;
    #endif

    std::string text;
    float characterSize;
    std::string fontName;
    bool smoothed;
    bool bold, italic, underlined;
    unsigned int colorR;
    unsigned int colorG;
    unsigned int colorB;
    #if defined(GD_IDE_ONLY)
    const sf::Font * font; ///< The font used to render the object in the IDE. This is just a pointer to a font stored in the FontManager.
    #endif
};

class GD_EXTENSION_API RuntimeTextObject : public RuntimeObject
{
public :

    RuntimeTextObject(RuntimeScene & scene, const gd::Object & object);
    virtual ~RuntimeTextObject() {};
    virtual RuntimeObject * Clone() const { return new RuntimeTextObject(*this);}

    virtual bool Draw(sf::RenderTarget & renderTarget);

    virtual void OnPositionChanged();

    virtual float GetWidth() const;
    virtual float GetHeight() const;

    virtual float GetDrawableX() const;
    virtual float GetDrawableY() const;

    virtual bool SetAngle(float newAngle) { angle = newAngle; text.setRotation(angle); return true;};
    virtual float GetAngle() const {return angle;};

    inline void SetString(const std::string & str) { text.setString(str); text.setOrigin(text.getLocalBounds().width/2, text.getLocalBounds().height/2); };
    inline std::string GetString() const {return text.getString();};

    inline void SetCharacterSize(float size) { text.setCharacterSize(size); text.setOrigin(text.getLocalBounds().width/2, text.getLocalBounds().height/2); };
    inline float GetCharacterSize() const { return text.getCharacterSize(); };

    /** \brief Change the text object font filename and reload the font
     */
    void ChangeFont(const std::string & fontFilename);

    /** \brief Return the font file name.
     */
    inline std::string GetFontFilename() const {return fontName; };

    void SetFontStyle(int style);
    int GetFontStyle();
    bool HasFontStyle(sf::Text::Style style);

    bool IsBold();
    void SetBold(bool bold);
    bool IsItalic();
    void SetItalic(bool italic);
    bool IsUnderlined();
    void SetUnderlined(bool underlined);

    void SetSmooth(bool smooth);
    bool IsSmoothed() const {return smoothed;};

    void SetOpacity(float val);
    float GetOpacity() const { return opacity; };

    void SetColor(unsigned int r, unsigned int g, unsigned int b);
    void SetColor(const std::string & colorStr);
    unsigned int GetColorR() const { return text.getColor().r; };
    unsigned int GetColorG() const { return text.getColor().g; };
    unsigned int GetColorB() const { return text.getColor().b; };

    virtual std::vector<Polygon2d> GetHitBoxes() const;

    #if defined(GD_IDE_ONLY)
    virtual void GetPropertyForDebugger (unsigned int propertyNb, std::string & name, std::string & value) const;
    virtual bool ChangeProperty(unsigned int propertyNb, std::string newValue);
    virtual unsigned int GetNumberOfProperties() const;
    #endif

private:
    sf::Text text;
    std::string fontName;
    float opacity;
    bool smoothed;
    float angle;
};

void DestroyTextObject(gd::Object * object);
gd::Object * CreateTextObject(std::string name);

void DestroyRuntimeTextObject(RuntimeObject * object);
RuntimeObject * CreateRuntimeTextObject(RuntimeScene & scene, const gd::Object & object);

#endif // TEXTOBJECT_H