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                 virtual bool hasType(EGUI_ELEMENT_TYPE t) const {
 188                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 189                 };
 190
 191                 virtual bool hasType(EGUI_ELEMENT_TYPE t) {
 192                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 193                 };
 194
 195                 void setText(const EnrichedString &text);
 196
 197         private:
 198
 199                 //! Breaks the single text line.
 200                 void updateText();
 201
 202                 EGUI_ALIGNMENT HAlign, VAlign;
 203                 bool Border;
 204                 bool WordWrap;
 205                 bool Background;
 206                 bool RestrainTextInside;
 207                 bool RightToLeft;
 208
 209                 gui::IGUIFont* OverrideFont;
 210                 gui::IGUIFont* LastBreakFont; // stored because: if skin changes, line break must be recalculated.
 211
 212                 EnrichedString ColoredText;
 213                 std::vector<EnrichedString> BrokenText;
 214         };
 215
 216
 217 } // end namespace gui
 218
 219 } // end namespace irr
 220
 221 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
 222 {
 223         // dynamic_cast not possible due to some distributions shipped
 224         // without rtti support in irrlicht
 225         if (static_text->hasType(irr::gui::EGUIET_ENRICHED_STATIC_TEXT)) {
 226                 irr::gui::StaticText* stext = static_cast<irr::gui::StaticText*>(static_text);
 227                 stext->setText(text);
 228         } else {
 229                 static_text->setText(text.c_str());
 230         }
 231 }
 232
 233 #else // USE_FREETYPE
 234
 235 namespace irr
 236 {
 237 namespace gui
 238 {
 239
 240 class StaticText
 241 {
 242 public:
 243         static irr::gui::IGUIStaticText *add(
 244                 irr::gui::IGUIEnvironment *guienv,
 245                 const EnrichedString &text,
 246                 const core::rect< s32 > &rectangle,
 247                 bool border = false,
 248                 bool wordWrap = true,
 249                 irr::gui::IGUIElement *parent = NULL,
 250                 s32 id = -1,
 251                 bool fillBackground = false)
 252         {
 253                 return guienv->addStaticText(text.c_str(), rectangle, border, wordWrap, parent, id, fillBackground);
 254         }
 255 };
 256
 257 } // end namespace gui
 258
 259 } // end namespace irr
 260
 261 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
 262 {
 263         static_text->setText(text.c_str());
 264 }
 265
 266 #endif
 267
 268 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const wchar_t *text)
 269 {
 270         setStaticText(static_text, EnrichedString(text, static_text->getOverrideColor()));
 271 }
 272
 273 #endif // _IRR_COMPILE_WITH_GUI_