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                 //! constructor
  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                 #if IRRLICHT_VERSION_MAJOR == 1 && IRRLICHT_VERSION_MINOR <= 7
 137                 virtual const video::SColor& getOverrideColor() const;
 138                 #else
 139                 virtual video::SColor getOverrideColor() const;
 140                 #endif
 141
 142                 //! Sets if the static text should use the overide color or the
 143                 //! color in the gui skin.
 144                 virtual void enableOverrideColor(bool enable);
 145
 146                 //! Checks if an override color is enabled
 147                 virtual bool isOverrideColorEnabled() const;
 148
 149                 //! Set whether the text in this label should be clipped if it goes outside bounds
 150                 virtual void setTextRestrainedInside(bool restrainedInside);
 151
 152                 //! Checks if the text in this label should be clipped if it goes outside bounds
 153                 virtual bool isTextRestrainedInside() const;
 154
 155                 //! Enables or disables word wrap for using the static text as
 156                 //! multiline text control.
 157                 virtual void setWordWrap(bool enable);
 158
 159                 //! Checks if word wrap is enabled
 160                 virtual bool isWordWrapEnabled() const;
 161
 162                 //! Sets the new caption of this element.
 163                 virtual void setText(const wchar_t* text);
 164
 165                 //! Returns the height of the text in pixels when it is drawn.
 166                 virtual s32 getTextHeight() const;
 167
 168                 //! Returns the width of the current text, in the current font
 169                 virtual s32 getTextWidth() const;
 170
 171                 //! Updates the absolute position, splits text if word wrap is enabled
 172                 virtual void updateAbsolutePosition();
 173
 174                 //! Set whether the string should be interpreted as right-to-left (RTL) text
 175                 /** \note This component does not implement the Unicode bidi standard, the
 176                 text of the component should be already RTL if you call this. The
 177                 main difference when RTL is enabled is that the linebreaks for multiline
 178                 elements are performed starting from the end.
 179                 */
 180                 virtual void setRightToLeft(bool rtl);
 181
 182                 //! Checks if the text should be interpreted as right-to-left text
 183                 virtual bool isRightToLeft() const;
 184
 185                 //! Writes attributes of the element.
 186                 virtual void serializeAttributes(io::IAttributes* out, io::SAttributeReadWriteOptions* options) const;
 187
 188                 //! Reads attributes of the element
 189                 virtual void deserializeAttributes(io::IAttributes* in, io::SAttributeReadWriteOptions* options);
 190
 191                 virtual bool hasType(EGUI_ELEMENT_TYPE t) const {
 192                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 193                 };
 194
 195                 virtual bool hasType(EGUI_ELEMENT_TYPE t) {
 196                         return (t == EGUIET_ENRICHED_STATIC_TEXT) || (t == EGUIET_STATIC_TEXT);
 197                 };
 198
 199                 void setText(const EnrichedString &text);
 200
 201         private:
 202
 203                 //! Breaks the single text line.
 204                 void breakText();
 205
 206                 EGUI_ALIGNMENT HAlign, VAlign;
 207                 bool Border;
 208                 bool OverrideColorEnabled;
 209                 bool OverrideBGColorEnabled;
 210                 bool WordWrap;
 211                 bool Background;
 212                 bool RestrainTextInside;
 213                 bool RightToLeft;
 214
 215                 video::SColor OverrideColor, BGColor;
 216                 gui::IGUIFont* OverrideFont;
 217                 gui::IGUIFont* LastBreakFont; // stored because: if skin changes, line break must be recalculated.
 218
 219                 EnrichedString cText;
 220                 core::array< EnrichedString > BrokenText;
 221         };
 222
 223
 224 } // end namespace gui
 225
 226 } // end namespace irr
 227
 228 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
 229 {
 230         // dynamic_cast not possible due to some distributions shipped
 231         // without rtti support in irrlicht
 232         if (static_text->hasType(irr::gui::EGUIET_ENRICHED_STATIC_TEXT)) {
 233                 irr::gui::StaticText* stext = static_cast<irr::gui::StaticText*>(static_text);
 234                 stext->setText(text);
 235         } else {
 236                 static_text->setText(text.c_str());
 237         }
 238 }
 239
 240 #else // USE_FREETYPE
 241
 242 namespace irr
 243 {
 244 namespace gui
 245 {
 246
 247 class StaticText
 248 {
 249 public:
 250         static irr::gui::IGUIStaticText *add(
 251                 irr::gui::IGUIEnvironment *guienv,
 252                 const EnrichedString &text,
 253                 const core::rect< s32 > &rectangle,
 254                 bool border = false,
 255                 bool wordWrap = true,
 256                 irr::gui::IGUIElement *parent = NULL,
 257                 s32 id = -1,
 258                 bool fillBackground = false)
 259         {
 260                 return guienv->addStaticText(text.c_str(), rectangle, border, wordWrap, parent, id, fillBackground);
 261         }
 262 };
 263
 264 } // end namespace gui
 265
 266 } // end namespace irr
 267
 268 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const EnrichedString &text)
 269 {
 270         static_text->setText(text.c_str());
 271 }
 272
 273 #endif
 274
 275 inline void setStaticText(irr::gui::IGUIStaticText *static_text, const wchar_t *text)
 276 {
 277         auto color = static_text->isOverrideColorEnabled()
 278                                      ? static_text->getOverrideColor()
 279                                      : irr::video::SColor(255, 255, 255, 255);
 280         setStaticText(static_text, EnrichedString(text, color));
 281 }
 282
 283 #endif // _IRR_COMPILE_WITH_GUI_