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