src/irrlicht_changes/static_text.h

   1 // Copyright (C) 2002-2012 Nikolaus Gebhardt
   2 // Copyright (C) 2016 Nathanaël Courant
   3 //   Modified this class to work with EnrichedStrings too
   4 // This file is part of the "Irrlicht Engine".
   5 // For conditions of distribution and use, see copyright notice in irrlicht.h
   6
   7 #pragma once
   8
   9 #include "IrrCompileConfig.h"
  10 #ifdef _IRR_COMPILE_WITH_GUI_
  11
  12 #include "IGUIStaticText.h"
  13 #include "irrArray.h"
  14
  15 #include "log.h"
  16
  17 #include <vector>
  18
  19 #include "util/enriched_string.h"
  20 #include "config.h"
  21 #include <IGUIEnvironment.h>
  22
  23
  24 namespace irr
  25 {
  26
  27 namespace gui
  28 {
  29
  30         const EGUI_ELEMENT_TYPE EGUIET_ENRICHED_STATIC_TEXT = (EGUI_ELEMENT_TYPE)(0x1000);
  31
  32         class StaticText : public IGUIStaticText
  33         {
  34         public:
  35
  36                 // StaticText is translated by EnrichedString.
  37                 // No need to use translate_string()
  38                 StaticText(const EnrichedString &text, bool border, IGUIEnvironment* environment,
  39                         IGUIElement* parent, s32 id, const core::rect<s32>& rectangle,
  40                         bool background = false);
  41
  42                 //! destructor
  43                 virtual ~StaticText();
  44
  45                 static irr::gui::IGUIStaticText *add(
  46                         irr::gui::IGUIEnvironment *guienv,
  47                         const EnrichedString &text,
  48                         const core::rect< s32 > &rectangle,
  49                         bool border = false,
  50                         bool wordWrap = true,
  51                         irr::gui::IGUIElement *parent = NULL,
  52                         s32 id = -1,
  53                         bool fillBackground = false)
  54                 {
  55                         if (parent == NULL) {
  56                                 // parent is NULL, so we must find one, or we need not to drop
  57                                 // result, but then there will be a memory leak.
  58                                 //
  59                                 // What Irrlicht does is to use guienv as a parent, but the problem
  60                                 // is that guienv is here only an IGUIEnvironment, while it is a
  61                                 // CGUIEnvironment in Irrlicht, which inherits from both IGUIElement
  62                                 // and IGUIEnvironment.
  63                                 //
  64                                 // A solution would be to dynamic_cast guienv to a
  65                                 // IGUIElement*, but Irrlicht is shipped without rtti support
  66                                 // in some distributions, causing the dymanic_cast to segfault.
  67                                 //
  68                                 // Thus, to find the parent, we create a dummy StaticText and ask
  69                                 // for its parent, and then remove it.
  70                                 irr::gui::IGUIStaticText *dummy_text =
  71                                         guienv->addStaticText(L"", rectangle, border, wordWrap,
  72                                                 parent, id, fillBackground);
  73                                 parent = dummy_text->getParent();
  74                                 dummy_text->remove();
  75                         }
  76                         irr::gui::IGUIStaticText *result = new irr::gui::StaticText(
  77                                 text, border, guienv, parent,
  78                                 id, rectangle, fillBackground);
  79
  80                         result->setWordWrap(wordWrap);
  81                         result->drop();
  82                         return result;
  83                 }
  84
  85                 static irr::gui::IGUIStaticText *add(
  86                         irr::gui::IGUIEnvironment *guienv,
  87                         const wchar_t *text,
  88                         const core::rect< s32 > &rectangle,
  89                         bool border = false,
  90                         bool wordWrap = true,
  91                         irr::gui::IGUIElement *parent = NULL,
  92                         s32 id = -1,
  93                         bool fillBackground = false)
  94                 {
  95                         return add(guienv, EnrichedString(text), rectangle, border, wordWrap, parent,
  96                                 id, fillBackground);
  97                 }
  98
  99                 //! draws the element and its children
 100                 virtual void draw();
 101
 102                 //! Sets another skin independent font.
 103                 virtual void setOverrideFont(IGUIFont* font=0);
 104
 105                 //! Gets the override font (if any)
 106                 virtual IGUIFont* getOverrideFont() const;
 107
 108                 //! Get the font which is used right now for drawing
 109                 virtual IGUIFont* getActiveFont() const;
 110
 111                 //! Sets another color for the text.
 112                 virtual void setOverrideColor(video::SColor color);
 113
 114                 //! Sets another color for the background.
 115                 virtual void setBackgroundColor(video::SColor color);
 116
 117                 //! Sets whether to draw the background
 118                 virtual void setDrawBackground(bool draw);
 119
 120                 //! Gets the background color
 121                 virtual video::SColor getBackgroundColor() const;
 122
 123                 //! Checks if background drawing is enabled
 124                 virtual bool isDrawBackgroundEnabled() const;
 125
 126                 //! Sets whether to draw the border
 127                 virtual void setDrawBorder(bool draw);
 128
 129                 //! Checks if border drawing is enabled
 130                 virtual bool isDrawBorderEnabled() const;
 131
 132                 //! Sets alignment mode for text
 133                 virtual void setTextAlignment(EGUI_ALIGNMENT horizontal, EGUI_ALIGNMENT vertical);
 134
 135                 //! Gets the override color
 136                 virtual video::SColor getOverrideColor() const;
 137
 138                 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR > 8
 139                 //! Gets the currently used text color
 140                 virtual video::SColor getActiveColor() const;
 141                 #endif
 142
 143                 //! Sets if the static text should use the overide color or the
 144                 //! color in the gui skin.
 145                 virtual void enableOverrideColor(bool enable);
 146
 147                 //! Checks if an override color is enabled
 148                 virtual bool isOverrideColorEnabled() const;
 149
 150                 //! Set whether the text in this label should be clipped if it goes outside bounds
 151                 virtual void setTextRestrainedInside(bool restrainedInside);
 152
 153                 //! Checks if the text in this label should be clipped if it goes outside bounds
 154                 virtual bool isTextRestrainedInside() const;
 155
 156                 //! Enables or disables word wrap for using the static text as
 157                 //! multiline text control.
 158                 virtual void setWordWrap(bool enable);
 159
 160                 //! Checks if word wrap is enabled
 161                 virtual bool isWordWrapEnabled() const;
 162
 163                 //! Sets the new caption of this element.
 164                 virtual void setText(const wchar_t* text);
 165
 166                 //! Returns the height of the text in pixels when it is drawn.
 167                 virtual s32 getTextHeight() const;
 168
 169                 //! Returns the width of the current text, in the current font
 170                 virtual s32 getTextWidth() const;
 171
 172                 //! Updates the absolute position, splits text if word wrap is enabled
 173                 virtual void updateAbsolutePosition();
 174
 175                 //! Set whether the string should be interpreted as right-to-left (RTL) text
 176                 /** \note This component does not implement the Unicode bidi standard, the
 177                 text of the component should be already RTL if you call this. The
 178                 main difference when RTL is enabled is that the linebreaks for multiline
 179                 elements are performed starting from the end.
 180                 */
 181                 virtual void setRightToLeft(bool rtl);
 182
 183                 //! Checks if the text should be interpreted as right-to-left text
 184                 virtual bool isRightToLeft() const;
 185
 186                 virtual bool hasType(EGUI_ELEMENT_TYPE t) const {
 187                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 188                 };
 189
 190                 virtual bool hasType(EGUI_ELEMENT_TYPE t) {
 191                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 192                 };
 193
 194                 void setText(const EnrichedString &text);
 195
 196         private:
 197
 198                 //! Breaks the single text line.
 199                 void updateText();
 200
 201                 EGUI_ALIGNMENT HAlign, VAlign;
 202                 bool Border;
 203                 bool WordWrap;
 204                 bool Background;
 205                 bool RestrainTextInside;
 206                 bool RightToLeft;
 207
 208                 gui::IGUIFont* OverrideFont;
 209                 gui::IGUIFont* LastBreakFont; // stored because: if skin changes, line break must be recalculated.
 210
 211                 EnrichedString ColoredText;
 212                 std::vector<EnrichedString> BrokenText;
 213         };
 214
 215
 216 } // end namespace gui
 217
 218 } // end namespace irr
 219
 220 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
 221 {
 222         // dynamic_cast not possible due to some distributions shipped
 223         // without rtti support in irrlicht
 224         if (static_text->hasType(irr::gui::EGUIET_ENRICHED_STATIC_TEXT)) {
 225                 irr::gui::StaticText* stext = static_cast<irr::gui::StaticText*>(static_text);
 226                 stext->setText(text);
 227         } else {
 228                 static_text->setText(text.c_str());
 229         }
 230 }
 231
 232 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const wchar_t *text)
 233 {
 234         setStaticText(static_text, EnrichedString(text, static_text->getOverrideColor()));
 235 }
 236
 237 #endif // _IRR_COMPILE_WITH_GUI_