static_text.h

Go to the documentation of this file.

// Copyright (C) 2002-2012 Nikolaus Gebhardt
// Copyright (C) 2016 Nathanaëlle Courant
//   Modified this class to work with EnrichedStrings too
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
 
#pragma once
 
#include "IGUIStaticText.h"
#include "irrArray.h"
 
#include "log.h"
 
#include <vector>
 
#include "util/enriched_string.h"
#include "config.h"
#include <IGUIEnvironment.h>
 
 
namespace irr
{
 
namespace gui
{
 
        const EGUI_ELEMENT_TYPE EGUIET_ENRICHED_STATIC_TEXT = (EGUI_ELEMENT_TYPE)(0x1000);
 
        class StaticText : public IGUIStaticText
        {
        public:
 
                // StaticText is translated by EnrichedString.
                // No need to use translate_string()
                StaticText(const EnrichedString &text, bool border, IGUIEnvironment* environment,
                        IGUIElement* parent, s32 id, const core::rect<s32>& rectangle,
                        bool background = false);
 
                virtual ~StaticText();
 
                static irr::gui::IGUIStaticText *add(
                        irr::gui::IGUIEnvironment *guienv,
                        const EnrichedString &text,
                        const core::rect< s32 > &rectangle,
                        bool border = false,
                        bool wordWrap = true,
                        irr::gui::IGUIElement *parent = NULL,
                        s32 id = -1,
                        bool fillBackground = false)
                {
                        parent = parent ? parent : guienv->getRootGUIElement();
                        irr::gui::IGUIStaticText *result = new irr::gui::StaticText(
                                text, border, guienv, parent,
                                id, rectangle, fillBackground);
 
                        result->setWordWrap(wordWrap);
                        result->drop();
                        return result;
                }
 
                static irr::gui::IGUIStaticText *add(
                        irr::gui::IGUIEnvironment *guienv,
                        std::wstring_view text,
                        const core::rect< s32 > &rectangle,
                        bool border = false,
                        bool wordWrap = true,
                        irr::gui::IGUIElement *parent = NULL,
                        s32 id = -1,
                        bool fillBackground = false)
                {
                        return add(guienv, EnrichedString(text), rectangle, border, wordWrap, parent,
                                id, fillBackground);
                }
 
                virtual void draw();
 
                virtual void setOverrideFont(IGUIFont* font=0);
 
                virtual IGUIFont* getOverrideFont() const;
 
                virtual IGUIFont* getActiveFont() const;
 
                virtual void setOverrideColor(video::SColor color);
 
                virtual void setBackgroundColor(video::SColor color);
 
                virtual void setDrawBackground(bool draw);
 
                virtual video::SColor getBackgroundColor() const;
 
                virtual bool isDrawBackgroundEnabled() const;
 
                virtual void setDrawBorder(bool draw);
 
                virtual bool isDrawBorderEnabled() const;
 
                virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
 
                virtual video::SColor getOverrideColor() const;
 
                virtual video::SColor getActiveColor() const;
 
                virtual void enableOverrideColor(bool enable);
 
                virtual bool isOverrideColorEnabled() const;
 
                virtual void setTextRestrainedInside(bool restrainedInside);
 
                virtual bool isTextRestrainedInside() const;
 
                virtual void setWordWrap(bool enable);
 
                virtual bool isWordWrapEnabled() const;
 
                virtual void setText(const wchar_t* text);
 
                virtual s32 getTextHeight() const;
 
                virtual s32 getTextWidth() const;
 
                virtual void updateAbsolutePosition();
 
 
                virtual void setRightToLeft(bool rtl);
 
                virtual bool isRightToLeft() const;
 
                virtual bool hasType(EGUI_ELEMENT_TYPE t) const {
                        return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
                };
 
                virtual bool hasType(EGUI_ELEMENT_TYPE t) {
                        return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
                };
 
                void setText(const EnrichedString &text);
 
        private:
 
                void updateText();
 
                EGUI_ALIGNMENT HAlign, VAlign;
                bool Border;
                bool WordWrap;
                bool Background;
                bool RestrainTextInside;
                bool RightToLeft;
 
                gui::IGUIFont* OverrideFont;
                gui::IGUIFont* LastBreakFont; // stored because: if skin changes, line break must be recalculated.
 
                EnrichedString ColoredText;
                std::vector<EnrichedString> BrokenText;
        };
 
 
} // end namespace gui
 
} // end namespace irr
 
inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
{
        // dynamic_cast not possible due to some distributions shipped
        // without rtti support in irrlicht
        if (static_text->hasType(irr::gui::EGUIET_ENRICHED_STATIC_TEXT)) {
                irr::gui::StaticText* stext = static_cast<irr::gui::StaticText*>(static_text);
                stext->setText(text);
        } else {
                static_text->setText(text.c_str());
        }
}
 
inline void setStaticText(irr::gui::IGUIStaticText *static_text, std::wstring_view text)
{
        setStaticText(static_text, EnrichedString(text, static_text->getOverrideColor()));
}